@mono-agent/agent-runtime 0.6.1 → 0.8.0

package/src/ai/streaming/codex-events.js

@@ -70,22 +70,14 @@ export function normalizeCodexItemEvent(raw, context = {}) {
   if (type === "file_change") {
     const id = itemId(item, "file_change");
     const payload = fileChangePayload(raw, item, context);
-    if (!isCompleted(raw)) {
-      return {
-        type: "assistant",
-        message: { content: [{ type: "tool_use", id, name: "file_edit", input: payload }] },
-      };
-    }
     return {
-      type: "user",
-      message: {
-        content: [{
-          type: "tool_result",
-          tool_use_id: id,
-          content: item.error || payload,
-          is_error: itemFailed(item),
-        }],
-      },
+      type: "file_change",
+      id,
+      status: payload.status,
+      changes: payload.changes,
+      ...(payload.summary ? { summary: payload.summary } : {}),
+      ...(item.error ? { error: item.error } : {}),
+      is_error: itemFailed(item),
     };
   }
 

package/src/ai/types.js

@@ -46,6 +46,27 @@
  * context_compaction_applied, ...) adds its own extra fields.
  */
 
+/** @typedef {"uniform"|"per-route-native"} RuntimeRouteSafetyMode */
+
+/**
+ * @typedef {"mono-agent-monotonic"|"disabled"|"mono-agent-srt"|"mono-agent-srt-unsafe-host-fallback"|"provider-native"|"codex-native"|"unsupported"} RuntimeRouteSandboxContract
+ * Fixed telemetry vocabulary for a route's sandbox posture. The
+ * `mono-agent-srt-unsafe-host-fallback` describes a policy that prefers SRT but
+ * explicitly permits host execution if unavailable; it does not claim which
+ * branch ran for a particular command.
+ */
+
+/** @typedef {"mono-agent-monotonic"|"mono-agent-policy"|"provider-representable"|"exact-allow-all"|"unsupported"} RuntimeRouteToolsContract */
+
+/**
+ * @typedef {Object} RuntimeRouteSafetyContract
+ * Bounded, credential-free description of the sandbox/tool contract applied
+ * to one fallback route.
+ * @property {RuntimeRouteSafetyMode} mode
+ * @property {RuntimeRouteSandboxContract} sandbox
+ * @property {RuntimeRouteToolsContract} tools
+ */
+
 /**
  * @typedef {Object} RuntimeObserver
  * Per-call or host-level observer merged by createObserverHub (ai/observer.js).
@@ -107,6 +128,10 @@
  * The options object a host passes to `createRuntime(host).run(systemPrompt, options)`.
  * @property {RuntimeModelRef} model                     Resolved model reference; see parseRuntimeModelReference.
  * @property {string} [executionMode]                     "sdk" (default) or "cli"; selects which bridge variant handles the model.
+ * @property {string} [sessionId]                         Host conversation/session key for resumable bridges.
+ * @property {string} [providerSessionId]                 Provider-owned resume id for resumable bridges.
+ * @property {boolean} [sessionKeepAlive]                 Keep resumable provider state alive after the turn.
+ * @property {number} [sessionIdleTimeoutMs]              Idle TTL for resumable provider state.
  * @property {boolean} [liveInput]                        Whether this run expects a live/streaming input channel.
  * @property {ReadonlyArray<*>} [observers]               Per-call observers (see RuntimeObserver) merged with host-level (createRuntime) observers.
  * @property {(event: RuntimeEvent) => void} [onEvent]
@@ -115,6 +140,7 @@
  * @property {boolean} [fastMode]
  * @property {string} [cwd]
  * @property {Object<string, Object>} [mcpServers]
+ * @property {ReadonlyArray<Object>} [skills]             Runtime skill metadata for progressive disclosure.
  * @property {ReadonlyArray<string>} [allowedTools]
  * @property {ReadonlyArray<string>} [disallowedTools]
  * @property {string} [permissionMode]
@@ -173,7 +199,8 @@
  * @property {Array<Object>} [runtimeWarnings]
  * @property {Object} [diagnostics]
  * @property {Object} [capabilitiesUsed]
- * @property {Array<{model: RuntimeModelRef, failureKind: (string|null), requestId?: (string|null), retryableSubkind?: (string|null), requirements?: Object}>} [failoverHistory] Set by createRouterRuntime (ai/runtime/router.js) on every attempt after the first.
+ * @property {Array<{model: RuntimeModelRef, failureKind: (string|null), requestId?: (string|null), retryableSubkind?: (string|null), requirements?: Object, routeSafety?: RuntimeRouteSafetyMode, safetyContract?: RuntimeRouteSafetyContract}>} [failoverHistory] Set by createRouterRuntime (ai/runtime/router.js) on every failed/skipped attempt.
+ * @property {Array<{attemptIndex: number, model: RuntimeModelRef, routeSafety: RuntimeRouteSafetyMode, safetyContract: RuntimeRouteSafetyContract, status: string}>} [routeSafetyHistory] Bounded route-safety audit emitted by createRouterRuntime.
  */
 
 /**
@@ -299,4 +326,4 @@
  * @property {() => Promise<void>} disposeAllSessions
  */
 
