@mono-agent/agent-runtime 0.15.3 → 0.16.0

package/types/agent/tools/web-search.d.ts

@@ -1,11 +1,87 @@
 /**
- * @param {{query: string, limit?: number}} params
- * @param {{sandboxPolicy?: any, ctx?: any}} [options]
+ * Compatibility wrapper for direct callers.
+ *
+ * @param {{query: string, limit?: number, alternate_queries?: string[], domains?: string[], exclude_domains?: string[], language?: string, time_range?: string}} params
+ * @param {{sandboxPolicy?: any, ctx?: any, signal?: AbortSignal, searchConfig?: any, fetchImpl?: typeof fetch}} [options]
  */
-export function webSearchToolImpl({ query, limit }: {
+export function webSearchToolImpl(params: {
     query: string;
     limit?: number;
-}, { sandboxPolicy, ctx }?: {
+    alternate_queries?: string[];
+    domains?: string[];
+    exclude_domains?: string[];
+    language?: string;
+    time_range?: string;
+}, options?: {
     sandboxPolicy?: any;
     ctx?: any;
-}): Promise<string>;
+    signal?: AbortSignal;
+    searchConfig?: any;
+    fetchImpl?: typeof fetch;
+}): Promise<any>;
+/**
+ * Search through an operator-owned SearXNG endpoint and/or the keyless HTML
+ * fallback chain. Returns a structured internal outcome for the Pi bridge.
+ *
+ * @param {{query: string, limit?: number, alternate_queries?: string[], domains?: string[], exclude_domains?: string[], language?: string, time_range?: string}} params
+ * @param {{sandboxPolicy?: any, ctx?: any, signal?: AbortSignal, searchConfig?: any, fetchImpl?: typeof fetch}} [options]
+ */
+export function performWebSearch({ query, limit, alternate_queries, domains, exclude_domains, language, time_range, }: {
+    query: string;
+    limit?: number;
+    alternate_queries?: string[];
+    domains?: string[];
+    exclude_domains?: string[];
+    language?: string;
+    time_range?: string;
+}, { sandboxPolicy, ctx, signal, searchConfig, fetchImpl, }?: {
+    sandboxPolicy?: any;
+    ctx?: any;
+    signal?: AbortSignal;
+    searchConfig?: any;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    text: any;
+    outcome: {
+        status: string;
+        code: any;
+        retryable: boolean;
+        attempts: number;
+        backend: string;
+        cacheHit: boolean;
+        durationMs: number;
+        bytes: number;
+        truncated: boolean;
+    };
+    error: boolean;
+} | {
+    text: string;
+    outcome: {
+        status: string;
+        code: string;
+        retryable: boolean;
+        attempts: number;
+        backend: any;
+        cacheHit: boolean;
+        durationMs: number;
+        bytes: number;
+        truncated: boolean;
+        resultCount: number;
+        providerFailureCount: number;
+    };
+    error: boolean;
+}>;
+export function parseDuckDuckGoResults(html: any): {
+    title: string;
+    url: string;
+    snippet: string;
+    backend: string;
+}[];
+export function parseStartpageResults(html: any): {
+    title: string;
+    url: string;
+    snippet: string;
+    backend: string;
+}[];
+export function canonicalizeSearchUrl(value: any, base: any): string;
+export function mergeRankedResults(rankedLists: any, limit?: number): any[];

package/types/ai/pi-oauth-compat.d.ts

@@ -0,0 +1,57 @@
+/** @internal Exported only so tests can force a rebuild of the memoized index. */
+export function resetPiProviderIndexForTests(): void;
+/**
+ * The OAuth implementation for a Pi provider id, or undefined when the provider
+ * is unknown or supports only API-key auth (e.g. `opencode-go`).
+ *
+ * @param {string} providerId
+ * @returns {OAuthAuth|undefined}
+ */
+export function getPiOAuthAuth(providerId: string): OAuthAuth | undefined;
+/**
+ * Every Pi provider id that supports OAuth. Replaces
+ * `getOAuthProviders().map((provider) => provider.id)`.
+ *
+ * @returns {string[]}
+ */
+export function getPiOAuthProviderIds(): string[];
+/**
+ * Resolve an API key from stored OAuth credentials, refreshing first when the
+ * token has expired.
+ *
+ * Reproduces pi-ai 0.80.6's `getOAuthApiKey(providerId, credentials)` contract
+ * so its call sites keep their shape: takes the whole provider-keyed credential
+ * map, returns `null` when this provider has no stored credential, and is
+ * *pure* — the refreshed credential comes back as `newCredentials` for the
+ * caller to persist rather than being written here.
+ *
+ * The refresh trigger is deliberately the old exact-expiry check. pi's own
+ * `Models.getAuth()` refreshes five minutes ahead of expiry; matching that would
+ * change live token rotation timing, which this migration does not intend.
+ *
+ * @param {string} providerId
+ * @param {Record<string, *>|undefined} credentials Provider-keyed credential map.
+ * @returns {Promise<{newCredentials: OAuthCredential, apiKey: string|undefined}|null>}
+ */
+export function resolveOAuthApiKey(providerId: string, credentials: Record<string, any> | undefined): Promise<{
+    newCredentials: OAuthCredential;
+    apiKey: string | undefined;
+} | null>;
+/**
+ * Bridge the legacy six-callback OAuth surface onto 0.83.0's single
+ * `prompt`/`notify` pair.
+ *
+ * `manual_code` must stay wired to `onManualCodeInput`: Anthropic races its
+ * localhost callback against a pasted redirect URL, and that path is the reason
+ * `agent-app`'s `runPiOAuthLogin` exists at all.
+ *
+ * @param {OAuthLoginCallbacks} callbacks
+ * @returns {AuthInteraction}
+ */
+export function toAuthInteraction(callbacks: OAuthLoginCallbacks): AuthInteraction;
+export type OAuthAuth = import("@earendil-works/pi-ai").OAuthAuth;
+export type OAuthCredential = import("@earendil-works/pi-ai").OAuthCredential;
+export type AuthInteraction = import("@earendil-works/pi-ai").AuthInteraction;
+export type AuthPrompt = import("@earendil-works/pi-ai").AuthPrompt;
+export type AuthEvent = import("@earendil-works/pi-ai").AuthEvent;
+export type OAuthLoginCallbacks = import("@earendil-works/pi-ai/oauth").OAuthLoginCallbacks;

package/types/ai/providers/pi-native/turn-runner.d.ts

@@ -9,7 +9,7 @@
  * @param {any} params
  * @returns {Promise<{tools: any[], structuredTool: any, mcpClients: any[], closeRunTools: () => Promise<void>}>}
  */
-export function buildTurnTools(runState: any, { options, capabilities, toolLimits, approvalManager, runtime, resolved, onEvent, runtimeWarnings, }: any): Promise<{
+export function buildTurnTools(runState: any, { options, capabilities, toolLimits, approvalManager, runtime, resolved, onEvent, runtimeWarnings, toolExecutionMode, }: any): Promise<{
     tools: any[];
     structuredTool: any;
     mcpClients: any[];
@@ -32,7 +32,37 @@ export function thinkingLevelForEffort(effort: string, capabilities: any): strin
  * @param {any} params
  * @returns {any}
  */
-export function buildTurnHarness(runState: any, { cwd, session, piModels, model, thinkingLevel, systemPrompt, outputSchema, tools, transport, maxRetries, maxRetryDelayMs, steeringMode, onEvent, options, toolLimits, sdk, reference, }: any): any;
+/**
+ * Restore the error flag on a tool result pi resolved successfully.
+ *
+ * pi hardcodes `isError: false` for every `execute()` that returns rather than
+ * throws, so any tool that reports failure in its payload needs this hook or
+ * the model is told the call succeeded.
+ *
+ * @param {*} details Tool-result details recorded by the bridge.
+ * @returns {{isError: true}|undefined}
+ */
+export function toolResultErrorOverride(details: any): {
+    isError: true;
+} | undefined;
+export function buildTurnHarness(runState: any, { session, piModels, model, thinkingLevel, systemPrompt, outputSchema, tools, transport, maxRetries, maxRetryDelayMs, steeringMode, onEvent, options, toolLimits, sdk, reference, }: {
+    session: any;
+    piModels: any;
+    model: any;
+    thinkingLevel: any;
+    systemPrompt: any;
+    outputSchema: any;
+    tools: any;
+    transport: any;
+    maxRetries: any;
+    maxRetryDelayMs: any;
+    steeringMode: any;
+    onEvent: any;
+    options: any;
+    toolLimits: any;
+    sdk: any;
+    reference: any;
+}): AgentHarness<undefined, import("@earendil-works/pi-agent-core").Skill, import("@earendil-works/pi-agent-core").PromptTemplate, import("@earendil-works/pi-agent-core").AgentHarnessTool<undefined>>;
 /**
  * Start the live-input steering consumer. Consumes follow-up messages and steers
  * the harness mid-run; the consumer is tied to run completion (an internal
@@ -60,3 +90,4 @@ export function startLiveInput({ harness, options, onEvent }: {
 export function runHarnessPrompt(harness: any, promptText: string, promptImages: Array<any>): Promise<{
     runError: any;
 }>;
+import { AgentHarness } from "@earendil-works/pi-agent-core";

package/types/ai/providers/pi-native.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Pi 0.80.6 exposes per-tool execution markers but not AgentHarness's global
+ * toolExecution option. Resolve mono-agent's programmatic mode once per run;
+ * individual tool builders then mark stateful/mutating tools sequential.
+ */
+export function resolvePiToolExecutionMode(options?: {}): {
+    mode: any;
+    warnings: {
+        warning_kind: string;
+        message: string;
+    }[];
+};
 export function createDynamicCredentialStore(apiKeys: any, resolvePiApiKey: any, runtimeWarnings: any): any;
 export function splitPromptMessages(messages: any, model: any): {
     priorMessages: any[];

package/types/ai/runtime/router.d.ts

@@ -3,10 +3,12 @@
  * @param {AgentRuntimeHostOptions} [options.host]
  * @param {ReadonlyArray<RuntimeModelRef|RouterChainEntryInput>} [options.chain]
  * @param {"uniform"|"per-route-native"} [options.routeSafety]
- * @param {(input: {model: RuntimeModelRef, executionMode: string|null, attemptIndex: number, routeSafety: "uniform"|"per-route-native"}) => (RouterAttemptResolution|Promise<RouterAttemptResolution>)} [options.resolveAttempt]
+ * @param {(input: {model: RuntimeModelRef, executionMode: string|null, attemptIndex: number, retryIndex: number, routeSafety: "uniform"|"per-route-native"}) => (RouterAttemptResolution|Promise<RouterAttemptResolution>)} [options.resolveAttempt]
+ * @param {Partial<RouterRetryPolicy>} [options.retry] Backoff shape for same-model
+ *   retries. Per-route retry counts live on each chain entry's `attempts`.
  * @returns {AgentRuntimeInstance & {chain: () => Array<RouterChainEntry>}}
  */
-export function createRouterRuntime({ host, chain, routeSafety, resolveAttempt }?: {
+export function createRouterRuntime({ host, chain, routeSafety, resolveAttempt, retry }?: {
     host?: AgentRuntimeHostOptions;
     chain?: ReadonlyArray<RuntimeModelRef | RouterChainEntryInput>;
     routeSafety?: "uniform" | "per-route-native";
@@ -14,8 +16,10 @@ export function createRouterRuntime({ host, chain, routeSafety, resolveAttempt }
         model: RuntimeModelRef;
         executionMode: string | null;
         attemptIndex: number;
+        retryIndex: number;
         routeSafety: "uniform" | "per-route-native";
     }) => (RouterAttemptResolution | Promise<RouterAttemptResolution>);
+    retry?: Partial<RouterRetryPolicy>;
 }): AgentRuntimeInstance & {
     chain: () => Array<RouterChainEntry>;
 };
@@ -26,7 +30,8 @@ export type RuntimeRunOptions = import("../types.js").RuntimeRunOptions;
 export type RuntimeResult = import("../types.js").RuntimeResult;
 /**
  * A chain entry as accepted by createRouterRuntime: either the shorthand bare
- * RuntimeModelRef, or the full `{model, executionMode?, effort?, requires?}` form.
+ * RuntimeModelRef, or the full `{model, executionMode?, effort?, requires?,
+ * attempts?}` form.
  */
 export type RouterChainEntryInput = {
     model: RuntimeModelRef;
@@ -35,6 +40,7 @@ export type RouterChainEntryInput = {
     requires?: {
         [x: string]: any;
     };
+    attempts?: number;
 };
 export type RouterChainEntry = {
     model: RuntimeModelRef;
@@ -43,6 +49,20 @@ export type RouterChainEntry = {
     requires: {
         [x: string]: any;
     } | null;
+    /**
+     * Total attempts on this route including the first.
+     */
+    attempts: number;
+};
+export type RouterRetryPolicy = {
+    /**
+     * Delay before the first retry; doubles per retry.
+     */
+    backoffMs: number;
+    /**
+     * Ceiling for the doubled delay.
+     */
+    maxBackoffMs: number;
 };
 /**
  * Private host seam for route-specific provider options/runtime ownership.

package/types/ai/types.d.ts

@@ -118,7 +118,8 @@
  * @property {boolean} [fastMode]
  * @property {string} [cwd]
  * @property {Object<string, Object>} [mcpServers]
- * @property {ReadonlyArray<Object>} [skills]             Runtime skill metadata for progressive disclosure.
+ * @property {ReadonlyArray<{name: string, description?: string}>} [skills] Skills disclosed to this run, as `{name, description}`. Non-empty makes `supports_skills` a routing requirement (see router.js), so a chain entry that lacks it is skipped.
+ * @property {string} [skillsRoot]                       Directory holding `<name>/SKILL.md`. Required alongside `skills` for `ReadSkill` to be built.
  * @property {ReadonlyArray<string>} [allowedTools]
  * @property {ReadonlyArray<string>} [disallowedTools]
  * @property {string} [permissionMode]
@@ -132,8 +133,13 @@
  * @property {RuntimeToolLimits} [toolLimits] Typed per-run tool-output limits (supported replacement for the deprecated `settings` tool keys).
  * @property {RuntimeCompactionPolicy} [compaction] Typed per-run compaction policy (supported replacement for the deprecated `settings` compaction keys).
  * @property {RuntimePromptOverrides} [prompts] Per-run prompt-fragment overrides (run wins over the host default).
+ * @property {{backend?: "auto"|"searxng"|"keyless", endpoint?: string}} [webSearchConfig] Run-scoped WebSearch backend configuration.
+ * @property {{render?: "never"|"auto", browserCommand?: string}} [webFetchConfig] Run-scoped WebFetch extraction/render configuration.
+ * @property {"sequential"|"safe-parallel"} [piToolExecutionMode] Pi built-in tool scheduling mode. Safe parallelism is the default.
+ * @property {"one-at-a-time"|"all"} [piToolParallelismMode] DEPRECATED. Compatibility alias mapped to piToolExecutionMode.
  * @property {Object} [settings] DEPRECATED. Legacy flat settings bag; consumed only as a per-group FALLBACK when the corresponding typed object (`toolLimits` / `compaction`) is absent. Consuming any key emits one `deprecated_settings_option` runtime_warning per run. Migrate via resolveRuntimePolicies (@mono-agent/runtime-adapter).
  * @property {Object} [nativeSubagents] Same-runtime teammate helpers exposed through native provider subagent surfaces.
+ * @property {RuntimeSubagentsOptions} [subagents] In-process `Agent` built-in: profiles, caps, and the nested-run callback.
  * @property {Object} [diagnosticsSeed] Set by createRouterRuntime (ai/runtime/router.js) with a `resume_snapshot` when
  *   failing over mid-chain; a host-level coordinator may relay it forward (see agent/transcript.js), not read by any
  *   bridge in this package today.
@@ -154,6 +160,48 @@
  * createRuntime), and the per-run observerHub (onEvent is overridden to the
  * hub's emit). `systemPrompt` is passed positionally, not folded into this object.
  */
+/**
+ * @typedef {Object} RuntimeSubagentDefinition
+ * One named subagent profile the `Agent` built-in can deploy.
+ * @property {string} name Model-visible identifier and the tool's `name` enum value.
+ * @property {string} description Model-visible: when to pick this profile.
+ * @property {string} systemPrompt Full system prompt for the child run.
+ * @property {RuntimeModelRef} [model] Absent inherits the parent's configured route.
+ * @property {string} [effort]
+ * @property {ReadonlyArray<string>} [allowedTools] Absent uses the safe read-only default set.
+ * @property {ReadonlyArray<string>} [disallowedTools]
+ * @property {Object<string, Object>} [mcpServers]
+ * @property {number} [maxTurns]
+ * @property {number} [timeoutMs]
+ */
+/**
+ * @callback RuntimeSubagentRun
+ * Owning-layer callback that actually executes one child turn. The kernel
+ * supplies a self-run fallback so `createRuntime` works without host wiring;
+ * agent-app replaces it so subagent runs get the configured fallback chain,
+ * same-model retries, and run recording.
+ * @param {Object} request
+ * @returns {Promise<RuntimeResult>}
+ */
+/**
+ * @typedef {Object} RuntimeInlineSubagentsOptions
+ * Policy for subagents the model authors at call time rather than picking from
+ * `definitions`. Absent suppresses authoring entirely.
+ * @property {boolean} [enabled] Only `false` turns authoring off.
+ * @property {ReadonlyArray<string>} [allowedTools] Ceiling on what an authored subagent may
+ *   request. Absent means the safe read-only default set, never every built-in.
+ */
+/**
+ * @typedef {Object} RuntimeSubagentsOptions
+ * @property {ReadonlyArray<RuntimeSubagentDefinition>} [definitions] Named profiles.
+ * @property {RuntimeInlineSubagentsOptions} [inline] Call-time authoring policy.
+ * @property {number} [maxConcurrent] In-flight subagents per parent turn. Default 5.
+ * @property {number} [maxPerTurn] Total Agent calls per parent turn. Default 20.
+ * @property {number} [maxTurns] Default per-subagent turn cap. Default 100.
+ * @property {number} [timeoutMs] Default per-subagent wall clock.
+ * @property {RuntimeSubagentRun} [run] Nested-run callback; absent uses the kernel self-run.
+ * @property {number} [depth] Kernel-owned. Absent/0 is the parent; >=1 suppresses the `Agent` tool.
+ */
 /**
  * @typedef {Object} RuntimeResult
  * @property {string|null} [text]
@@ -175,7 +223,7 @@
  * @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, routeSafety?: RuntimeRouteSafetyMode, safetyContract?: RuntimeRouteSafetyContract}>} [failoverHistory] Set by createRouterRuntime (ai/runtime/router.js) on every failed/skipped attempt.
+ * @property {Array<{model: RuntimeModelRef, failureKind: (string|null), requestId?: (string|null), retryableSubkind?: (string|null), retryIndex?: number, 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.
  */
 /**
@@ -531,9 +579,16 @@ export type RuntimeRunOptions = {
         [x: string]: any;
     };
     /**
-     * Runtime skill metadata for progressive disclosure.
+     * Skills disclosed to this run, as `{name, description}`. Non-empty makes `supports_skills` a routing requirement (see router.js), so a chain entry that lacks it is skipped.
+     */
+    skills?: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    /**
+     * Directory holding `<name>/SKILL.md`. Required alongside `skills` for `ReadSkill` to be built.
      */
-    skills?: ReadonlyArray<any>;
+    skillsRoot?: string;
     allowedTools?: ReadonlyArray<string>;
     disallowedTools?: ReadonlyArray<string>;
     permissionMode?: string;
@@ -565,6 +620,28 @@ export type RuntimeRunOptions = {
      * Per-run prompt-fragment overrides (run wins over the host default).
      */
     prompts?: RuntimePromptOverrides;
+    /**
+     * Run-scoped WebSearch backend configuration.
+     */
+    webSearchConfig?: {
+        backend?: "auto" | "searxng" | "keyless";
+        endpoint?: string;
+    };
+    /**
+     * Run-scoped WebFetch extraction/render configuration.
+     */
+    webFetchConfig?: {
+        render?: "never" | "auto";
+        browserCommand?: string;
+    };
+    /**
+     * Pi built-in tool scheduling mode. Safe parallelism is the default.
+     */
+    piToolExecutionMode?: "sequential" | "safe-parallel";
+    /**
+     * DEPRECATED. Compatibility alias mapped to piToolExecutionMode.
+     */
+    piToolParallelismMode?: "one-at-a-time" | "all";
     /**
      * DEPRECATED. Legacy flat settings bag; consumed only as a per-group FALLBACK when the corresponding typed object (`toolLimits` / `compaction`) is absent. Consuming any key emits one `deprecated_settings_option` runtime_warning per run. Migrate via resolveRuntimePolicies (@mono-agent/runtime-adapter).
      */
@@ -573,6 +650,10 @@ export type RuntimeRunOptions = {
      * Same-runtime teammate helpers exposed through native provider subagent surfaces.
      */
     nativeSubagents?: any;
+    /**
+     * In-process `Agent` built-in: profiles, caps, and the nested-run callback.
+     */
+    subagents?: RuntimeSubagentsOptions;
     /**
      * Set by createRouterRuntime (ai/runtime/router.js) with a `resume_snapshot` when
      * failing over mid-chain; a host-level coordinator may relay it forward (see agent/transcript.js), not read by any
@@ -603,6 +684,94 @@ export type RuntimeRequest = RuntimeRunOptions & Pick<AgentRuntimeHostOptions, "
         flush: () => Promise<void>;
     };
 };
+/**
+ * One named subagent profile the `Agent` built-in can deploy.
+ */
+export type RuntimeSubagentDefinition = {
+    /**
+     * Model-visible identifier and the tool's `name` enum value.
+     */
+    name: string;
+    /**
+     * Model-visible: when to pick this profile.
+     */
+    description: string;
+    /**
+     * Full system prompt for the child run.
+     */
+    systemPrompt: string;
+    /**
+     * Absent inherits the parent's configured route.
+     */
+    model?: RuntimeModelRef;
+    effort?: string;
+    /**
+     * Absent uses the safe read-only default set.
+     */
+    allowedTools?: ReadonlyArray<string>;
+    disallowedTools?: ReadonlyArray<string>;
+    mcpServers?: {
+        [x: string]: any;
+    };
+    maxTurns?: number;
+    timeoutMs?: number;
+};
+/**
+ * Owning-layer callback that actually executes one child turn. The kernel
+ * supplies a self-run fallback so `createRuntime` works without host wiring;
+ * agent-app replaces it so subagent runs get the configured fallback chain,
+ * same-model retries, and run recording.
+ */
+export type RuntimeSubagentRun = (request: any) => Promise<RuntimeResult>;
+/**
+ * Policy for subagents the model authors at call time rather than picking from
+ * `definitions`. Absent suppresses authoring entirely.
+ */
+export type RuntimeInlineSubagentsOptions = {
+    /**
+     * Only `false` turns authoring off.
+     */
+    enabled?: boolean;
+    /**
+     * Ceiling on what an authored subagent may
+     * request. Absent means the safe read-only default set, never every built-in.
+     */
+    allowedTools?: ReadonlyArray<string>;
+};
+export type RuntimeSubagentsOptions = {
+    /**
+     * Named profiles.
+     */
+    definitions?: ReadonlyArray<RuntimeSubagentDefinition>;
+    /**
+     * Call-time authoring policy.
+     */
+    inline?: RuntimeInlineSubagentsOptions;
+    /**
+     * In-flight subagents per parent turn. Default 5.
+     */
+    maxConcurrent?: number;
+    /**
+     * Total Agent calls per parent turn. Default 20.
+     */
+    maxPerTurn?: number;
+    /**
+     * Default per-subagent turn cap. Default 100.
+     */
+    maxTurns?: number;
+    /**
+     * Default per-subagent wall clock.
+     */
+    timeoutMs?: number;
+    /**
+     * Nested-run callback; absent uses the kernel self-run.
+     */
+    run?: RuntimeSubagentRun;
+    /**
+     * Kernel-owned. Absent/0 is the parent; >=1 suppresses the `Agent` tool.
+     */
+    depth?: number;
+};
 export type RuntimeResult = {
     text?: string | null;
     structuredResult?: any;
@@ -634,6 +803,7 @@ export type RuntimeResult = {
         failureKind: (string | null);
         requestId?: (string | null);
         retryableSubkind?: (string | null);
+        retryIndex?: number;
         requirements?: any;
         routeSafety?: RuntimeRouteSafetyMode;
         safetyContract?: RuntimeRouteSafetyContract;

package/types/ai/backend.d.ts

@@ -1,57 +0,0 @@
-export function backendCapabilities(sdkOrModel: any): any;
-export function backendUsesExecenvConfig(sdk: any): boolean;
-export function backendSupportsSessionResume(sdk: any): boolean;
-export const BACKEND_CAPABILITIES: {
-    claude: {
-        supports_session_resume: boolean;
-        streaming: boolean;
-        structured_output: boolean;
-        native_runtime_config: any;
-        supports_mcp: boolean;
-        supports_skills: boolean;
-        supports_builtin_tools: boolean;
-        supports_live_input: boolean;
-        supports_native_subagents: boolean;
-        supports_fast_mode: boolean;
-        runtime: string;
-    };
-    pi: {
-        supports_session_resume: boolean;
-        supports_native_subagents: boolean;
-        streaming: boolean;
-        structured_output: boolean;
-        native_runtime_config: any;
-        supports_mcp: boolean;
-        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;
-        supports_mcp: boolean;
-        supports_skills: boolean;
-        supports_builtin_tools: boolean;
-        supports_live_input: boolean;
-        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/registry.d.ts

@@ -1 +0,0 @@
-export { listRuntimeBridges as listProviders, resolveRuntimeBridge as findProviderForModel, runtimeCapabilities } from "./runtime/registry.js";