Agent SDK गतिशील टर्न

जब किसी बाद वाले मॉडल टर्न को ऐप्लिकेशन संदर्भ या पिछले नतीजों पर निर्भर होना हो, तब तय मान की जगह एक function दें। रनटाइम हर मॉडल अनुरोध से पहले इसे टर्न संख्या, स्टेप इंडेक्स, मैसेज और संदर्भ के साथ कॉल करता है। Rust में प्रति-टर्न callbacks नहीं हैं; यह मॉडल प्रति रन सेट करता है।

हर टर्न में सेटिंग बदलें

type ResearchContext = {
  fast: boolean;
};

const agent = createAgent<string, string, ResearchContext>({
  id: "research-agent",
  model: ({ context }) =>
    context?.fast ? "openai/gpt-6-astra" : "openai/gpt-6-astra-pro",
  instructions: ({ numberOfTurns }) =>
    `Research turn ${numberOfTurns}. Cite the evidence you use.`,
});

agent = create_agent({
    "id": "research-agent",
    "model": lambda turn: "openai/gpt-6-astra" if (turn["context"] or {}).get("fast") else "openai/gpt-6-astra-pro",
    "instructions": lambda turn: f"Research turn {turn['number_of_turns']}. Cite the evidence you use.",
})

agent := phaseoagent.CreateAgent(phaseoagent.AgentDefinition{
  ID:    "support-agent",
  Model: "openai/gpt-6-astra",
  DynamicModel: func(turn phaseoagent.TurnContext) string {
    if turn.StepIndex >= 3 {
      return "openai/gpt-6-astra-pro"
    }
    return "openai/gpt-6-astra"
  },
  DynamicInstructions: func(turn phaseoagent.TurnContext) string {
    return fmt.Sprintf("Resolve the request. Current context: %v", turn.Context)
  },
})

var agent = AgentSdk.CreateAgent(new AgentDefinition
{
    Id = "support-agent",
    Model = "openai/gpt-6-astra",
    DynamicModel = turn => turn.StepIndex >= 3 ? "openai/gpt-6-astra-pro" : "openai/gpt-6-astra",
    DynamicInstructions = turn => $"Resolve the request. Current context: {turn.Context}",
});

$agent = AgentSdk::createAgent(new AgentDefinition(
    id: "support-agent",
    model: fn (array $turn) => $turn["step_index"] >= 3
        ? "openai/gpt-6-astra-pro"
        : "openai/gpt-6-astra",
    instructions: fn (array $turn) => "Resolve the request. Current context: " . json_encode($turn["context"]),
));

agent = PhaseoAgentSdk.create_agent(
  id: "support-agent",
  model: ->(turn) {
    turn[:step_index] >= 3 ? "openai/gpt-6-astra-pro" : "openai/gpt-6-astra"
  },
  instructions: ->(turn) {
    "Resolve the request. Current context: #{turn[:context].inspect}"
  }
)

// Callbacks 19-argument constructor के आख़िरी छह arguments हैं।
var agent = AgentSdk.createAgent(new AgentSdk.AgentDefinition(
    "support-agent", "openai/gpt-6-astra", null, "Resolve the request.",
    List.of(), 12, null, null, null, null,
    List.of(), null, null,                         // stopWhen, outputSchema, requireApproval
    turn -> turn.stepIndex() >= 3 ? "openai/gpt-6-astra-pro" : "openai/gpt-6-astra", // dynamicModel
    turn -> "Resolve the request. Current context: " + turn.context(),         // dynamicInstructions
    null, null, null,                              // temperature, maxOutputTokens, topP
    null                                           // dynamicTools
));

आप हर टर्न में क्या बदल सकते हैं

