> ## Documentation Index
> Fetch the complete documentation index at: https://phaseo.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Phaseo Gateway base URL: https://api.phaseo.app/v1. Send `Authorization: Bearer $PHASEO_API_KEY` with every request.
> Model IDs look like `provider/model`, for example `openai/gpt-6-astra`. Do not guess IDs: list them with `GET /v1/models` or check https://phaseo.app/models. `phaseo/free` routes to an available free model and needs no wallet balance.
> For new text integrations prefer `POST /v1/responses`. `POST /v1/chat/completions` (OpenAI format) and `POST /v1/messages` (Anthropic format) suit existing code.
> The full API contract is https://phaseo.app/docs/openapi/v1/openapi.yaml. Official SDKs: `@phaseo/sdk` (TypeScript) and `phaseo` (Python), plus Go, C#, PHP, Ruby and Rust.
> Search these docs over MCP at https://phaseo.app/docs/mcp, and install Phaseo skills with `npx skills add https://phaseo.app/docs`. If a page is wrong or out of date, report it with the MCP `submit_feedback` tool.
> Manage Phaseo accounts with the `phaseo` CLI (`npm install -g @phaseo/cli`, then `phaseo login` or `phaseo login --device-code`), the `/v1` Management API or the MCP server at `https://mcp.phaseo.app/mcp?access=manage`. Do not send users to the dashboard for account tasks. A person is still needed for sign-up, approving a sign-in, paying the first top-up on the checkout link that `phaseo credits add` returns when no card is saved, confirming each saved-card top-up from the emailed link, and account security (password, MFA, passkeys). Create API keys with `phaseo keys create --name <name> --json`; never guess one. Credit top-ups need `phaseo login --scopes billing:write` first. Task map: https://phaseo.app/docs/v1/developers/manage-from-an-agent.md.

# Agent SDK टूल

> Phaseo एजेंट के लिए स्थानीय, अनुमोदन से नियंत्रित, मैन्युअल और समवर्ती टूल परिभाषित करें।

जब किसी एजेंट को ऐप्लिकेशन डेटा पढ़ना हो, किसी आंतरिक सेवा को कॉल करना हो, या कोई कार्रवाई करनी हो, तब एक टूल परिभाषित करें। मॉडल टूल को उसके ID से कॉल करता है; SDK arguments की जाँच करता है, आपका कोड आपके प्रोसेस में चलाता है, और नतीजा अगले टर्न पर वापस भेजता है।

## टूल परिभाषित करें

```typescript TypeScript theme={null}
import { defineTool } from "@phaseo/agent-sdk";

const fetchTicket = defineTool({
  id: "fetch-ticket",
  description: "Load one internal support ticket.",
  parameters: {
    type: "object",
    properties: {
      ticketId: { type: "string" },
    },
    required: ["ticketId"],
    additionalProperties: false,
  },
  timeoutMs: 3_000,
  async execute(input: { ticketId: string }, context) {
    const response = await fetch(
      `https://internal.example/tickets/${input.ticketId}`,
      { signal: context.signal },
    );

    return response.json();
  },
});
```

```python Python theme={null}
import httpx
from phaseo_agent import AgentTool, define_tool

def fetch_ticket(tool_input, runtime):
    response = httpx.get(f"https://internal.example/tickets/{tool_input['ticketId']}")
    return response.json()