-export const PROVIDER_KIND_VALUES = ["claude", "pi", "codex"];
+export const PROVIDER_KIND_VALUES = ["claude", "pi", "codex", "opencode"];

package/src/index.js

@@ -18,6 +18,12 @@ export {
   DEFAULT_RUNTIME_BRAND,
   resolveRuntimeBrand,
 } from "./runtime-brand.js";
+export {
+  CLAUDE_SDK_CATALOG_VERSION,
+  discoverClaudeSdkModels,
+  normalizeClaudeSdkCatalog,
+  normalizeClaudeSdkModelId,
+} from "./ai/providers/claude-sdk-discovery.js";
 
 export * from "./ai/index.js";
 export * from "./agent/index.js";

package/src/runtime.js

@@ -77,6 +77,22 @@ function pickDefined(source, keys) {
   return out;
 }
 
+/**
+ * Select recognized keys that are present even when their value is undefined.
+ * `configureTools` uses this variant so callers can explicitly clear state
+ * held by the long-lived per-instance ToolContext.
+ * @param {Object<string, *>} source
+ * @param {Array<string>} keys
+ * @returns {Object<string, *>}
+ */
+function pickPresent(source, keys) {
+  const out = {};
+  for (const key of keys) {
+    if (source && key in source) out[key] = source[key];
+  }
+  return out;
+}
+
 const PROMPT_OVERRIDE_KEYS = ["structuredOutputInstruction", "structuredOutputFinalization", "liveInputGuidance"];
 
 /**
@@ -157,7 +173,7 @@ export function createRuntime(host = {}) {
       return result;
     },
     configureTools(next = {}) {
-      updateToolContext(toolContext, pickDefined(next, TOOL_RUNTIME_KEYS));
+      updateToolContext(toolContext, pickPresent(next, TOOL_RUNTIME_KEYS));
     },
     async disposeSession(providerSessionId) {
       return disposeProviderSession(providerSessionId);

package/types/agent/approval.d.ts

@@ -1,23 +1,20 @@
 /**
- * @param {{onToolApprovalRequest?: any, defaultRiskTier?: string, timeoutMs?: number, onEvent?: (event: any) => void, riskTiersByTool?: any, alwaysAllowTools?: any}} [options]
+ * @param {{onToolApprovalRequest?: any, defaultRiskTier?: string, timeoutMs?: number, onEvent?: (event: any) => void, riskTiersByTool?: any, alwaysAllowTools?: any, autoApproveLowRisk?: boolean}} [options]
  */