सेटिंग	TypeScript	Python	Go	C#	PHP	Ruby	Java
मॉडल	`model`	`model`	`DynamicModel`	`DynamicModel`	`model`	`model:`	`dynamicModel`
निर्देश	`instructions`	`instructions`	`DynamicInstructions`	`DynamicInstructions`	`instructions`	`instructions:`	`dynamicInstructions`
Temperature	`temperature`	`temperature`	`Temperature` (`*float64`)	`Temperature` (`double?`)	`temperature`	`temperature:`	`temperature` (`Double`)
Top-p	`topP`	`top_p`	`TopP` (`*float64`)	`TopP` (`double?`)	`topP`	`top_p:`	`topP` (`Double`)
अधिकतम आउटपुट टोकन	`maxOutputTokens`	`max_output_tokens`	`MaxOutputTokens` (`*int`)	`MaxOutputTokens` (`int?`)	`maxOutputTokens`	`max_output_tokens:`	`maxOutputTokens` (`Integer`)
दिए गए टूल	`activeTools` (टूल ID)	प्रति टर्न नहीं; `next_turn_params` का उपयोग करें	`DynamicTools` (`[]Tool`)	`DynamicTools` (`IReadOnlyList<Tool>`)	`dynamicTools`	`dynamic_tools:`	`dynamicTools` (`List<Tool>`)
मॉडल सूची	`models`	नहीं	नहीं	नहीं	नहीं	नहीं	नहीं

TypeScript, Python, PHP और Ruby तय फ़ील्ड की जगह एक function लेते हैं। Go, C# और Java तय Model और Instructions के बगल में अलग callback फ़ील्ड का उपयोग करते हैं। TypeScript में, activeTools से बाहर छोड़े गए टूल कॉल किए जा सकते रहते हैं, ताकि पिछली कॉल फिर भी resolve हो सकें। टर्न argument में हर भाषा में वही चार मान होते हैं:

भाषा	टर्न argument
TypeScript	`numberOfTurns`, `stepIndex`, `messages`, `context` वाला object
Python	`number_of_turns`, `step_index`, `messages`, `context` वाली dict
Go, C#	`NumberOfTurns`, `StepIndex`, `Messages`, `Context` वाला `TurnContext`
PHP	`number_of_turns`, `step_index`, `messages`, `context` वाला array
Ruby	`:number_of_turns`, `:step_index`, `:messages`, `:context` वाला hash
Java	`numberOfTurns()`, `stepIndex()`, `messages()`, `context()` वाला `TurnContext`

Python में, run() को दिया गया model या preset हर टर्न के लिए definition के मॉडल की जगह ले लेता है।

किसी टूल से ऐप्लिकेशन संदर्भ अपडेट करें

कोई टूल उस ऐप्लिकेशन संदर्भ को बदल सकता है जिसे बाद के टर्न पढ़ते हैं: TypeScript में context.setContext(), Python में runtime.set_context(), और टूल में दिए गए समकक्ष। जब आप रन सहेजते हैं और बाद में उन्हें जारी रखते हैं, तो संदर्भ छोटा और serializable रखें।

const chooseMode = defineTool({
  id: "choose-mode",
  async execute(input: { fast: boolean }, context) {
    context.setContext({ fast: input.fast });
    return { selected: input.fast ? "fast" : "thorough" };
  },
});

सिर्फ़ अगला टर्न override करें

एजेंट definition बदले बिना, किसी टूल के ठीक बाद आने वाले अनुरोध को बदलने के लिए उस टूल पर next-turn पैरामीटर सेट करें। उस एक टर्न के लिए ये प्रति-टर्न functions से ऊपर रहते हैं।

const broadenSearch = defineTool({
  id: "broaden-search",
  nextTurnParams: {
    model: "openai/gpt-6-astra-pro",
    maxOutputTokens: 2_000,
  },
  async execute() {
    return { broadened: true };
  },
});

broaden_search = define_tool(AgentTool(
    id="broaden-search",
    next_turn_params={"model": "openai/gpt-6-astra-pro", "max_output_tokens": 2_000},
    execute=lambda tool_input, runtime: {"broadened": True},
))

