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
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-<payload-hash-prefix>.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) — इस एकीकरण विधि से पहले काम चुनने का संबंधित गाइड; यह विधि की शुद्धता साबित नहीं करता।
BIG CHANGE न्यूज़लेटर
बड़ी तस्वीर। आपकी गति से।
AI और रोबोटिक्स पर ताज़ा लेख, ध्यान देने योग्य बदलाव और उपयोगी विचार। दैनिक ब्रीफ़िंग, साप्ताहिक सारांश या मासिक परिप्रेक्ष्य चुनें।
अगला निर्धारित प्रेषण (UTC): . पुष्टि करने के बाद अगले निर्धारित प्रेषण के समय आपको पहला अंक मिलेगा।
आपकी गोपनीयता, आपकी पसंद।
ज़रूरी स्टोरेज साइट की सुरक्षा में मदद करता है और आपकी पसंद याद रखता है। आपकी अनुमति मिलने तक वैकल्पिक Google Analytics बंद रहता है। आप हर लेख केवल आवश्यक स्टोरेज के साथ पढ़ सकते हैं। गोपनीयता का विवरण