-export function createApprovalManager({ onToolApprovalRequest, defaultRiskTier, timeoutMs, onEvent, riskTiersByTool, alwaysAllowTools, }?: {
+export function createApprovalManager({ onToolApprovalRequest, defaultRiskTier, timeoutMs, onEvent, riskTiersByTool, alwaysAllowTools, autoApproveLowRisk, }?: {
     onToolApprovalRequest?: any;
     defaultRiskTier?: string;
     timeoutMs?: number;
     onEvent?: (event: any) => void;
     riskTiersByTool?: any;
     alwaysAllowTools?: any;
+    autoApproveLowRisk?: boolean;
 }): {
     request: (toolCall?: {}) => Promise<{
-        decision: string;
-        reason: string;
-        riskTier: any;
-    } | {
         requestId: any;
         riskTier: any;
         decision: any;
-        reason: any;
+        reason: string;
     }>;
     riskTierFor: (toolName: any) => any;
     sessionAllowlist: () => Set<any>;

package/types/agent/sandbox-seam.d.ts

@@ -7,6 +7,10 @@ export type SandboxCommandSpec = {
     env?: {
         [x: string]: string;
     };
+    /**
+     * Trusted per-command capability.
+     */
+    allowLocalBinding?: boolean;
 };
 export type PreparedSandboxCommand = SandboxCommandSpec & {
     sandboxed: boolean;
@@ -85,6 +89,7 @@ export class SandboxUnavailableError extends Error {
  * @property {ReadonlyArray<string>} [args]
  * @property {string} [cwd]
  * @property {Object<string, string|undefined>} [env]
+ * @property {boolean} [allowLocalBinding] Trusted per-command capability.
  */
 /**
  * @typedef {SandboxCommandSpec & {sandboxed: boolean, cleanup?: () => Promise<void>}} PreparedSandboxCommand

package/types/ai/backend.d.ts

@@ -12,6 +12,7 @@ export const BACKEND_CAPABILITIES: {
         supports_builtin_tools: boolean;
         supports_live_input: boolean;
         supports_native_subagents: boolean;
+        supports_fast_mode: boolean;
         runtime: string;
     };
     pi: {
@@ -24,10 +25,12 @@ export const BACKEND_CAPABILITIES: {
         supports_skills: boolean;
         supports_builtin_tools: boolean;
         supports_live_input: boolean;
+        supports_fast_mode: boolean;
         runtime: string;
     };
     codex: {
         supports_session_resume: boolean;
+        supports_fast_mode: boolean;
         streaming: boolean;
         structured_output: boolean;
         native_runtime_config: any;
@@ -38,4 +41,17 @@ export const BACKEND_CAPABILITIES: {
         supports_native_subagents: boolean;
         runtime: string;
     };
+    opencode: {
+        structured_output: boolean;
+        supports_session_resume: boolean;
+        supports_mcp: boolean;
+        supports_skills: boolean;
+        supports_live_input: boolean;
+        supports_native_subagents: boolean;
+        streaming: boolean;
+        native_runtime_config: any;
+        supports_builtin_tools: boolean;
+        supports_fast_mode: boolean;
+        runtime: string;
+    };
 };

package/types/ai/file-change-stats.d.ts

@@ -49,27 +49,3 @@ export function createFileChangePayload(raw: any, { cwd, snapshots }?: {
     changes: any;
     status: any;
 };
-export function createFileEditToolUseEvent(id: any, payload: any): {
-    type: string;
-    message: {
-        content: {
-            type: string;
-            id: any;
-            name: string;
-            input: any;
-        }[];
-    };
-};
-export function createFileEditToolResultEvent(id: any, payload: any, { isError }?: {
-    isError?: boolean;
-}): {
-    type: string;
-    message: {
-        content: {
-            type: string;
-            tool_use_id: any;
-            content: any;
-            is_error: boolean;
-        }[];
-    };
-};

package/types/ai/index.d.ts

@@ -4,4 +4,5 @@ export * from "./runtime/registry.js";
 export { createSessionRegistry, disposeAllProviderSessions, disposeProviderSession } from "./runtime/sessions.js";
 export { createMetricsObserver, createObserverHub } from "./observer.js";
 export { generatePiNativeResponse, piNativeRuntimeBridge } from "./providers/pi-native.js";
+export { CLAUDE_SDK_CATALOG_VERSION, createClaudeSdkDiscoveryIsolation, curatedClaudeSdkModels, discoverClaudeSdkModels, normalizeClaudeSdkCatalog, normalizeClaudeSdkModelId } from "./providers/claude-sdk-discovery.js";
 export { buildCapabilitiesUsed, toolCompactionAppliedFromWarnings, UNKNOWN_CAPABILITY } from "./runtime/capabilities-used.js";

package/types/ai/providers/claude-cli.d.ts

@@ -29,6 +29,64 @@ export function buildCliCommand({ sdk, model, effort, cwd, schemaPath, outputSch
     cwd: any;
 };
 export function generateCliResponse(systemPrompt: any, options?: {}): Promise<{
+    text: any;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: any;
+    providerSessionId: any;
+    provider_session_id: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: string;
+    diagnostics: {
+        claude_error_code: any;
+    };
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+} | {
+    text: any;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: string;
+    providerSessionId: any;
+    provider_session_id: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: string;
+    diagnostics: {
+        codex_error_code: any;
+    };
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+} | {
     text: any;
     structuredResult: undefined;
     structuredResultSource: string;
@@ -140,6 +198,64 @@ export namespace claudeCodeRuntimeBridge {
     export { capabilities_2 as capabilities };
     export function supports(ref: any, options: any): boolean;
     export function execute(systemPrompt: any, options: any): Promise<{
+        text: any;
+        structuredResult: any;
+        structuredResultSource: any;
+        events: any[];
+        usage: {};
+        durationMs: number;
+        numTurns: number;
+        model: any;
+        effort: any;
+        sdk: any;
+        providerSessionId: any;
+        provider_session_id: any;
+        cancelled: boolean;
+        error: any;
+        failureKind: string;
+        diagnostics: {
+            claude_error_code: any;
+        };
+        capabilitiesUsed: {
+            prompt_cache_active: any;
+            thinking_enabled: any;
+            structured_output_enforced: boolean;
+            subagent_invoked: any;
+            mcp_servers_used: any[];
+            native_subagents_used: any[];
+            tool_compaction_applied: boolean;
+            context_compaction_applied: any;
+        };
+    } | {
+        text: any;
+        structuredResult: any;
+        structuredResultSource: any;
+        events: any[];
+        usage: {};
+        durationMs: number;
+        numTurns: number;
+        model: any;
+        effort: any;
+        sdk: string;
+        providerSessionId: any;
+        provider_session_id: any;
+        cancelled: boolean;
+        error: any;
+        failureKind: string;
+        diagnostics: {
+            codex_error_code: any;
+        };
+        capabilitiesUsed: {
+            prompt_cache_active: any;
+            thinking_enabled: any;
+            structured_output_enforced: boolean;
+            subagent_invoked: any;
+            mcp_servers_used: any[];
+            native_subagents_used: any[];
+            tool_compaction_applied: boolean;
+            context_compaction_applied: any;
+        };
+    } | {
         text: any;
         structuredResult: undefined;
         structuredResultSource: string;

package/types/ai/providers/claude-sandbox.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Claude owns its built-in tool subprocesses, so mono-agent's runtime tool
+ * context cannot wrap them with the configured srt engine. An explicit `off`
+ * policy is inert and remains valid; every enforcing mono-agent mode must fail
+ * before the provider starts instead of silently running outside that policy.
+ */
+export function claudeSandboxPolicyProblem(options: any): string;
+/** Typed provider result used by Claude bridges for fail-closed capability paths. */
+export function claudeCapabilityMismatchResult({ model, effort, sdk, providerSessionId, durationMs, outputSchema, error, errorCode, }: {
+    model: any;
+    effort: any;
+    sdk: any;
+    providerSessionId?: any;
+    durationMs?: number;
+    outputSchema: any;
+    error: any;
+    errorCode: any;
+}): {
+    text: any;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: any;
+    providerSessionId: any;
+    provider_session_id: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: string;
+    diagnostics: {
+        claude_error_code: any;
+    };
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+};
+/** Typed provider result used by both Claude bridges for the sandbox path. */
+export function claudeSandboxCapabilityMismatchResult(options: any): {
+    text: any;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: any;
+    providerSessionId: any;
+    provider_session_id: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: string;
+    diagnostics: {
+        claude_error_code: any;
+    };
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+};
+export const CLAUDE_SANDBOX_POLICY_UNSUPPORTED: "Claude SDK/CLI cannot enforce mono-agent's native srt sandbox scopes. Remove the mono-agent sandbox policy or use a Pi runtime for exact readableRoots, writableRoots, denyWrite, and network rules.";

package/types/ai/providers/claude-sdk-discovery-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/types/ai/providers/claude-sdk-discovery.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Return the versioned, SDK-matched fallback without exposing mutable shared
+ * objects to callers.
+ */
+export function curatedClaudeSdkModels(): {
+    supportedEfforts: ClaudeSdkEffort[];
+    /**
+     * Exact model id accepted by the SDK.
+     */
+    model: string;
+    /**
+     * Canonical mono-agent reference.
+     */
+    reference: `claude:${string}`;
+    displayName: string;
+    description: string;
+    supportsAdaptiveThinking: boolean;
+    supportsFastMode: boolean;
+    source: "discovered" | "cached";
+    catalogVersion: typeof CLAUDE_SDK_CATALOG_VERSION;
+}[];
+/**
+ * Normalize only exact Claude model ids. CLI convenience aliases are rejected
+ * so persisted configuration never changes meaning when an alias advances.
+ * Exact dated ids and a canonical `[1m]` suffix are preserved.
+ * @param {unknown} value
+ * @returns {string|null}
+ */
+export function normalizeClaudeSdkModelId(value: unknown): string | null;
+/**
+ * Whitelist the SDK initialization catalog into the public mono-agent shape.
+ * No account, organization, token source, raw error, or unknown SDK field can
+ * cross this boundary.
+ * @param {unknown} rows
+ * @param {"discovered"|"cached"} [source]
+ * @returns {ClaudeSdkCatalogModel[]}
+ */
+export function normalizeClaudeSdkCatalog(rows: unknown, source?: "discovered" | "cached"): ClaudeSdkCatalogModel[];
+/** @internal Exported for deterministic isolation tests. */
+export function createClaudeSdkDiscoveryIsolation({ baseEnvironment }?: {
+    baseEnvironment?: NodeJS.ProcessEnv;
+}): Promise<{
+    root: string;
+    cwd: string;
+    env: {
+        HOME: string;
+        CLAUDE_CONFIG_DIR: string;
+        XDG_CONFIG_HOME: string;
+        XDG_CACHE_HOME: string;
+        XDG_DATA_HOME: string;
+        XDG_STATE_HOME: string;
+        TMPDIR: string;
+        TMP: string;
+        TEMP: string;
+        CLAUDE_AGENT_SDK_CLIENT_APP: string;
+        MCP_CONNECTION_NONBLOCKING: string;
+    };
+    cleanup: () => Promise<void>;
+}>;
+/**
+ * Discover Claude's current model catalog in a throwaway, no-auth process.
+ * Failure is deliberately non-fatal: the exact SDK-versioned curated catalog
+ * remains available with `source: "cached"`.
+ *
+ * @param {Object} [options]
+ * @param {number} [options.timeoutMs]
+ * @param {readonly string[]} [options.authoredModelRefs]
+ * @param {typeof fork} [options.forkProcess]
+ * @param {(isolation: Awaited<ReturnType<typeof createClaudeSdkDiscoveryIsolation>>) => void} [options.onIsolation]
+ * @returns {Promise<ClaudeSdkCatalogModel[]>}
+ */
+export function discoverClaudeSdkModels({ timeoutMs, authoredModelRefs, forkProcess, onIsolation, }?: {
+    timeoutMs?: number;
+    authoredModelRefs?: readonly string[];
+    forkProcess?: typeof fork;
+    onIsolation?: (isolation: Awaited<ReturnType<typeof createClaudeSdkDiscoveryIsolation>>) => void;
+}): Promise<ClaudeSdkCatalogModel[]>;
+export const CLAUDE_SDK_CATALOG_VERSION: "claude-agent-sdk-0.3.206";
+export type ClaudeSdkEffort = "low" | "medium" | "high" | "xhigh" | "max";
+export type ClaudeSdkCatalogModel = {
+    /**
+     * Exact model id accepted by the SDK.
+     */
+    model: string;
+    /**
+     * Canonical mono-agent reference.
+     */
+    reference: `claude:${string}`;
+    displayName: string;
+    description: string;
+    supportedEfforts: readonly ClaudeSdkEffort[];
+    supportsAdaptiveThinking: boolean;
+    supportsFastMode: boolean;
+    source: "discovered" | "cached";
+    catalogVersion: typeof CLAUDE_SDK_CATALOG_VERSION;
+};
+import { fork } from "node:child_process";

package/types/ai/providers/claude-sdk.d.ts

@@ -1,8 +1,80 @@
+/**
+ * Preserve the provider default when effort is omitted. The current Agent SDK
+ * accepts the five values below verbatim; mono-agent must not infer thinking
+ * enablement/disablement from a requested effort level.
+ * @param {unknown} effort
+ * @returns {{effort?: "low" | "medium" | "high" | "xhigh" | "max"}}
+ */
+export function claudeEffortOptions(effort: unknown): {
+    effort?: "low" | "medium" | "high" | "xhigh" | "max";
+};
+/** @param {string} model @param {unknown} contextWindow */
+export function claudeSdkModelForQuery(model: string, contextWindow: unknown): string;
 export function toolPayloadLimit(options: any): {
     bytes: number;
     usedSettings: boolean;
 };
 export function generateClaudeResponse(systemPrompt: any, options: any): Promise<{
+    text: any;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: any;
+    providerSessionId: any;
+    provider_session_id: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: string;
+    diagnostics: {
+        claude_error_code: any;
+    };
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+} | {
+    text: string;
+    structuredResult: any;
+    structuredResultSource: any;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: string;
+    cancelled: boolean;
+    error: string;
+    errorDetails: {
+        claude_error_code: string;
+        claude_error_category: string;
+        retryable: boolean;
+    };
+    failureKind: string;
+    providerSessionId: string;
+    runtimeWarnings: any[];
+    capabilitiesUsed: {
+        prompt_cache_active: any;
+        thinking_enabled: any;
+        structured_output_enforced: boolean;
+        subagent_invoked: any;
+        mcp_servers_used: any[];
+        native_subagents_used: any[];
+        tool_compaction_applied: boolean;
+        context_compaction_applied: any;
+    };
+} | {
     text: string;
     structuredResult: any;
     structuredResultSource: string;
@@ -22,18 +94,22 @@ export function generateClaudeResponse(systemPrompt: any, options: any): Promise
     cancelled: boolean;
     error: any;
     errorDetails: {
-        claude_error_subtype: any;
+        claude_error_subtype: string;
         last_text_excerpt: string;
-        last_tool_name: any;
+        last_tool_name: string;
         had_partial_progress: boolean;
         tool_results_seen: number;
         turn_count: number;
         max_turns_hit: boolean;
         structured_output_retry_exhausted: boolean;
-        last_structured_output_rejection: any;
-        provider_session_id: any;
+        last_structured_output_rejection: string;
+        provider_session_id: string;
+        claude_error_code: string;
+        claude_error_category: any;
+        retryable: boolean;
+        request_id: any;
     };
-    failureKind: string;
+    failureKind: any;
     providerSessionId: string;
     runtimeWarnings: {
         warning_kind: string;