fetch_ticket_tool = define_tool(AgentTool(
    id="fetch-ticket",
    description="Load one internal support ticket.",
    parameters={
        "type": "object",
        "properties": {"ticketId": {"type": "string"}},
        "required": ["ticketId"],
        "additionalProperties": False,
    },
    timeout_ms=3_000,
    execute=fetch_ticket,
))
```

```go Go theme={null}
search := phaseoagent.DefineTool(phaseoagent.Tool{
  ID:          "search_tickets",
  Description: "Search support tickets by keyword",
  Parameters: map[string]any{
    "type":       "object",
    "properties": map[string]any{"query": map[string]any{"type": "string"}},
    "required":   []string{"query"},
  },
  Timeout:     10 * time.Second,
  InputSchema: validateSearchInput, // func(any) (any, error)
  Execute: func(input any, runtime phaseoagent.RuntimeContext) (any, error) {
    return tickets.Search(input.(map[string]any)["query"].(string))
  },
})
```

```csharp C# theme={null}
// Constructor Id, Execute, Description, Parameters और Timeout लेता है;
// बाकी properties initializer से सेट करें।
var search = AgentSdk.DefineTool(new Tool(
    "search_tickets",
    async (input, runtime) => await tickets.SearchAsync(input, runtime.CancellationToken),
    "Search support tickets by keyword",
    new Dictionary<string, object?>
    {
        ["type"] = "object",
        ["properties"] = new Dictionary<string, object?> { ["query"] = new { type = "string" } },
        ["required"] = new[] { "query" },
    },
    TimeSpan.FromSeconds(10))
{
    InputSchema = ValidateSearchInput, // Func<object?, object?>
});
```

```php PHP theme={null}
$search = AgentSdk::defineTool(new Tool(
    id: "search_tickets",
    execute: fn (array $input, $runtime) => $tickets->search($input["query"]),
    description: "Search support tickets by keyword",
    parameters: [
        "type" => "object",
        "properties" => ["query" => ["type" => "string"]],
        "required" => ["query"],
    ],
    timeoutMs: 10000,
    inputSchema: fn ($input) => is_string($input["query"] ?? null) ? $input : throw new InvalidArgumentException("query is required"),
));
```

```ruby Ruby theme={null}
search = PhaseoAgentSdk.define_tool(
  PhaseoAgentSdk::Tool.new(
    id: "search_tickets",
    description: "Search support tickets by keyword",
    parameters: {
      type: "object",
      properties: { query: { type: "string" } },
      required: ["query"]
    },
    timeout_ms: 10_000,
    input_schema: ->(input) { input["query"].is_a?(String) ? input : raise("query is required") },
    execute: ->(input, runtime) { tickets.search(input["query"]) }
  )
)
```

```java Java theme={null}
// Tool के तीन constructors हैं: (id, execute); (id, execute, description, parameters, timeout);
// और नीचे वाला पूरा रूप। Validators::requireQuery आपके अपने validator की जगह है।
var search = AgentSdk.defineTool(new AgentSdk.Tool(
    "search_tickets",
    (input, context) -> tickets.search((String) ((Map<?, ?>) input).get("query")),
    "Search support tickets by keyword",
    Map.of("type", "object", "properties", Map.of("query", Map.of("type", "string"))),
    Duration.ofSeconds(10),
    Validators::requireQuery, // inputSchema: AgentSdk.Validator
    null, null,             // outputSchema, eventSchema
    false, null,            // requireApproval, approval
    null, null,             // onToolCalled, onResponseReceived
    "fail-run"              // onError
));
```

```rust Rust theme={null}
use phaseo_agent::Tool;
use serde_json::json;