inspect := phaseoagent.Tool{
  ID:       "inspect_repository",
  Execute:  inspectRepository,
  NextTurn: &phaseoagent.NextTurnParams{Model: "openai/gpt-6-astra-pro"},
}

var inspect = new Tool("inspect_repository", InspectRepository)
{
    NextTurnParams = new NextTurnParams(Model: "openai/gpt-6-astra-pro"),
};

$inspect = new Tool(
    id: "inspect_repository",
    execute: fn (array $input, $runtime) => inspectRepository($input),
    nextTurnParams: ["model" => "openai/gpt-6-astra-pro"],
);

inspect_repo = PhaseoAgentSdk::Tool.new(
  id: "inspect_repository",
  execute: ->(input, runtime) { inspect_repository(input) },
  next_turn_params: { model: "openai/gpt-6-astra-pro" }
)

// इसे टूल के आख़िरी constructor argument के रूप में दें।
new AgentSdk.NextTurnParams("openai/gpt-6-astra-pro", null, null, null, null, null)

Next-turn पैरामीटर मॉडल, निर्देश, temperature, top-p, अधिकतम आउटपुट टोकन और टूल स्वीकार करते हैं, जिनके नाम हर भाषा की casing में होते हैं। Python में टर्न के बीच टूल सूची बदलने का यही एकमात्र तरीका है। अगर टूल अनुमोदन का इंतज़ार करता है, तो उसके overrides रुके हुए रन के साथ सहेजे जाते हैं और जारी रखने के बाद वाले टर्न पर लागू होते हैं:

भाषा	कहाँ सहेजे जाते हैं
TypeScript	जारी रखने पर जब अनुमोदित कॉल चलती है, तब लागू होते हैं
Python	`run.next_turn_params`
Go	`Run.NextTurn`
C#	`Run.NextTurn`
PHP	`$result->run->nextTurnParams`
Ruby	`result.run.next_turn_params`
Java	`run().nextTurn()`

जिस नीति को आप हर टर्न में फिर से गणना करवाना चाहते हैं उसके लिए प्रति-टर्न functions का उपयोग करें, और किसी ख़ास टूल से एक बार के handoff के लिए next-turn पैरामीटर का।

Rust में मॉडल प्रति रन सेट करें

Rust के phaseo-agent 0.2 में प्रति-टर्न callbacks, टूल से संदर्भ अपडेट या next-turn पैरामीटर नहीं हैं। RunOptions के साथ मॉडल, स्टेप सीमा और ऐप्लिकेशन संदर्भ प्रति रन सेट करें:

let mut options = RunOptions::new("Explain when to use routing presets.");
options.model = Some("openai/gpt-6-astra-pro".to_string());
options.max_steps = Some(4);
options.context = serde_json::json!({ "workspace": "docs" });

let result = agent.run(&mut client, options)?;

यहाँ से शुरू करें

बनाएँ

निरीक्षण

संदर्भ

Agent SDK गतिशील टर्न

हर टर्न में सेटिंग बदलें

आप हर टर्न में क्या बदल सकते हैं

किसी टूल से ऐप्लिकेशन संदर्भ अपडेट करें

सिर्फ़ अगला टर्न override करें

Rust में मॉडल प्रति रन सेट करें

​हर टर्न में सेटिंग बदलें

​आप हर टर्न में क्या बदल सकते हैं

​किसी टूल से ऐप्लिकेशन संदर्भ अपडेट करें

​सिर्फ़ अगला टर्न override करें

​Rust में मॉडल प्रति रन सेट करें

हर टर्न में सेटिंग बदलें

आप हर टर्न में क्या बदल सकते हैं

किसी टूल से ऐप्लिकेशन संदर्भ अपडेट करें

सिर्फ़ अगला टर्न override करें

Rust में मॉडल प्रति रन सेट करें