AI-translated from English; not yet reviewed by a fluent editor. # முகவரின் வெளியீட்டை மதிப்பாய்வு செய்த செயல்பதிவாக மாற்றவும் > உங்கள் குறிப்புகளிலிருந்து OpenAI Agents SDK மூலம் வகை நிர்ணயித்த முடிவை உருவாக்கி, மூல ஆதாரங்களையும் பொருளையும் மதிப்பாய்வு செய்து, ஏற்ற முடிவை ஹாஷ்களை மீள்படித்துச் சரிபார்க்கும் உள்ளூர் Markdown செயல்பதிவுக்கு அனுப்புங்கள். By BIG CHANGE Editorial Published: 2026-10-20T12:52:38.610Z Updated: 2026-10-20T12:52:38.610Z Canonical: https://bigchange.ai/blog/agents-sdk-reviewed-action-register-guide ![Conceptual charcoal illustration of one person holding a larger blank ruled source page and a smaller blank candidate page, with an orange reading strip across the source.](https://bigchange.ai/api/media/file/source-candidate-human-review-hero-v2.png) AI-generated conceptual illustration by BIG CHANGE. முகவரின் முடிவில் JSON வடிவம் சரியாக இருந்தும் மூலத்தைத் தவறாகப் புரிந்திருக்கலாம். இந்த வழிகாட்டி Python உருவாக்குநருக்கு அனுமதித்த ஒரு குறிப்புக் கோப்பிலிருந்து உள்ளூர் செயல்பதிவு வரை முழுப் பாதையைத் தருகிறது: வகை நிர்ணயித்த உற்பத்தியாளர் முடிவு, மூலம் மற்றும் பொருள் சோதனைகள், துல்லியமான ஹாஷ்களுக்கு மனித ஒப்புதல், குழுவாக்கிய Markdown அறிக்கையை எழுதி மீள்படிக்கும் நுகர்வோர். வெளிப்படையான செயல் உறுதிகள் கொண்ட சொந்தக் குறிப்புகளைப் பயன்படுத்துங்கள். தயாரிப்பில் உண்மைக் குறிப்புகளோ மாதிரி முடிவோ பயன்படுத்தப்படவில்லை. ## பெரிய மாற்றம் - **என்ன மாறியது:** OpenAI Agents SDK ஒரு Pydantic `output_type`ஐ ஏற்கிறது. எனவே பயன்பாடு வரையறுத்த முடிவைக் கேட்டு, பயன்படுத்துமுன் மீண்டும் சோதிக்கலாம். எடுத்துக்காட்டு முடிவுடன் மூல மேற்கோள்களையும் பதிப்புள்ள ஒப்பந்தத்தையும் சேர்க்கிறது. - **ஏன் முக்கியம்:** முகவரை அடுத்த படியுடன் இணைக்கும் உருவாக்குநர் தவறான வடிவம், முழுமையற்ற அல்லது ஆதாரமற்ற வெளியீடு செயல் பட்டியலாவதற்கு முன் நிறுத்தலாம். மேற்கோள் குறிப்புகள் ஒவ்வொரு பணி, பொறுப்பாளர், தேதியை உண்மையில் ஆதரிக்கிறதா, மாதிரி எதையாவது விட்டுவிட்டதா என்பதை மனிதர் இன்னும் மதிப்பிட வேண்டும். - **கவனிக்க வேண்டியது:** முடிவு நுகர்வோர் எல்லையில் எடுக்கப்படுகிறது. துல்லியமான இயக்கம், மூலம், வேட்பாளர் ஒப்புதலுக்குப் பிறகே இந்த முறை உள்ளூர் வகைப்படுத்தல் பதிவைச் செய்கிறது. பிறகு பணிமுறையில் இறக்குமதிக்கு தனி அதிகாரம், மறுமுயற்சிக் கொள்கை, இலக்கில் மீள்படித்தல் தேவை. ## அனுமதித்த ஒரு மூலத்தைத் தயார் செய்யவும் Python 3.12, குறிப்புகளுக்கு அனுமதித்த OpenAI API கணக்கு, அசலைப் படிக்கக்கூடிய மதிப்பாய்வாளர், கணக்கில் தற்போது JSON-schema கட்டமைந்த வெளியீடு ஆதரிப்பதை உறுதிசெய்த மாதிரி தேவை. உற்பத்தியாளரை இயக்கும் முன் தரவு விதிகளையும் இன்றைய விலைகளையும் பார்க்கவும். சான்றுகளைக் குறிப்பிலோ ஒப்புதல் கோப்பிலோ வைக்காதீர்கள். கீழே ஒரே மாதிரி அழைப்பு `produce`; மற்றவை உள்ளூர் செயலாக்கம். அசல் குறிப்புகளை UTF-8 ஆக `notes.txt`இல் வையுங்கள். உங்கள் பணியின் உண்மையான வெளிப்படையான செயல் உறுதிகள் இருக்க வேண்டும். சொந்தப் பதிவு அடையாளம் போன்ற நிலையான `source_id`ஐ அளித்து, மதிப்பாய்வு மற்றும் பயன்பாடு வரை ஒவ்வொரு பைட்டையும் மாற்றாமல் வையுங்கள். உருவாக்குமுன் `candidate/` என்ற அடைவை உருவாக்குங்கள்; வேட்பாளர் கோப்பு புதிதாக இருக்க வேண்டும். பின்னர் உள்ளூர் அறிக்கைக்குத் தனி வெளியீட்டு அடைவு வையுங்கள். இயக்குமுன் மூல பைட்களின் ஹாஷைப் பதிவு செய்யுங்கள்: ```sh python -c "from pathlib import Path; import hashlib; print(hashlib.sha256(Path('notes.txt').read_bytes()).hexdigest())" ``` தனித்த Python 3.12 சூழலில் `recipe-requirements.txt` என்ற கோப்பை உருவாக்கி, சரியாக இந்த வரிகளை வைத்து நிறுவுங்கள்: ```text openai-agents==0.24.0 pydantic==2.14.1 ``` ```sh python -m pip install -r recipe-requirements.txt mkdir candidate ``` இந்தப் பதிப்புகள் 20 அக்டோபர் 2026 அன்று உள்ளூர் Python 3.12.7 சூழலில் ஒன்றாக நிறுவப்பட்டன. பயன்படுத்தும்போது இணக்கத்தையும் மாதிரி கிடைப்பதையும் உறுதிப்படுத்துங்கள். கீழே முழு ஸ்கிரிப்டை `action_register_recipe.py` என்ற பெயரில் அதே அடைவில் சேமியுங்கள். இரண்டு கட்டளைகள் உள்ளன: `produce` வேட்பாளர் மற்றும் இயக்க ரசீதை உருவாக்கும்; `consume` சரிபார்ப்புக்கும் ஒப்புதலுக்கும் பிறகே அறிக்கையை உருவாக்கும். ## வகை நிர்ணயித்த உற்பத்தியாளரை இயக்கவும் இந்த `Extraction` ஒப்பந்தத்திற்கு பதிப்பு `action-register/v1`, நிலை `ready`, `partial` அல்லது `blocked`, மூல ID, துல்லியமான கோப்பு பைட்களின் SHA-256, செயல்கள் மற்றும் `gap_note` தேவை. ஒவ்வொரு செயலுக்கும் உரை, துல்லிய மேற்கோள், 1இலிருந்து எண்ணும் மூல வரி எல்லை, null ஆகக்கூடிய பொறுப்பாளர் மற்றும் தேதி, மேலும் `complete` அல்லது `needs_review` ஆதார நிலை தேவை. பொறுப்பாளர் அல்லது தேதி null என்பது குறிப்புகளில் இல்லை என்பதாகும். இரண்டையும் ஊகிக்க வேண்டாம் என மாதிரிக்கு அறிவுறுத்தப்படுகிறது. எல்லாப் புலங்களும் கட்டாயம்; கூடுதல் புலங்கள் மறுக்கப்படும். கட்டமைந்த வெளியீட்டு மாதிரியை வெளிப்படையாகத் தேர்ந்தெடுங்கள். சொந்த அனுமதித்த பாதையையும் அடையாளத்தையும் தாருங்கள்: ```sh python action_register_recipe.py produce --source-id OWNED-ID --source notes.txt --candidate candidate/actions.json --model YOUR-STRUCTURED-OUTPUT-MODEL ``` இதைப் படியுங்கள்: `candidate/actions.json` மற்றும் அருகிலுள்ள `candidate/actions.run.json`. இரண்டாவது கோப்பு UUID இயக்க ID, மூலம் மற்றும் வேட்பாளர் ஹாஷ்கள், முடித்த முகவர், கோரிய மாதிரியைப் பதிவு செய்கிறது. தோல்வியில் மாற்றாக இயக்க ID பின்னொட்டு கொண்ட `.failure.json` பிழையறிதல் பதிவு உருவாகும். இடையீடு, `None` அல்லது சாதாரண சரம் இறுதி வெளியீடு, எதிர்பாராத இறுதி முகவர் ஆகியவை வெற்றியாகாது. இந்தக் கட்டளை SDKஇன் தொடரக்கூடிய நிலையான `RunState`ஐச் சேமிக்காது; தோல்வி ரசீதிலிருந்து இயக்கத்தைத் தொடர முடியாது. புதிய இயக்கம் பொருத்தமா எனத் தீர்மானிக்குமுன் கோரிக்கை, வேட்பாளர், அடுத்த நிலையைப் பாருங்கள். ## பொருளை மதிப்பாய்வு செய்து துல்லிய வேட்பாளரை ஒப்புக்கொள்ளவும் பயன்பாடு கடுமையான வகைகள், கட்டாயப் புலங்கள், மூல அடையாளம், தயார்நிலை, குறைந்தது ஒரு முழுச் செயல், செல்லுபடியாகும் வரி எல்லை, அதில் மேற்கோள், காலியில்லாத பணி அல்லது பொறுப்பாளர், நிலையான `YYYY-MM-DD` தேதிகளைச் சோதிக்கிறது. இது அமைப்பையும் மேற்கோளின் இடத்தையும் நிரூபிக்கும். வாக்கியம் உண்மையான உறுதியா, பெயர் அல்லது தேதி கூறிய பொருள்தானா, அனைத்து உறுதிகளும் கண்டுபிடிக்கப்பட்டனவா என்பதைக் காட்டாது. அசல் குறிப்புகளையும் ஒவ்வொரு முன்மொழிந்த செயலையும் படியுங்கள். பொருள், பொறுப்பாளர், தேதி, மேற்கோள், விடுபட்டவற்றை ஒப்பிடுங்கள். மூல அல்லது வேட்பாளர் குழப்பத்தைப் புதிய மதிப்பாய்வு செய்த இயக்கத்தில் தீர்த்து, ஆதாரமற்ற, பகுதியான அல்லது தடுக்கப்பட்ட வேட்பாளரை ஒப்புக்கொள்ளாதீர்கள். மாறாத கோப்பும் வேட்பாளரும் `actions.run.json`உடன் பொருந்துவதைப் பார்த்து `approval.json` என்ற கோப்பைச் சரியாக இந்த ஏழு விசைகளுடன் எழுதுங்கள். சோதித்த ரசீதிலிருந்து இயக்க ID மற்றும் ஹாஷ்களை நகலெடுங்கள். மதிப்பாய்வாளரின் உண்மையான அடையாளம், உண்மையில் செய்த சோதனைகளின் தெளிவான விளக்கத்தைப் பயன்படுத்துங்கள்: ```json { "approved": true, "run_id": "COPY-RUN-ID", "source_id": "OWNED-ID", "source_sha256": "COPY-SOURCE-SHA256", "payload_sha256": "COPY-PAYLOAD-SHA256", "reviewer": "YOUR-REVIEWER-ID", "review_note": "Describe the source, task, owner, date, quotation and omission checks actually performed." } ``` `approved` என்பது JSON பூலியன் `true` ஆக இருக்க வேண்டும்; சரம் அல்லது எண் அல்ல. மற்ற மதிப்புகள் சரங்கள்; மதிப்பாய்வாளர் மற்றும் குறிப்பு காலியில்லாமல் இருக்க வேண்டும். கூடுதல் புலங்கள் தோல்வியடையும். ஒப்புதல் ஒரு வேட்பாளரையும் மூலத் திருத்தத்தையும் பிணைக்கிறது; எதிர்கால மறுஎழுத்தை அல்ல. ## பயன்படுத்தி அறிக்கையை மீண்டும் படிக்கவும் ```sh python action_register_recipe.py consume --source-id OWNED-ID --source notes.txt --candidate candidate/actions.json --approval approval.json --out private-output ``` நுகர்வோர் ஏற்ற செயல்களை **Assigned with dates**, **Needs an owner** மற்றும் **Needs a date** என்று பிரிக்கிறது. ஒவ்வொரு பதிவிலும் பணி, பொறுப்பாளர்/தேதி நிலை, மேற்கோள், மூல வரிகள் உள்ளன. அது `action-register-.md` மற்றும் அருகிலுள்ள `.receipt.json` என்ற கோப்பை எழுதுகிறது; அவற்றில் இயக்கம், மூலம், வேட்பாளர், அறிக்கை ஹாஷ்கள் உள்ளன. இரண்டையும் திறந்து மேற்கோள் செயல்களைக் குறிப்புகளுடன் ஒப்பிட்டு `report_sha256` என்பதை Markdown கோப்பு பைட்களுடன் சரிபார்க்கவும். சரியான ரசீது உள்ளூர் கோப்பை உருவாக்கி மீள்படித்ததை மட்டுமே குறிக்கிறது; வெளிப் பணிமுறையில் எழுத ஒப்புதல் அல்ல. பயன்பாட்டு கட்டளை அறிக்கை மற்றும் ரசீதின் உண்மைப் பாதைகளைக் காட்டும். அவற்றை பைட் சோதனைக்குப் பயன்படுத்துங்கள்: ```sh python -c "from pathlib import Path; import hashlib,json,sys; report=Path(sys.argv[1]); receipt=json.loads(Path(sys.argv[2]).read_text(encoding='utf-8')); assert hashlib.sha256(report.read_bytes()).hexdigest()==receipt['report_sha256']; print('report hash matches receipt')" PATH-PRINTED-FOR-REPORT PATH-PRINTED-FOR-RECEIPT ``` வேட்பாளர் கிடைத்ததும் தெளிவான செயற்கை அமைப்பு மாதிரியால் மறுப்பு வழியைச் சோதியுங்கள். JSONஐ தனிக் கோப்பில் நகலெடுத்து, முதல் செயலின் ஒரு கட்டாயப் புலத்தை நீக்கி `consume` என்ற கட்டளையைத் தவறான கோப்புடனும் புதிய காலி வெளியீட்டு அடைவுடனும் இயக்குங்கள். கோப்பு உருவாகுமுன் தோல்வியடைய வேண்டும். மாதிரியை உண்மைத் தகவல் எடுப்பாகக் கருதவோ ஒப்புக்கொள்ளவோ வேண்டாம். உதாரணமாக அடுத்த உள்ளூர் சோதனை நகலிலிருந்து `evidence_quote` என்ற புலத்தை நீக்கும்: ```sh python -c "import json; from pathlib import Path; p=json.loads(Path('candidate/actions.json').read_text(encoding='utf-8')); p['actions'][0].pop('evidence_quote'); Path('candidate/SYNTHETIC-malformed.json').write_text(json.dumps(p), encoding='utf-8')" python action_register_recipe.py consume --source-id OWNED-ID --source notes.txt --candidate candidate/SYNTHETIC-malformed.json --approval approval.json --out synthetic-rejection-output ``` இரண்டாவது கட்டளை தோல்வியடையவும் வெளியீட்டு அடைவு இல்லாமல் இருக்கவும் வேண்டும். உண்மை வேட்பாளரில் முதல் செயல் இல்லாவிட்டால் மாதிரியைப் பயன்படுத்தாதீர்கள்; அது ஏற்கெனவே நுகர்வோருக்கு முழுமையற்றது. எழுதுதல் உறுதியில்லை என்றால் மறுமுயற்சிக்கு முன் நிர்ணயித்த அறிக்கையையும் ரசீதையும் பாருங்கள். ஏற்கெனவே உள்ள ஒரே பைட்களை மீண்டும் பயன்படுத்தலாம்; மாறுபட்டவை ஒப்பிடுவதற்காகச் செயலை நிறுத்தும். மூலம் அல்லது ஸ்கீமா பதிப்பு மாறினால் புதிய மதிப்பாய்வு தேவை. உள்ளூர் பதில் தெளிவில்லை என்பதற்காக மட்டும் மாதிரி அழைப்பை மீண்டும் செய்யாதீர்கள். ## முழு Python முறை இந்த ஸ்கிரிப்டை அப்படியே `action_register_recipe.py`இல் நகலெடுங்கள்: ```python """Private, bounded recipe. No model call occurs unless `produce` is explicitly run.""" import argparse import hashlib import json import uuid from datetime import date from pathlib import Path from typing import Literal from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr, ValidationError class StrictModel(BaseModel): model_config = ConfigDict(extra="forbid", strict=True) class Action(StrictModel): action_text: StrictStr evidence_quote: StrictStr line_start: StrictInt line_end: StrictInt owner: StrictStr | None due_date: StrictStr | None evidence_status: Literal["complete", "needs_review"] class Extraction(StrictModel): schema_version: Literal["action-register/v1"] status: Literal["ready", "partial", "blocked"] source_id: StrictStr source_sha256: StrictStr actions: list[Action] gap_note: StrictStr | None def digest(data: bytes) -> str: return hashlib.sha256(data).hexdigest() def canonical(payload: Extraction) -> bytes: return json.dumps(payload.model_dump(mode="json"), sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8") def check(payload: Extraction, source_id: str, source: bytes) -> None: if payload.source_id != source_id or payload.source_sha256 != digest(source): raise ValueError("source identity or revision mismatch") lines = source.decode("utf-8").splitlines() if payload.status == "ready" and (not payload.actions or payload.gap_note is not None): raise ValueError("ready requires actions and no gap") if payload.status != "ready": raise ValueError("partial or blocked result cannot reach consumer") for index, item in enumerate(payload.actions, 1): if item.evidence_status != "complete": raise ValueError(f"action {index}: evidence needs review") if not item.action_text.strip() or not item.evidence_quote.strip(): raise ValueError(f"action {index}: empty task or evidence") if not 1 <= item.line_start <= item.line_end <= len(lines): raise ValueError(f"action {index}: invalid source line range") segment = "\n".join(lines[item.line_start - 1:item.line_end]) if item.evidence_quote not in segment: raise ValueError(f"action {index}: quotation absent from source span") if item.owner is not None and not item.owner.strip(): raise ValueError(f"action {index}: blank owner") if item.due_date is not None: try: if date.fromisoformat(item.due_date).isoformat() != item.due_date: raise ValueError() except ValueError as exc: raise ValueError(f"action {index}: due date must be YYYY-MM-DD") from exc def report(payload: Extraction) -> str: """Application consumer: a triage register grouped by missing ownership/date.""" groups = [ ("Assigned with dates", lambda x: x.owner is not None and x.due_date is not None), ("Needs an owner", lambda x: x.owner is None), ("Needs a date", lambda x: x.owner is not None and x.due_date is None), ] rows = ["# Action register for " + payload.source_id, "", "Review artifact; source meaning was approved separately.", ""] for heading, predicate in groups: rows += ["## " + heading, ""] matches = [(n, a) for n, a in enumerate(payload.actions, 1) if predicate(a)] for number, action in matches: rows += [f"{number}. {action.action_text}", f" Owner: {action.owner or 'Unspecified'}; due: {action.due_date or 'Unspecified'}", f" Source lines {action.line_start}-{action.line_end}: {action.evidence_quote}", ""] if not matches: rows += ["None.", ""] return "\n".join(rows) def load_payload(path: Path) -> Extraction: return Extraction.model_validate_json(path.read_bytes(), strict=True) def consume(source_id: str, source_path: Path, payload_path: Path, approval_path: Path, out_dir: Path) -> tuple[Path, Path]: source = source_path.read_bytes() payload = load_payload(payload_path) check(payload, source_id, source) run = json.loads(payload_path.with_suffix(".run.json").read_text(encoding="utf-8")) payload_hash = digest(canonical(payload)) if run.get("source_id") != source_id or run.get("source_sha256") != digest(source) or run.get("payload_sha256") != payload_hash or run.get("last_agent") != "Owned-source action extractor" or not str(run.get("run_id", "")).strip(): raise ValueError("producer receipt does not match accepted candidate") approval = json.loads(approval_path.read_text(encoding="utf-8")) if (type(approval) is not dict or set(approval) != {"approved", "run_id", "source_id", "source_sha256", "payload_sha256", "reviewer", "review_note"} or approval["approved"] is not True or any(type(approval[key]) is not str for key in ("run_id", "source_id", "source_sha256", "payload_sha256", "reviewer", "review_note")) or not approval["reviewer"].strip() or not approval["review_note"].strip() or approval["run_id"] != run["run_id"] or approval["source_id"] != source_id or approval["source_sha256"] != digest(source) or approval["payload_sha256"] != payload_hash): raise ValueError("human source/meaning approval must bind exact source and payload hashes") body = report(payload).encode("utf-8") stem = "action-register-" + payload_hash[:16] out_dir.mkdir(parents=True, exist_ok=True) target = out_dir / (stem + ".md") receipt = out_dir / (stem + ".receipt.json") record = {"run_id": run["run_id"], "source_id": source_id, "source_sha256": digest(source), "payload_sha256": payload_hash, "report_sha256": digest(body), "reviewer": approval["reviewer"], "operation": "local action-triage register"} encoded = (json.dumps(record, indent=2) + "\n").encode("utf-8") for path, data in [(target, body), (receipt, encoded)]: if path.exists(): if path.read_bytes() != data: raise ValueError(f"uncertain prior output differs: {path}; inspect before retry") else: with path.open("xb") as handle: handle.write(data) if path.read_bytes() != data: raise IOError(f"readback failed: {path}") return target, receipt def produce(source_id: str, source_path: Path, candidate_path: Path, model: str) -> None: from agents import Agent, Runner source = source_path.read_bytes() source_text = source.decode("utf-8") if not source_text.strip() or candidate_path.exists() or not candidate_path.parent.is_dir(): raise ValueError("source must contain text; candidate must be new and its parent directory must already exist") run_id = str(uuid.uuid4()) agent = Agent( name="Owned-source action extractor", model=model, instructions=("Extract only explicit action commitments from the supplied numbered source. " "Return action-register/v1. Copy an exact quote with matching 1-based line span. " "Use null for an unstated owner or due date; never infer them. " "Use partial and needs_review for ambiguous evidence; blocked for unusable input. " "Do not use tools or hand off."), output_type=Extraction, ) numbered = "\n".join(f"{n}: {line}" for n, line in enumerate(source_text.splitlines(), 1)) try: result = Runner.run_sync(agent, f"Source ID: {source_id}\nSHA-256: {digest(source)}\nNumbered source:\n{numbered}") if result.interruptions or result.last_agent is not agent or not isinstance(result.final_output, Extraction): raise ValueError("run interrupted, unfinished, or finished by unexpected agent; this CLI does not persist resumable RunState, so do not resume from its failure receipt") output = result.final_output if output.source_id != source_id or output.source_sha256 != digest(source): raise ValueError("producer returned wrong source identity") candidate = canonical(output) with candidate_path.open("xb") as handle: handle.write(candidate) # Candidate only; consumer still requires review. receipt = {"run_id": run_id, "source_id": source_id, "source_sha256": digest(source), "payload_sha256": digest(candidate), "last_agent": result.last_agent.name, "model": model} with candidate_path.with_suffix(".run.json").open("x", encoding="utf-8") as handle: handle.write(json.dumps(receipt, indent=2) + "\n") except Exception as exc: failure = {"run_id": run_id, "source_id": source_id, "source_sha256": digest(source), "error_type": type(exc).__name__, "error": str(exc), "state": "unknown_or_blocked; inspect run and destination before retry"} with candidate_path.with_name(candidate_path.stem + "." + run_id + ".failure.json").open("x", encoding="utf-8") as handle: handle.write(json.dumps(failure, indent=2) + "\n") raise def main() -> None: parser = argparse.ArgumentParser() sub = parser.add_subparsers(dest="command", required=True) for name in ("produce", "consume"): p = sub.add_parser(name) p.add_argument("--source-id", required=True) p.add_argument("--source", type=Path, required=True) if name == "produce": p.add_argument("--candidate", type=Path, required=True) p.add_argument("--model", required=True) else: p.add_argument("--candidate", type=Path, required=True) p.add_argument("--approval", type=Path, required=True) p.add_argument("--out", type=Path, required=True) args = parser.parse_args() if args.command == "produce": produce(args.source_id, args.source, args.candidate, args.model) else: print(*consume(args.source_id, args.source, args.candidate, args.approval, args.out), sep="\n") if __name__ == "__main__": main() ``` ## வரம்புகள் மற்றும் மூலங்கள் ஸ்கிரிப்ட் ஒப்பந்தமும் உள்ளூர் நுகர்வோரும் ஐந்து ஆஃப்லைன் சோதனைகள் மற்றும் ஏழு செயற்கை மாதிரி உற்பத்தியாளர் அல்லது மறுமுயற்சி நிலைகளால் சோதிக்கப்பட்டன. கடுமையான ஸ்கீமா உருவாக்கம், கோப்புக்கு முன் மறுப்பு, குழு வெளியீடு, ஹாஷ்கள், தோல்விக் கையாளுதல் சோதிக்கப்பட்டன. வழங்குநருக்கு ஸ்கீமா அனுப்பவில்லை, மாதிரியை அழைக்கவில்லை, உண்மைக் குறிப்புகளை எடுக்கவில்லை, உண்மையான மனித ஒப்புதல் பெறவில்லை, உண்மை மூல அறிக்கை செய்யவில்லை, கட்டணம் அல்லது தரம் அளவிடவில்லை. API கட்டணம் கணக்கைச் சாரும்; மூலத்தை அனுப்புமுன் இன்றைய இணக்கம், விலை, தரவு அனுமதியைப் பாருங்கள். தொடர்புடைய பின்னணிக்காக BIG CHANGEஇன் [சொந்தப் பணியிலிருந்து AI பணியைத் தேர்ந்தெடுக்கும் வழிகாட்டி](https://bigchange.ai/blog/map-work-choose-first-ai-task-guide) எதைச் சோதிப்பது என்ற முந்தைய முடிவை விவரிக்கிறது. இந்த வழிகாட்டி தேர்ந்தெடுத்த அனுமதித்த தகவல் எடுப்பிலிருந்து ஒரு வகை நிர்ணயித்த முடிவைச் சோதித்த உள்ளூர் நுகர்வோருக்கு அனுப்புகிறது. ### ஆதாரங்கள் மற்றும் கூடுதல் வாசிப்பு - [OpenAI Agents SDK: Agents](https://openai.github.io/openai-agents-python/agents/) Pydanticஇன் `output_type`ஐ விவரிக்கிறது. இந்த முறையின் மனித ஒப்புதல் அல்லது உள்ளூர் நுகர்வோரை வழங்காது. - [OpenAI Agents SDK: Results](https://openai.github.io/openai-agents-python/results/) இவற்றை விவரிக்கிறது: `final_output`, `last_agent`, இடையீடுகள் மற்றும் `to_state()`. இந்த CLI தொடரக்கூடிய நிலையைச் சேமிக்காது. - [OpenAI Agents SDK: Quickstart](https://openai.github.io/openai-agents-python/quickstart/) நிறுவல் மற்றும் API விசை அமைப்பைக் கூறுகிறது. விசையை மூலம் மற்றும் ரசீதுக்கு வெளியே வையுங்கள். - [OpenAI Structured Outputs](https://developers.openai.com/api/docs/guides/structured-outputs) கடுமையான ஸ்கீமா விதிகளையும் மாதிரி ஆதரவையும் விவரிக்கிறது. தேர்ந்தெடுத்த மாதிரியின் ஆதரவை உறுதிப்படுத்துங்கள். - [Pydantic ConfigDict](https://docs.pydantic.dev/latest/api/config/) கடுமையான சரிபார்ப்பு மற்றும் கூடுதல் புலத் தடையை விவரிக்கிறது. - [OpenAI Agents SDK 0.24.0](https://pypi.org/project/openai-agents/0.24.0/) மற்றும் [Pydantic 2.14.1](https://pypi.org/project/pydantic/2.14.1/) உள்ளூர் நிறுவிய நிலையான பதிப்புகளைக் குறிக்கின்றன. வழங்குநர் ஏற்றலைச் சோதிக்கவில்லை. ## Sources - [OpenAI Agents SDK: Agents](https://openai.github.io/openai-agents-python/agents/) — Pydantic output_type அதிகாரப்பூர்வ கையேடு. கட்டுரையின் மனித ஒப்புதல் அல்லது உள்ளூர் நுகர்வோரைச் செயல்படுத்தாது. - [OpenAI Agents SDK: Results](https://openai.github.io/openai-agents-python/results/) — final_output, last_agent, இடையீடுகள், to_stateஇன் அதிகாரப்பூர்வ நடத்தை. முறை RunStateஐச் சேமிக்காது அல்லது தொடர்வதை வழங்காது. - [OpenAI Agents SDK: Quickstart](https://openai.github.io/openai-agents-python/quickstart/) — நிறுவல் மற்றும் API விசையின் அதிகாரப்பூர்வ பின்னணி; தயாரிப்பில் விசை அல்லது உண்மை வழங்குநர் அழைப்பு இல்லை. - [OpenAI Agents SDK: வெளியீட்டு ஸ்கீமா குறிப்பு](https://openai.github.io/openai-agents-python/ref/agent_output/) — கடுமையான வெளியீட்டு ஸ்கீமா உருவாக்கத்தின் அதிகாரப்பூர்வ குறிப்பு; உள்ளூர் சோதனை வழங்குநர் ஏற்றலை நிரூபிக்காது. - [OpenAI Structured Outputs](https://developers.openai.com/api/docs/guides/structured-outputs) — கட்டாயப் புலங்கள் மற்றும் additionalProperties கடுமையான விதிகள், மாதிரி இணக்கம்; பயன்படுத்தும்போது தேர்ந்தெடுத்த மாதிரியைச் சரிபார்க்க வேண்டும். - [Pydantic ConfigDict](https://docs.pydantic.dev/latest/api/config/) — strict மற்றும் extra-forbid அமைப்பை விவரிக்கிறது; பொருள் துல்லியம் மனித மூல மதிப்பாய்வுப் பணியே. - [openai-agents 0.24.0 வெளியீடு](https://pypi.org/project/openai-agents/0.24.0/) — தனி உள்ளூர் Python 3.12.7 ஆஃப்லைன் சோதனையில் நிறுவிய துல்லிய SDK பதிப்பு; மாதிரி அழைப்போ கட்டணமோ இல்லை. - [Pydantic 2.14.1 வெளியீடு](https://pypi.org/project/pydantic/2.14.1/) — SDK 0.24.0 உடன் உள்ளூரில் நிறுவிய சரிபார்ப்பு நூலகத்தின் துல்லியப் பதிப்பு. - [BIG CHANGE: உங்கள் பணியை வரைபடமாக்கி AI மூலம் சோதிக்க முதல் பணியைத் தேர்ந்தெடுக்கவும்](https://bigchange.ai/blog/map-work-choose-first-ai-task-guide) — இந்த ஒருங்கிணைப்பு முறைக்கு முன் பணி தேர்ந்தெடுக்கும் தொடர்புடைய வழிகாட்டி; இது முறையின் சரித்தன்மையை நிறுவாது.