let get_status = Tool::new(
    "get_status",
    "Get the current service status",
    json!({
        "type": "object",
        "properties": {
            "service": { "type": "string" }
        },
        "required": ["service"]
    }),
    |input, _context| {
        Ok(json!({
            "service": input["service"],
            "status": "healthy"
        }))
    },
);
```

## टूल फ़ील्ड

| फ़ील्ड | `camelCase` (TS, PHP, Java) | `snake_case` (Python, Ruby, Rust) | `PascalCase` (Go, C#) | यह क्या करता है |
| - | - | - | - | - |
| पैरामीटर | `parameters` | `parameters` | `Parameters` | मॉडल को भेजा जाने वाला JSON Schema |
| Validators | `inputSchema`, `outputSchema`, `eventSchema` | `input_schema`, `output_schema`, `event_schema` | `InputSchema`, `OutputSchema`, `EventSchema` | arguments, नतीजों और प्रगति मानों की जाँच करते हैं। विफलता रन को ख़त्म कर देती है (TypeScript में `AgentSchemaValidationError`, बाकी जगह `Invalid tool input: ...` या `Invalid tool output: ...`)। Rust में नहीं हैं। |
| Timeout | `timeoutMs` (TS, PHP), `timeout` (Java) | `timeout_ms` | `Timeout` | इतने समय के बाद कॉल को विफल करता है; नीचे की तालिका देखें। Rust में नहीं है। |
| अनुमोदन | `requireApproval` | `require_approval` | `RequireApproval`, `Approval` | कॉल चलने से पहले किसी व्यक्ति के लिए रुकता है |
| इंटरैक्टिव hooks | `onToolCalled`, `onResponseReceived` | `on_tool_called`, `on_response_received` | `OnToolCalled`, `OnResponseReceived` | किसी व्यक्ति के जवाब के लिए रुकते हैं, फिर उसे रूपांतरित करते हैं। Rust में नहीं हैं। |
| Next-turn overrides | `nextTurnParams` | `next_turn_params` | `NextTurn` (Go), `NextTurnParams` (C#) | अगला मॉडल अनुरोध बदलते हैं; [गतिशील टर्न](https://phaseo.app/docs/hi/v1/sdk-reference/agent/dynamic-turns.md) देखें। Rust में नहीं हैं। |
| त्रुटि नीति | `onError` | `on_error` | `OnError` | `"fail-run"` (डिफ़ॉल्ट) या `"return-to-model"`। Rust में नहीं है। |

Schemas हर भाषा का अपना validator लेते हैं: TypeScript में एक function या `parse()` या `safeParse()` वाला object; Python में एक callable, एक Pydantic मॉडल, या `parse` या `safe_parse` वाला object; बाकी जगह एक function या callable जो मान लौटाता है या exception फेंकता है।

### Timeout क्या करता है

| भाषा | `timeout` ख़त्म होने पर |
| - | - |
| TypeScript | `context.signal` को abort करता है और timeout को टूल त्रुटि मानता है |
| Python | `TimeoutError` raise करता है और हमेशा रन को विफल करता है, `return-to-model` के साथ भी। थ्रेड नहीं रुकता, इसलिए लंबे चलने वाले टूल को अपनी समय-सीमा ख़ुद जाँचनी चाहिए। |
| Go | कॉल को `tool <id> timed out` के साथ विफल करता है। `Execute` के पास `context.Context` नहीं है, इसलिए function अपने goroutine में चलता रहता है। |
| C# | `runtime.CancellationToken` रद्द करता है और कॉल को `TimeoutException` के साथ विफल करता है। Token को अपनी async कॉल में दें। |
| PHP | `execute` के लौटने के बाद जाँचा जाता है: धीमी कॉल `Tool <name> timed out after <n>ms` के साथ विफल होती है। PHP callback को बाधित नहीं कर सकता। |
| Ruby | `execute` को `Timeout.timeout` में लपेटता है, जो कॉल को बाधित करता है और `Timeout::Error` raise करता है |
| Java | Executor को उसके अपने थ्रेड पर चलाता है, कॉल को `TimeoutException` के साथ विफल करता है, और उस थ्रेड को बाधित करता है |
| Rust | कोई टूल timeout नहीं |

ऐसे टूल ID की कॉल जो मौजूदा टूल सूची में नहीं है, रन को विफल कर देती है (Go में `unknown tool`, C#, PHP, Ruby और Java में `Unknown tool '<name>'`, Rust में `AgentError` के रूप में `Unknown tool: <name>`)। `return-to-model` के साथ TypeScript में, अज्ञात टूल या न पढ़े जा सकने वाले arguments का जवाब इसकी जगह टूल त्रुटि की तरह दिया जाता है।

## अनुमोदन ज़रूरी करें

किसी टूल का अनुमोदन flag `true` सेट करें, या उसे एक function दें जो हर कॉल के लिए तय करे। एजेंट-स्तर का अनुमोदन function, जिन भाषाओं में है, हर टूल पर लागू होता है और दोनों को override करता है। नियंत्रित कॉल रन को `waiting_for_human` स्टेटस के साथ रोक देती है; [स्टेट और अनुमोदन](https://phaseo.app/docs/hi/v1/sdk-reference/agent/state-and-approval.md) में कॉल ID से उसे अनुमोदित या अस्वीकार करें।

```typescript TypeScript theme={null}
const deploy = defineTool({
  id: "deploy",
  description: "Deploy the selected release",
  requireApproval: (input: { environment: string }) => input.environment === "production",
  execute: deployRelease,
});
```

```python Python theme={null}
deploy = define_tool(AgentTool(
    id="deploy",
    description="Deploy the selected release",
    require_approval=lambda tool_input, runtime: tool_input["environment"] == "production",
    execute=deploy_release,
))
```

```go Go theme={null}
deploy := phaseoagent.Tool{
  ID:          "deploy",
  Description: "Deploy the selected release",
  Approval: func(input any, runtime phaseoagent.RuntimeContext) (bool, error) {
    return input.(map[string]any)["environment"] == "production", nil
  },
  Execute: deployRelease,
}
```

```csharp C# theme={null}
var deploy = new Tool("deploy", DeployRelease, "Deploy the selected release")
{
    Approval = async (input, runtime) =>
        ((JsonElement)input!).GetProperty("environment").GetString() == "production",
};
```

```php PHP theme={null}
$deploy = new Tool(
    id: "deploy",
    execute: fn (array $input, $runtime) => $deployments->deploy($input),
    description: "Deploy the selected release",
    requireApproval: fn (array $input, $runtime) => ($input["environment"] ?? null) === "production",
);
```

```ruby Ruby theme={null}
deploy = PhaseoAgentSdk::Tool.new(
  id: "deploy",
  description: "Deploy the selected release",
  require_approval: ->(input, runtime) { input["environment"] == "production" },
  execute: ->(input, runtime) { deployments.deploy(input) }
)
```

```rust Rust theme={null}
let deploy = Tool::new(
    "deploy",
    "Deploy an application environment",
    json!({
        "type": "object",
        "properties": {
            "environment": { "type": "string" }
        },
        "required": ["environment"]
    }),
    |input, _context| {
        Ok(json!({
            "environment": input["environment"],
            "deployed": true
        }))
    },
)
.require_approval();
```

| भाषा | प्रति-टूल | हर टूल |
| - | - | - |
| TypeScript | `requireApproval: true` या `(input, context) => boolean` | एजेंट पर `requireApproval: (call, context) => boolean` |
| Python | `require_approval=True` या `(input, runtime) -> bool` | एजेंट पर `"require_approval": (call, runtime) -> bool` |
| Go | `RequireApproval: true` या `Approval` func | `AgentDefinition.RequireApproval(call, runtime)` |
| C# | `RequireApproval = true` या `Approval` func | `AgentDefinition.RequireApproval` |
| PHP | `requireApproval: true` या `fn ($input, $runtime): bool` | `AgentDefinition` का `requireApproval` (`fn ($toolCall, $runtime): bool`) |
| Ruby | `require_approval: true` या `->(input, runtime)` | एजेंट का `require_approval:` (`->(tool_call, runtime)`) |
| Java | `requireApproval` `true` या पूरे constructor में एक `approval` function | `AgentDefinition.requireApproval` (एक `CallApproval`) |
| Rust | `.require_approval()`; कोई प्रति-कॉल function नहीं | कोई नहीं। Pause kind `tool_approval` है, और कोई rejection टाइप नहीं है: अनुमोदित न की गई कॉल को रुका रहने दें या फिर से शुरू करने से पहले अपनी अस्वीकृति नीति लागू करें। |

## कॉल किसी व्यक्ति या दूसरे सिस्टम को सौंपें

मैन्युअल टूल का कोई executor नहीं होता: काम आपका ऐप्लिकेशन, कोई queue या कोई दूसरी सेवा करती है। इंटरैक्टिव टूल एक hook चलाता है जो किसी व्यक्ति के लिए रुक सकता है। दोनों रन को तब तक रोके रखते हैं जब तक आप कॉल ID के लिए टूल आउटपुट के साथ उसे जारी न रखें; [स्टेट और अनुमोदन](https://phaseo.app/docs/hi/v1/sdk-reference/agent/state-and-approval.md) देखें।

| भाषा | मैन्युअल टूल | इंटरैक्टिव टूल: इस तरह रोकें |
| - | - | - |
| TypeScript | `execute: false` | `onToolCalled` से `null` लौटाकर |
| Python | `execute` सेट न करें | `on_tool_called` से `None` लौटाकर |
| Go | `Execute` nil छोड़ें (लंबित `Kind` `manual`) | `OnToolCalled` से `completed = false` लौटाकर (लंबित `Kind` `hitl`) |
| C# | `Execute` null छोड़ें (`manual`) | `OnToolCalled` से `(Completed: false, Output: null)` लौटाकर (`hitl`) |
| PHP | `execute: null` (`manual`) | `onToolCalled` से `null` लौटाकर (`hitl`) |
| Ruby | `execute` सेट न करें (`manual`) | `on_tool_called` से `nil` लौटाकर (`hitl`) |
| Java | executor के रूप में `null` दें (`manual`) | `onToolCalled` से `new ToolCalledResult(false, null)` लौटाकर (`hitl`) |
| Rust | `Tool::external(...)` (pause kind `external_output`) | समर्थित नहीं; एजेंट के `human_review` का उपयोग करें |

अगर इंटरैक्टिव hook इसकी जगह कोई मान लौटाता है, तो वह तुरंत टूल नतीजा बन जाता है। जारी रखने के बाद, आउटपुट validator की जाँच से पहले `onResponseReceived` (या उस भाषा का समकक्ष) दिए गए आउटपुट की जाँच कर सकता है या उसे रूपांतरित कर सकता है।

Rust के external टूल में कोई executor नहीं होता:

```rust theme={null}
let ticket_lookup = Tool::external(
    "ticket_lookup",
    "Load one support ticket",
    json!({
        "type": "object",
        "properties": {
            "ticket_id": { "type": "string" }
        },
        "required": ["ticket_id"]
    }),
);
```

अगर एक मॉडल टर्न में स्वचालित और लंबित टूल दोनों हों, तो रनटाइम pause लौटाने से पहले स्वचालित टूल चलाता है।

## प्रगति बताएँ और संदर्भ अपडेट करें

कोई टूल काम करते समय प्रारंभिक नतीजे प्रकाशित कर सकता है और बाद के टर्न के लिए ऐप्लिकेशन संदर्भ बदल सकता है। प्रगति `tool.preliminary_result` इवेंट के रूप में दिखती है ([स्ट्रीमिंग](https://phaseo.app/docs/hi/v1/sdk-reference/agent/streaming.md) देखें), और अगर आपने event validator सेट किया है तो उसके सामने जाँची जाती है।

```typescript TypeScript theme={null}
const indexRepository = defineTool({
  id: "index-repository",
  async *execute(input: { path: string }, context) {
    yield { phase: "scan" };
    yield { phase: "embed" };
    context.setContext({ indexed: true });
    return { indexed: 248 };
  },
});
```

```python Python theme={null}
def index_repository(tool_input, runtime):
    runtime.emit_progress({"stage": "indexing"})
    runtime.set_context({"indexed": True})
    return "done"
