@tangle-network/agent-runtime 0.21.1 → 0.23.0

package/dist/{chunk-RZAOYKCO.js → chunk-XZYF3YJN.js}

@@ -26,10 +26,18 @@ var SessionMismatchError = class extends AgentEvalError {
 var BackendTransportError = class extends AgentEvalError {
   backend;
   status;
+  /**
+   * Truncated upstream response body (≤2 KiB) when available. Diagnostic
+   * only — surfaces in `backend_error.error.body` and `final.error.body`
+   * so operators can see "free_tier_limit", "invalid_api_key", etc. without
+   * cracking the log line open.
+   */
+  body;
   constructor(backend, message, options) {
     super("config", message, options);
     this.backend = backend;
     this.status = options?.status;
+    this.body = options?.body;
   }
 };
 var RuntimeRunStateError = class extends AgentEvalError {
@@ -48,4 +56,4 @@ export {
   NotFoundError,
   ValidationError
 };
-//# sourceMappingURL=chunk-RZAOYKCO.js.map
+//# sourceMappingURL=chunk-XZYF3YJN.js.map

package/dist/{chunk-RZAOYKCO.js.map → chunk-XZYF3YJN.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/**\n * @stable\n *\n * Error taxonomy for `@tangle-network/agent-runtime`.\n *\n * Public contract: every error this package throws as part of its consumer-\n * facing API either extends `AgentEvalError` (re-exported here for ergonomic\n * `instanceof` checks at the runtime boundary) or extends one of the\n * runtime-specific subclasses below.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error` — they are programmer-mistake assertions, not\n * consumer-catchable contract failures.\n *\n * Subclassing strategy: where a runtime-specific failure maps cleanly to an\n * agent-eval code (validation, config, not_found), we re-use the agent-eval\n * subclass. Runtime-only failure modes (session resume against the wrong\n * backend, backend transport errors) get fresh subclasses that still carry an\n * `AgentEvalErrorCode` so cross-package handlers can pattern-match without\n * importing the runtime.\n */\n\nimport { AgentEvalError } from '@tangle-network/agent-eval'\n\nexport {\n  AgentEvalError,\n  type AgentEvalErrorCode,\n  CaptureIntegrityError,\n  ConfigError,\n  JudgeError,\n  NotFoundError,\n  ReplayError,\n  ValidationError,\n  VerificationError,\n} from '@tangle-network/agent-eval'\n\n/**\n * @stable\n *\n * Caller asked to resume a session against a backend whose `kind` does not\n * match the session's recorded backend. This is a routing bug — the same\n * session id was reused across two different backend implementations — and\n * is not retryable without picking the right backend.\n */\nexport class SessionMismatchError extends AgentEvalError {\n  readonly sessionBackend: string\n  readonly requestedBackend: string\n\n  constructor(sessionBackend: string, requestedBackend: string, options?: { cause?: unknown }) {\n    super(\n      'validation',\n      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,\n      options,\n    )\n    this.sessionBackend = sessionBackend\n    this.requestedBackend = requestedBackend\n  }\n}\n\n/**\n * @stable\n *\n * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success\n * status. Distinct from `JudgeError` (which is structural / unrecoverable)\n * because backend failures are sometimes retryable and consumers may want to\n * branch on the upstream status code.\n */\nexport class BackendTransportError extends AgentEvalError {\n  readonly backend: string\n  readonly status?: number\n\n  constructor(backend: string, message: string, options?: { cause?: unknown; status?: number }) {\n    super('config', message, options)\n    this.backend = backend\n    this.status = options?.status\n  }\n}\n\n/**\n * @stable\n *\n * A runtime-run lifecycle method was called in an order the state machine does\n * not allow: `persist()` before `complete()`, `complete()` twice, etc.\n */\nexport class RuntimeRunStateError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n"],"mappings":";AAsBA,SAAS,sBAAsB;AAE/B;AAAA,EACE,kBAAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAUA,IAAM,uBAAN,cAAmC,eAAe;AAAA,EAC9C;AAAA,EACA;AAAA,EAET,YAAY,gBAAwB,kBAA0B,SAA+B;AAC3F;AAAA,MACE;AAAA,MACA,iBAAiB,cAAc,iBAAiB,gBAAgB;AAAA,MAChE;AAAA,IACF;AACA,SAAK,iBAAiB;AACtB,SAAK,mBAAmB;AAAA,EAC1B;AACF;AAUO,IAAM,wBAAN,cAAoC,eAAe;AAAA,EAC/C;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,SAAiB,SAAgD;AAC5F,UAAM,UAAU,SAAS,OAAO;AAChC,SAAK,UAAU;AACf,SAAK,SAAS,SAAS;AAAA,EACzB;AACF;AAQO,IAAM,uBAAN,cAAmC,eAAe;AAAA,EACvD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,cAAc,SAAS,OAAO;AAAA,EACtC;AACF;","names":["AgentEvalError"]}
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/**\n * @stable\n *\n * Error taxonomy for `@tangle-network/agent-runtime`.\n *\n * Public contract: every error this package throws as part of its consumer-\n * facing API either extends `AgentEvalError` (re-exported here for ergonomic\n * `instanceof` checks at the runtime boundary) or extends one of the\n * runtime-specific subclasses below.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error` — they are programmer-mistake assertions, not\n * consumer-catchable contract failures.\n *\n * Subclassing strategy: where a runtime-specific failure maps cleanly to an\n * agent-eval code (validation, config, not_found), we re-use the agent-eval\n * subclass. Runtime-only failure modes (session resume against the wrong\n * backend, backend transport errors) get fresh subclasses that still carry an\n * `AgentEvalErrorCode` so cross-package handlers can pattern-match without\n * importing the runtime.\n */\n\nimport { AgentEvalError } from '@tangle-network/agent-eval'\n\nexport {\n  AgentEvalError,\n  type AgentEvalErrorCode,\n  CaptureIntegrityError,\n  ConfigError,\n  JudgeError,\n  NotFoundError,\n  ReplayError,\n  ValidationError,\n  VerificationError,\n} from '@tangle-network/agent-eval'\n\n/**\n * @stable\n *\n * Caller asked to resume a session against a backend whose `kind` does not\n * match the session's recorded backend. This is a routing bug — the same\n * session id was reused across two different backend implementations — and\n * is not retryable without picking the right backend.\n */\nexport class SessionMismatchError extends AgentEvalError {\n  readonly sessionBackend: string\n  readonly requestedBackend: string\n\n  constructor(sessionBackend: string, requestedBackend: string, options?: { cause?: unknown }) {\n    super(\n      'validation',\n      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,\n      options,\n    )\n    this.sessionBackend = sessionBackend\n    this.requestedBackend = requestedBackend\n  }\n}\n\n/**\n * @stable\n *\n * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success\n * status. Distinct from `JudgeError` (which is structural / unrecoverable)\n * because backend failures are sometimes retryable and consumers may want to\n * branch on the upstream status code.\n */\nexport class BackendTransportError extends AgentEvalError {\n  readonly backend: string\n  readonly status?: number\n  /**\n   * Truncated upstream response body (≤2 KiB) when available. Diagnostic\n   * only — surfaces in `backend_error.error.body` and `final.error.body`\n   * so operators can see \"free_tier_limit\", \"invalid_api_key\", etc. without\n   * cracking the log line open.\n   */\n  readonly body?: string\n\n  constructor(\n    backend: string,\n    message: string,\n    options?: { cause?: unknown; status?: number; body?: string },\n  ) {\n    super('config', message, options)\n    this.backend = backend\n    this.status = options?.status\n    this.body = options?.body\n  }\n}\n\n/**\n * @stable\n *\n * A runtime-run lifecycle method was called in an order the state machine does\n * not allow: `persist()` before `complete()`, `complete()` twice, etc.\n */\nexport class RuntimeRunStateError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n"],"mappings":";AAsBA,SAAS,sBAAsB;AAE/B;AAAA,EACE,kBAAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAUA,IAAM,uBAAN,cAAmC,eAAe;AAAA,EAC9C;AAAA,EACA;AAAA,EAET,YAAY,gBAAwB,kBAA0B,SAA+B;AAC3F;AAAA,MACE;AAAA,MACA,iBAAiB,cAAc,iBAAiB,gBAAgB;AAAA,MAChE;AAAA,IACF;AACA,SAAK,iBAAiB;AACtB,SAAK,mBAAmB;AAAA,EAC1B;AACF;AAUO,IAAM,wBAAN,cAAoC,eAAe;AAAA,EAC/C;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA,EAET,YACE,SACA,SACA,SACA;AACA,UAAM,UAAU,SAAS,OAAO;AAChC,SAAK,UAAU;AACf,SAAK,SAAS,SAAS;AACvB,SAAK,OAAO,SAAS;AAAA,EACvB;AACF;AAQO,IAAM,uBAAN,cAAmC,eAAe;AAAA,EACvD,YAAY,SAAiB,SAA+B;AAC1D,UAAM,cAAc,SAAS,OAAO;AAAA,EACtC;AACF;","names":["AgentEvalError"]}

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { AgentEvalError, KnowledgeReadinessReport, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { a as AgentBackendInput, b as AgentExecutionBackend, c as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, d as RunAgentTaskOptions, e as AgentTaskRunResult, f as RunAgentTaskStreamOptions, g as AgentRuntimeEvent, h as AgentTaskStatus, i as RuntimeSessionStore, j as RuntimeSession } from './types-DvJIha6w.js';
-export { k as AgentAdapter, l as AgentKnowledgeProvider, m as AgentRuntimeEventSink, n as AgentTaskContext, A as AgentTaskSpec } from './types-DvJIha6w.js';
-export { R as RuntimeRunHandle, a as RuntimeRunPersistenceAdapter, b as RuntimeRunRow, s as startRuntimeRun } from './runtime-run-B2j-hvBj.js';
+import { a as AgentBackendInput, b as AgentExecutionBackend, O as OpenAIChatTool, c as OpenAIChatToolChoice, d as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, e as RunAgentTaskOptions, f as AgentTaskRunResult, g as RunAgentTaskStreamOptions, h as AgentRuntimeEvent, i as AgentTaskStatus, j as RuntimeSessionStore, k as RuntimeSession } from './types-BFgFD_sl.js';
+export { l as AgentAdapter, m as AgentKnowledgeProvider, n as AgentRuntimeEventSink, o as AgentTaskContext, A as AgentTaskSpec, B as BackendErrorDetail } from './types-BFgFD_sl.js';
+export { O as OtelAttribute, a as OtelExportConfig, b as OtelExporter, c as OtelSpan, d as createOtelExporter, l as loopEventToOtelSpan, m as mcpToolsForRuntimeMcp, e as mcpToolsForRuntimeMcpSubset } from './otel-export-B33Cy_60.js';
+export { R as RuntimeRunHandle, a as RuntimeRunPersistenceAdapter, b as RuntimeRunRow, s as startRuntimeRun } from './runtime-run-D5ItCKl_.js';
 
 /**
  * @stable
@@ -68,11 +69,59 @@ interface BackendRetryPolicy {
      */
     requestTimeoutMs?: number;
 }
+/**
+ * @stable
+ *
+ * OpenAI-compat streaming backend. Routes `runAgentTaskStream` through any
+ * `POST /chat/completions` endpoint that speaks OpenAI's SSE protocol —
+ * Tangle Router, OpenAI direct, OpenRouter, Groq, DeepSeek, Together. The
+ * router also fronts Anthropic models in Anthropic-native SSE shape; this
+ * backend handles both.
+ *
+ * ### Tool calls
+ *
+ * Pass `tools` (and optionally `toolChoice`) to forward an OpenAI Chat
+ * Completions `tools[]` array on every request. Streamed `tool_call` chunks
+ * are buffered until the model finalizes them (either `finish_reason:
+ * 'tool_calls'` for OpenAI shape or a `content_block_stop` for Anthropic
+ * `tool_use` blocks proxied through the router), then emitted as a single
+ * `tool_call` RuntimeStreamEvent with the assembled `args`.
+ *
+ * The backend does NOT execute tools — it surfaces calls for the caller's
+ * own dispatcher (typically the product's MCP / sandbox runtime) to fulfill
+ * and feed back as a subsequent `messages` turn. This keeps the transport
+ * thin and lets the agent host own tool dispatch policy.
+ *
+ * ### Fail-loud errors
+ *
+ * Non-success HTTP responses (4xx/5xx) and exhausted retry budgets throw
+ * `BackendTransportError` from inside the `stream()` generator. The runtime
+ * catches the throw, yields a `backend_error` with a typed `error` field
+ * (`kind`, `status`, truncated `body`) and a terminal `final` event with
+ * `status: 'failed'` carrying the same detail. Consumers MUST map
+ * `final.error` onto their `RunRecord.error` — silently treating an empty
+ * `finalText` as "agent produced nothing" hides credit exhaustion, auth
+ * failure, and upstream outages.
+ */
 declare function createOpenAICompatibleBackend<TInput extends AgentBackendInput = AgentBackendInput>(options: {
     apiKey: string;
     baseUrl: string;
     model: string;
     kind?: string;
+    /**
+     * OpenAI Chat Completions `tools[]` definitions surfaced to the model on
+     * every request. Omit to send a tool-free request (existing behavior).
+     * The runtime makes no assumption about the dispatcher — calls stream out
+     * as `tool_call` events and the caller is responsible for executing them
+     * and feeding `tool_result` messages back on a follow-up turn.
+     */
+    tools?: ReadonlyArray<OpenAIChatTool>;
+    /**
+     * OpenAI Chat Completions `tool_choice`. Default `undefined` (request
+     * omits the field; provider falls back to its own default — typically
+     * `'auto'`).
+     */
+    toolChoice?: OpenAIChatToolChoice;
     fetchImpl?: typeof fetch;
     retry?: BackendRetryPolicy;
 }): AgentExecutionBackend<TInput>;
@@ -220,6 +269,30 @@ declare function deriveExecutionId(input: {
  * importing the runtime.
  */
 
+/**
+ * @stable
+ *
+ * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success
+ * status. Distinct from `JudgeError` (which is structural / unrecoverable)
+ * because backend failures are sometimes retryable and consumers may want to
+ * branch on the upstream status code.
+ */
+declare class BackendTransportError extends AgentEvalError {
+    readonly backend: string;
+    readonly status?: number;
+    /**
+     * Truncated upstream response body (≤2 KiB) when available. Diagnostic
+     * only — surfaces in `backend_error.error.body` and `final.error.body`
+     * so operators can see "free_tier_limit", "invalid_api_key", etc. without
+     * cracking the log line open.
+     */
+    readonly body?: string;
+    constructor(backend: string, message: string, options?: {
+        cause?: unknown;
+        status?: number;
+        body?: string;
+    });
+}
 /**
  * @stable
  *
@@ -504,4 +577,4 @@ declare function readinessServerSentEvent(report: KnowledgeReadinessReport, opti
 /** @stable */
 declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
 
-export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, type ModelInfo, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RuntimeEventCollector, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, cleanModelId, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, BackendTransportError, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RuntimeEventCollector, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, cleanModelId, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, validateChatModelId };

package/dist/index.js

@@ -1,3 +1,10 @@
+import {
+  createOtelExporter,
+  loopEventToOtelSpan,
+  mcpToolsForRuntimeMcp,
+  mcpToolsForRuntimeMcpSubset
+} from "./chunk-7HN72MF3.js";
+import "./chunk-UNQM6XQO.js";
 import {
   AgentEvalError,
   BackendTransportError,
@@ -7,7 +14,7 @@ import {
   RuntimeRunStateError,
   SessionMismatchError,
   ValidationError
-} from "./chunk-RZAOYKCO.js";
+} from "./chunk-XZYF3YJN.js";
 import "./chunk-DGUM43GV.js";
 
 // src/sessions.ts
@@ -144,14 +151,19 @@ function createOpenAICompatibleBackend(options) {
     },
     async *stream(input, context) {
       const url = `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
-      const requestBody = JSON.stringify({
+      const bodyPayload = {
         model: options.model,
         stream: true,
         stream_options: { include_usage: true },
         messages: input.messages ?? [
           { role: "user", content: input.message ?? context.task.intent }
         ]
-      });
+      };
+      if (options.tools && options.tools.length > 0) {
+        bodyPayload.tools = options.tools;
+        if (options.toolChoice !== void 0) bodyPayload.tool_choice = options.toolChoice;
+      }
+      const requestBody = JSON.stringify(bodyPayload);
       let response;
       let lastStatus = 0;
       let lastThrown;
@@ -198,14 +210,23 @@ function createOpenAICompatibleBackend(options) {
         );
       }
       if (!response.ok) {
+        let body;
+        try {
+          const raw = await response.text();
+          body = raw.length > MAX_ERROR_BODY_BYTES ? `${raw.slice(0, MAX_ERROR_BODY_BYTES)}\u2026` : raw;
+        } catch {
+          body = void 0;
+        }
         throw new BackendTransportError(kind, `chat backend returned ${lastStatus || "unknown"}`, {
-          status: lastStatus || 0
+          status: lastStatus || 0,
+          body
         });
       }
       yield* streamResponseEvents(response, context, options.model);
     }
   };
 }
+var MAX_ERROR_BODY_BYTES = 2048;
 function normalizeBackendStreamEvent(event, task, session) {
   if ("task" in event && event.task && "session" in event && event.session && "timestamp" in event && event.timestamp) {
     return event;
@@ -315,6 +336,7 @@ async function* streamResponseEvents(response, context, requestedModel) {
   const decoder = new TextDecoder();
   let buffer = "";
   const usage = { saw: false };
+  const toolCalls = /* @__PURE__ */ new Map();
   const startedAt = Date.now();
   for (; ; ) {
     const { done, value } = await reader.read();
@@ -325,9 +347,9 @@ async function* streamResponseEvents(response, context, requestedModel) {
   buffer += decoder.decode().replace(/\r\n/g, "\n");
   for (const event of drainStreamBuffer(true)) yield event;
   if (buffer.trim()) {
-    const event = parseStreamChunk(buffer, context, usage);
-    if (event) yield event;
+    for (const event of parseStreamChunk(buffer, context, usage, toolCalls)) yield event;
   }
+  for (const event of flushPendingToolCalls(toolCalls, context)) yield event;
   if (usage.saw) {
     yield {
       type: "llm_call",
@@ -350,56 +372,124 @@ async function* streamResponseEvents(response, context, requestedModel) {
       if (sseBoundary >= 0) {
         const chunk = buffer.slice(0, sseBoundary);
         buffer = buffer.slice(sseBoundary + 2);
-        const event = parseStreamChunk(chunk, context, usage);
-        if (event) yield event;
+        for (const event of parseStreamChunk(chunk, context, usage, toolCalls)) yield event;
         continue;
       }
       const newline = buffer.indexOf("\n");
       if (newline >= 0 && !buffer.slice(0, newline).startsWith("data:")) {
         const line = buffer.slice(0, newline);
         buffer = buffer.slice(newline + 1);
-        const event = parseStreamChunk(line, context, usage);
-        if (event) yield event;
+        for (const event of parseStreamChunk(line, context, usage, toolCalls)) yield event;
         continue;
       }
       if (flush && buffer.trim() && !buffer.trimStart().startsWith("data:")) {
         const line = buffer;
         buffer = "";
-        const event = parseStreamChunk(line, context, usage);
-        if (event) yield event;
+        for (const event of parseStreamChunk(line, context, usage, toolCalls)) yield event;
         continue;
       }
       break;
     }
   }
 }
-function parseStreamChunk(chunk, context, usage) {
+function* parseStreamChunk(chunk, context, usage, toolCalls) {
   const lines = chunk.split(/\r?\n/);
   const dataLines = lines.filter((line) => line.startsWith("data:"));
   const data = dataLines.length > 0 ? dataLines.map((line) => line.slice(5).trimStart()).join("\n") : chunk.trim();
-  if (!data || data === "[DONE]") return void 0;
+  if (!data || data === "[DONE]") return;
+  let parsed;
   try {
-    const parsed = JSON.parse(data);
-    captureStreamUsage(parsed, usage);
-    const choices = parsed.choices;
-    const choice = Array.isArray(choices) ? choices[0] : void 0;
-    const delta = choice?.delta;
-    const message = choice?.message;
-    const text = stringValue(delta?.content) ?? stringValue(message?.content) ?? stringValue(parsed.text);
-    if (text) {
-      return {
-        type: "text_delta",
-        task: context.task,
-        session: context.session,
-        text,
-        timestamp: nowIso()
-      };
+    parsed = JSON.parse(data);
+  } catch {
+    yield {
+      type: "text_delta",
+      task: context.task,
+      session: context.session,
+      text: data,
+      timestamp: nowIso()
+    };
+    return;
+  }
+  captureStreamUsage(parsed, usage);
+  const choices = parsed.choices;
+  const choice = Array.isArray(choices) ? choices[0] : void 0;
+  const delta = choice?.delta;
+  const message = choice?.message;
+  const deltaToolCalls = delta?.tool_calls;
+  if (Array.isArray(deltaToolCalls)) {
+    for (const tc of deltaToolCalls) {
+      if (!tc || typeof tc !== "object") continue;
+      const rec = tc;
+      const idx = numberValue(rec.index) ?? 0;
+      const key = `openai:${idx}`;
+      const acc = toolCalls.get(key) ?? { argsRaw: "", source: "openai", finalized: false };
+      const id = stringValue(rec.id);
+      if (id) acc.id = id;
+      const fn = rec.function;
+      const name = stringValue(fn?.name);
+      if (name) acc.name = name;
+      const args = stringValue(fn?.arguments);
+      if (args) acc.argsRaw += args;
+      toolCalls.set(key, acc);
+    }
+  }
+  const messageToolCalls = message?.tool_calls;
+  if (Array.isArray(messageToolCalls)) {
+    for (const tc of messageToolCalls) {
+      if (!tc || typeof tc !== "object") continue;
+      const rec = tc;
+      const fn = rec.function;
+      const idx = numberValue(rec.index) ?? messageToolCalls.indexOf(tc);
+      const key = `openai:${idx}`;
+      const acc = toolCalls.get(key) ?? { argsRaw: "", source: "openai", finalized: false };
+      const id = stringValue(rec.id);
+      if (id) acc.id = id;
+      const name = stringValue(fn?.name);
+      if (name) acc.name = name;
+      const args = stringValue(fn?.arguments);
+      if (args) acc.argsRaw += args;
+      acc.finalized = true;
+      toolCalls.set(key, acc);
+    }
+  }
+  const finishReason = stringValue(choice?.finish_reason);
+  if (finishReason === "tool_calls") {
+    for (const [key, acc] of toolCalls) {
+      if (acc.source === "openai" && !acc.finalized) acc.finalized = true;
+      toolCalls.set(key, acc);
     }
-    if (stringValue(parsed.type) === "content_block_delta") {
-      const d = parsed.delta;
+  }
+  const eventType = stringValue(parsed.type);
+  if (eventType === "content_block_start") {
+    const block = parsed.content_block;
+    if (block && stringValue(block.type) === "tool_use") {
+      const idx = numberValue(parsed.index) ?? 0;
+      const key = `anthropic:${idx}`;
+      toolCalls.set(key, {
+        id: stringValue(block.id),
+        name: stringValue(block.name),
+        argsRaw: "",
+        source: "anthropic",
+        finalized: false
+      });
+    }
+  }
+  if (eventType === "content_block_delta") {
+    const d = parsed.delta;
+    const dType = stringValue(d?.type);
+    if (dType === "input_json_delta") {
+      const idx = numberValue(parsed.index) ?? 0;
+      const key = `anthropic:${idx}`;
+      const acc = toolCalls.get(key);
+      if (acc) {
+        const partial = stringValue(d?.partial_json) ?? "";
+        acc.argsRaw += partial;
+        toolCalls.set(key, acc);
+      }
+    } else {
       const text2 = stringValue(d?.text);
       if (text2) {
-        return {
+        yield {
           type: "text_delta",
           task: context.task,
           session: context.session,
@@ -408,17 +498,65 @@ function parseStreamChunk(chunk, context, usage) {
         };
       }
     }
-    return mapCommonBackendEvent(parsed, context);
-  } catch {
-    return {
+  }
+  if (eventType === "content_block_stop") {
+    const idx = numberValue(parsed.index) ?? 0;
+    const key = `anthropic:${idx}`;
+    const acc = toolCalls.get(key);
+    if (acc) {
+      acc.finalized = true;
+      toolCalls.set(key, acc);
+    }
+  }
+  for (const event of drainFinalizedToolCalls(toolCalls, context)) yield event;
+  const text = stringValue(delta?.content) ?? stringValue(message?.content) ?? stringValue(parsed.text);
+  if (text) {
+    yield {
       type: "text_delta",
       task: context.task,
       session: context.session,
-      text: data,
+      text,
       timestamp: nowIso()
     };
+    return;
+  }
+  const mapped = mapCommonBackendEvent(parsed, context);
+  if (mapped) yield mapped;
+}
+function* drainFinalizedToolCalls(toolCalls, context) {
+  for (const [key, acc] of toolCalls) {
+    if (!acc.finalized) continue;
+    toolCalls.delete(key);
+    yield buildToolCallEvent(acc, context);
+  }
+}
+function* flushPendingToolCalls(toolCalls, context) {
+  for (const [key, acc] of toolCalls) {
+    toolCalls.delete(key);
+    yield buildToolCallEvent(acc, context);
   }
 }
+function buildToolCallEvent(acc, context) {
+  let args = acc.argsRaw;
+  if (acc.argsRaw.length > 0) {
+    try {
+      args = JSON.parse(acc.argsRaw);
+    } catch {
+      args = acc.argsRaw;
+    }
+  } else {
+    args = {};
+  }
+  return {
+    type: "tool_call",
+    task: context.task,
+    session: context.session,
+    toolName: acc.name ?? "tool",
+    toolCallId: acc.id,
+    args,
+    timestamp: nowIso()
+  };
+}
 function captureStreamUsage(parsed, usage) {
   const model = stringValue(parsed.model);
   if (model && !usage.model) usage.model = model;
@@ -888,13 +1026,21 @@ async function* runAgentTaskStream(options) {
     } catch (stopErr) {
       stopErrorMessage = stopErr instanceof Error ? stopErr.message : String(stopErr);
     }
+    const combinedMessage = stopErrorMessage ? `${message}; backend stop failed: ${stopErrorMessage}` : message;
+    const errorDetail = err instanceof BackendTransportError ? {
+      kind: "transport",
+      message: combinedMessage,
+      status: err.status,
+      body: err.body
+    } : { kind: "backend", message: combinedMessage };
     const backendError = streamEvent({
       type: "backend_error",
       task,
       session,
       backend: options.backend.kind,
-      message: stopErrorMessage ? `${message}; backend stop failed: ${stopErrorMessage}` : message,
-      recoverable: !options.signal?.aborted
+      message: combinedMessage,
+      recoverable: !options.signal?.aborted,
+      error: errorDetail
     });
     await store?.appendEvent?.(session.id, backendError);
     yield backendError;
@@ -908,7 +1054,8 @@ async function* runAgentTaskStream(options) {
       session,
       status,
       reason: message,
-      text: finalText || void 0
+      text: finalText || void 0,
+      error: errorDetail
     });
     await store?.appendEvent?.(session.id, final);
     yield final;
@@ -1289,6 +1436,12 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
     };
   }
   if (event.type === "final") {
+    const sanitizedError = event.error !== void 0 ? {
+      kind: event.error.kind,
+      message: event.error.message,
+      status: event.error.status,
+      body: options.includeControlPayloads ? event.error.body : void 0
+    } : void 0;
     return {
       type: event.type,
       ...withTask,
@@ -1297,7 +1450,8 @@ function sanitizeRuntimeStreamEvent(event, options = {}) {
       status: event.status,
       reason: event.reason,
       text: options.includeControlPayloads ? event.text : void 0,
-      metadata: options.includeMetadata ? event.metadata : void 0
+      metadata: options.includeMetadata ? event.metadata : void 0,
+      ...sanitizedError !== void 0 ? { error: sanitizedError } : {}
     };
   }
   return {
@@ -1423,7 +1577,16 @@ function pickPublicStreamFields(event) {
   if (event.type === "backend_start" || event.type === "backend_end")
     return { backend: event.backend };
   if (event.type === "backend_error") {
-    return { backend: event.backend, message: event.message, recoverable: event.recoverable };
+    const sanitizedError = event.error !== void 0 ? {
+      kind: event.error.kind,
+      status: event.error.status
+    } : void 0;
+    return {
+      backend: event.backend,
+      message: event.message,
+      recoverable: event.recoverable,
+      ...sanitizedError !== void 0 ? { error: sanitizedError } : {}
+    };
   }
   if (event.type === "task_end") return { status: event.status, reason: event.reason };
   if (event.type === "text_delta" || event.type === "reasoning_delta") return { text: event.text };
@@ -1511,6 +1674,7 @@ function stripNewlines(value) {
 }
 export {
   AgentEvalError,
+  BackendTransportError,
   ConfigError,
   DEFAULT_ROUTER_BASE_URL,
   InMemoryRuntimeSessionStore,
@@ -1521,6 +1685,7 @@ export {
   cleanModelId,
   createIterableBackend,
   createOpenAICompatibleBackend,
+  createOtelExporter,
   createRuntimeEventCollector,
   createRuntimeStreamEventCollector,
   createSandboxPromptBackend,
@@ -1528,6 +1693,9 @@ export {
   deriveExecutionId,
   getModels,
   handleChatTurn,
+  loopEventToOtelSpan,
+  mcpToolsForRuntimeMcp,
+  mcpToolsForRuntimeMcpSubset,
   readinessServerSentEvent,
   resolveChatModel,
   resolveRouterBaseUrl,