```

```go Go theme={null}
Execute: func(input any, runtime phaseoagent.RuntimeContext) (any, error) {
  _ = runtime.EmitProgress(map[string]any{"stage": "indexing"})
  runtime.SetContext(map[string]any{"indexed": true})
  return "done", nil
},
```

```csharp C# theme={null}
async (input, runtime) =>
{
    await runtime.EmitProgress!(new { stage = "indexing" });
    runtime.SetContext!(new { indexed = true });
    return "done";
}
```

```php PHP theme={null}
execute: function (array $input, $runtime) {
    ($runtime->emitProgress)(["stage" => "indexing"]); // tool.preliminary_result इवेंट
    ($runtime->setContext)(["indexed" => true]);       // बाद के टर्न के लिए संदर्भ
    return "done";
},
```

```ruby Ruby theme={null}
execute: ->(input, runtime) {
  runtime.emit_progress.call(stage: "indexing") # tool.preliminary_result इवेंट
  runtime.set_context.call(indexed: true)       # बाद के टर्न के लिए संदर्भ
  "done"
}
```

```java Java theme={null}
(input, context) -> {
    context.emitProgress().receive(Map.of("stage", "indexing"), context); // tool.preliminary_result इवेंट
    context.setContext().accept(Map.of("indexed", true));                 // बाद के टर्न के लिए संदर्भ
    return "done";
}
```

| भाषा | प्रगति | संदर्भ | रनटाइम संदर्भ फ़ील्ड |
| - | - | - | - |
| TypeScript | Async generator: प्रगति `yield` करें, नतीजा `return` करें; या `context.emitProgress(value)`। स्टेप के `preliminaryResults` में भी रखी जाती है। | `context.setContext(value)` | `runId`, `agentId`, `stepIndex`, `context`, `signal`, `toolCall` |
| Python | `runtime.emit_progress(value)`, या एक generator जो प्रगति yield करता है और नतीजा लौटाता है | `runtime.set_context(value)` | `run_id`, `agent_id`, `step_index`, `context`, `tool_call` |
| Go | `runtime.EmitProgress(value)` | `runtime.SetContext(value)` | `RunID`, `AgentID`, `StepIndex`, `Context`, `ToolCall` |
| C# | `await runtime.EmitProgress(value)` | `runtime.SetContext(value)` | `RunId`, `AgentId`, `StepIndex`, `Context`, `CancellationToken`, `ToolCall` |
| PHP | `($runtime->emitProgress)(value)` | `($runtime->setContext)(value)` | `$runId`, `$agentId`, `$stepIndex`, `$context`, `$toolCall` |
| Ruby | `runtime.emit_progress.call(value)` | `runtime.set_context.call(value)` | `run_id`, `agent_id`, `step_index`, `context`, `tool_call` |
| Java | `context.emitProgress().receive(value, context)` | `context.setContext().accept(value)` | `runId`, `agentId`, `stepIndex`, `context`, `toolCall` |
| Rust | समर्थित नहीं | समर्थित नहीं; संदर्भ प्रति रन सेट होता है | `run_id`, एजेंट ID, स्टेप इंडेक्स, ऐप्लिकेशन संदर्भ, टूल कॉल |

## टूल त्रुटियों से उबरें

डिफ़ॉल्ट रूप से टूल की त्रुटि रन को विफल करती है और फिर से फेंकी जाती है। त्रुटि को टूल के नतीजे (`{"error": "..."}`) के रूप में वापस भेजने के लिए टूल की त्रुटि नीति `return-to-model` सेट करें, ताकि मॉडल कुछ और आज़मा सके। असुरक्षित या न सुधारी जा सकने वाली विफलताओं के लिए डिफ़ॉल्ट रखें।

| भाषा | डिफ़ॉल्ट | `return-to-model` इससे सेट करें |
| - | - | - |
| TypeScript | रन विफल करें | किसी टूल पर `onError`, या हर टूल के लिए `toolExecution.onError` |
| Python | रन विफल करें | `on_error="return-to-model"`। Timeout फिर भी रन को विफल करता है। |
| Go | रन विफल करें | `OnError: "return-to-model"` |
| C# | रन विफल करें | `OnError = "return-to-model"` |
| PHP | रन विफल करें | `onError: "return-to-model"` |
| Ruby | रन विफल करें | `on_error: "return-to-model"` |
| Java | रन विफल करें | `onError` argument के रूप में `"return-to-model"` |
| Rust | मॉडल को लौटाएँ | हमेशा चालू: executor का `AgentError` एक संरचित टूल त्रुटि मैसेज बन जाता है। अज्ञात टूल या ग़ायब अनुमोदन या आउटपुट continuation को `AgentError` के साथ विफल करता है। |

TypeScript में, `toolExecution.maxOutputChars` यह सीमित करता है कि मॉडल टूल के आउटपुट का कितना हिस्सा देखे; लंबे आउटपुट की शुरुआत और अंत रखे जाते हैं और बीच में एक सूचना होती है।

## टूल समवर्ती रूप से चलाएँ

जब एक मॉडल टर्न कई स्वतंत्र टूल कॉल करता है, तो उन्हें एक साथ चलाने के लिए concurrency सीमा सेट करें। जब तक आप ऐसा नहीं करते, Go, C#, Ruby और Java टूल एक-एक करके चलाते हैं। नतीजे उसी क्रम में जोड़े जाते हैं जिसमें मॉडल ने कॉल कीं, चाहे वे किसी भी क्रम में पूरी हों। Go और C# में, अगर कई समवर्ती टूल संदर्भ सेट करते हैं, तो कॉल क्रम में आख़िरी वाला मान्य होता है।

| भाषा | सेटिंग | नोट्स |
| - | - | - |
| TypeScript | `toolExecution: { toolConcurrency: 3 }` | [समानांतर टूल रेसिपी](https://phaseo.app/docs/hi/v1/cookbook/agent-sdk-parallel-tools.md) देखें |
| Python | `tool_execution=AgentToolExecutionConfig(tool_concurrency=3)` | थ्रेड |
| Go | `ToolExecution: phaseoagent.ToolExecutionConfig{Concurrency: 4}` | एजेंट पर, या एक रन के लिए `RunOptions` पर |
| C# | `ToolExecution = new ToolExecutionConfig(Concurrency: 4)` | एजेंट पर, या एक रन के लिए `RunOptions` पर |
| PHP | समर्थित नहीं | `toolExecution` स्वीकार किया जाता है लेकिन उसका कोई असर नहीं होता। समानांतर काम किसी एक टूल के अंदर से अपने HTTP क्लाइंट के समवर्ती अनुरोधों के साथ शुरू करें, या उसे queue में डालें और जॉब ID लौटाएँ। |
| Ruby | `tool_execution: { tool_concurrency: 4 }` | थ्रेड; `create_agent` पर, या एक रन के लिए `run` पर |
| Java | `new AgentSdk.ToolExecutionConfig(4)` | तय थ्रेड पूल; 1 से कम मान 1 कर दिए जाते हैं। एजेंट पर, या एक रन के लिए `RunOptions` में। |
| Rust | समर्थित नहीं | टूल उसी क्रम में synchronous रूप से चलते हैं जिसमें मॉडल ने उन्हें कॉल किया |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.