@mono-agent/agent-runtime 0.4.0 → 0.5.0

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

@@ -0,0 +1,24 @@
+export function streamContentKey(streamEvent: any, fallback: any): any;
+export function jsonSerializable(value: any, fallback?: any): any;
+export function compactToolRawResult(result: any, resultContent: any): {
+    details_truncated?: boolean;
+    content: {
+        omitted: boolean;
+        reason: string;
+        original_length: number;
+    };
+    details: any;
+    truncated?: boolean;
+    original_length?: number;
+    preview?: any;
+};
+/**
+ * @param {any} toolName
+ * @param {any} args
+ * @param {{cwd?: any, toolLimits?: any}} [options]
+ */
+export function eventToolArgs(toolName: any, args: any, { cwd, toolLimits }?: {
+    cwd?: any;
+    toolLimits?: any;
+}): any;
+export function emitCaptured(events: any, onEvent: any, event: any): void;

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

@@ -0,0 +1,5 @@
+export function promptTextFromMessages(messages: any): string;
+export function toAgentMessages(messages: any, model: any): any[];
+export function textFromContent(content: any): string;
+export function thinkingFromContent(content: any): string;
+export function toolResultContent(result: any): string;

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

@@ -0,0 +1,57 @@
+export function resolvePiRuntimeModel(resolved: any, options: any): {
+    model: {
+        id: any;
+        name: any;
+        api: string;
+        provider: string;
+        baseUrl: string;
+        reasoning: boolean;
+        input: string[];
+        cost: {
+            input: number;
+            output: number;
+            cacheRead: number;
+            cacheWrite: number;
+        };
+        contextWindow: number;
+        maxTokens: number;
+        compat: {
+            supportsStore: boolean;
+            supportsDeveloperRole: boolean;
+            supportsReasoningEffort: boolean;
+            maxTokensField: string;
+        };
+    };
+    capabilities: any;
+    apiKeys: Map<string, any>;
+} | {
+    model: import("@earendil-works/pi-ai").Model<never>;
+    capabilities: {
+        tool_use: boolean;
+        reasoning: boolean;
+        reasoning_mode: string;
+        reasoning_levels: string[];
+        reasoning_disable_supported: boolean;
+        vision: boolean;
+        json_mode: boolean;
+    };
+    apiKeys: Map<any, any>;
+};
+export namespace EMPTY_USAGE {
+    let input: number;
+    let output: number;
+    let cacheRead: number;
+    let cacheWrite: number;
+    let totalTokens: number;
+    namespace cost {
+        let input_1: number;
+        export { input_1 as input };
+        let output_1: number;
+        export { output_1 as output };
+        let cacheRead_1: number;
+        export { cacheRead_1 as cacheRead };
+        let cacheWrite_1: number;
+        export { cacheWrite_1 as cacheWrite };
+        export let total: number;
+    }
+}

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

@@ -0,0 +1,86 @@
+export function estimateCurrentContextTokens(session: any, fixedOverheadTokens?: number): Promise<{
+    tokens: number;
+    source: string;
+}>;
+export function tryCompact(harness: any, { trigger, onEvent, runtimeWarnings, onCompactionRecorded, runId, model }: {
+    trigger: any;
+    onEvent: any;
+    runtimeWarnings: any;
+    onCompactionRecorded: any;
+    runId: any;
+    model: any;
+}): Promise<{
+    applied: boolean;
+    tokensBefore: number;
+    nothingToCompact: boolean;
+}>;
+/**
+ * Express the kernel's compaction policy as a pi `CompactionSettings` so the
+ * proactive trigger runs through pi's own `shouldCompact()`.
+ *
+ * EQUIVALENCE (exact, proven by pi-native-compaction-parity.test.js): pi fires
+ * when `contextTokens > contextWindow - reserveTokens` (STRICT `>`), while the
+ * kernel policy fires when `estimate >= triggerTokens` (`>=`). Both `estimate`
+ * and `triggerTokens` are non-negative INTEGERS — pi's `estimateTokens` /
+ * `calculateContextTokens` return `Math.ceil(...)`/summed provider counts, and
+ * `resolveAgentCompactionPolicy` builds `triggerTokens` with `Math.floor` — so
+ * for integers `x >= t` iff `x > t - 1`. Setting
+ *   `reserveTokens = contextWindow - triggerTokens + 1`
+ * gives `contextWindow - reserveTokens = triggerTokens - 1`, hence
+ *   `shouldCompact(x, window, s)` == `x > triggerTokens - 1` == `x >= triggerTokens`.
+ * `triggerTokens < contextWindow` always (it is `min(floor(window*ratio),
+ * window - reserve)` with `ratio <= 0.95`), so `reserveTokens >= 2` — never
+ * degenerate. `keepRecentTokens` is carried through for a faithful settings
+ * object even though `shouldCompact` ignores it.
+ * @param {{enabled: boolean, contextWindow: number, triggerTokens: number, keepRecentTokens: number}} policy
+ * @returns {{enabled: boolean, reserveTokens: number, keepRecentTokens: number}}
+ */
+export function piCompactionSettings(policy: {
+    enabled: boolean;
+    contextWindow: number;
+    triggerTokens: number;
+    keepRecentTokens: number;
+}): {
+    enabled: boolean;
+    reserveTokens: number;
+    keepRecentTokens: number;
+};
+/**
+ * Resolve the compaction policy against the LIVE model's context window
+ * (auto-recognized from the model actually serving the request, lowered by any
+ * ceiling learned from a prior overflow). A positive `contextWindowOverride`
+ * (from the typed `compaction` policy object) replaces the auto-recognized
+ * window — it is not a legacy `settings` key, so it is applied here directly
+ * rather than through the settings shim. Drives the proactive trigger +
+ * reactive recovery.
+ * @param {{harness: any, runtime: any, resolved: any, settings: any, contextWindowOverride?: number}} params
+ */
+export function resolveLiveCompactionPolicy({ harness, runtime, resolved, settings, contextWindowOverride }: {
+    harness: any;
+    runtime: any;
+    resolved: any;
+    settings: any;
+    contextWindowOverride?: number;
+}): import("../../../agent/compaction.js").AgentCompactionPolicy;
+/**
+ * Proactive compaction: if the session is already near the window, compact
+ * BEFORE issuing the request so a long-lived session never overflows. Mutates
+ * runState.compaction (applied / compactedThisRun / diagnostics) and re-anchors
+ * runState.sessionBaselineCount when it fires.
+ * @param {any} runState
+ * @param {any} params
+ */
+export function runProactiveCompaction(runState: any, { harness, systemPrompt, options, tools, promptText, promptImages, reference, onEvent, runtimeWarnings, }: any): Promise<void>;
+/**
+ * Reactive recovery: if the turn ended in a context overflow and we have not
+ * already compacted-and-retried this run, compact once and re-prompt once.
+ * Learns the real ceiling from the overflow error. Returns the (possibly
+ * re-captured) state + runError.
+ * @param {any} runState
+ * @param {any} params
+ * @returns {Promise<{state: any, runError: any}>}
+ */
+export function runReactiveCompaction(runState: any, { harness, runtime, resolved, options, promptText, promptImages, reference, onEvent, runtimeWarnings, state, runError, captureState, }: any): Promise<{
+    state: any;
+    runError: any;
+}>;

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

@@ -0,0 +1,168 @@
+/**
+ * Sum assistant-message usage across a transcript slice.
+ * @param {Array<any>} [messages]
+ * @returns {{input: number, output: number, cacheRead: number, cacheWrite: number, cost: number}}
+ */
+export function usageFromMessages(messages?: Array<any>): {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+};
+/**
+ * Classify a pi error message into a runtime failure kind. Context-limit /
+ * max-turns terminations map to usage_limit; credential/config auth failures
+ * map to provider_auth; everything else to provider_unavailable. Null message → null.
+ * @param {string|null} message
+ * @param {Record<string, unknown>} diagnostics
+ * @param {{maxTurnsHit?: boolean}} [opts]
+ * @returns {string|null}
+ */
+export function failureKindForPiError(message: string | null, diagnostics: Record<string, unknown>, { maxTurnsHit }?: {
+    maxTurnsHit?: boolean;
+}): string | null;
+/**
+ * Emit the per-run cache / cost / provider-completed events.
+ * @param {{onEvent: (event: any) => void, resolved: any, reference: string, usage: {input: number, output: number, cacheRead: number, cacheWrite: number, cost: number}, estimatedCost: number, start: number, externalAbort: boolean}} params
+ */
+export function emitUsageCostEvents({ onEvent, resolved, reference, usage, estimatedCost, start, externalAbort }: {
+    onEvent: (event: any) => void;
+    resolved: any;
+    reference: string;
+    usage: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        cost: number;
+    };
+    estimatedCost: number;
+    start: number;
+    externalAbort: boolean;
+}): void;
+/**
+ * Emit the capabilities_resolved event.
+ * @param {(event: any) => void} onEvent
+ * @param {{sdk: string, model: string, capabilitiesUsed: any}} payload
+ */
+export function emitCapabilitiesResolved(onEvent: (event: any) => void, { sdk, model, capabilitiesUsed }: {
+    sdk: string;
+    model: string;
+    capabilitiesUsed: any;
+}): void;
+/**
+ * The aborted-run result (entry pre-check / pre-request abort). Pure factory.
+ * @param {{resolved: any, options: any, events: any[], runtimeWarnings: any[], start: number, providerSessionId: string}} params
+ */
+export function abortedResult({ resolved, options, events, runtimeWarnings, start, providerSessionId }: {
+    resolved: any;
+    options: any;
+    events: any[];
+    runtimeWarnings: any[];
+    start: number;
+    providerSessionId: string;
+}): {
+    text: any;
+    thinking: string;
+    events: any[];
+    usage: {};
+    durationMs: number;
+    numTurns: number;
+    model: any;
+    effort: any;
+    sdk: any;
+    cancelled: boolean;
+    error: any;
+    failureKind: any;
+    providerSessionId: string;
+    runtimeWarnings: any[];
+    diagnostics: {
+        provider_session_id: string;
+        pi_stop_reason: string;
+        pi_engine: string;
+        external_abort: boolean;
+    };
+};
+/**
+ * The verbatim success-path result object (also carries a run-level error when
+ * a turn ended in an error/max-turns/abort without throwing). Pure assembly.
+ * @param {object} params
+ */
+export function buildSuccessResult(params: object): {
+    structuredResult: any;
+    structuredResultSource: string;
+    text: any;
+    thinking: any;
+    events: any;
+    usage: {
+        input_tokens: any;
+        output_tokens: any;
+        cache_read_tokens: any;
+        cache_creation_tokens: any;
+        cache_write_tokens: any;
+        cost_usd: any;
+    };
+    durationMs: number;
+    numTurns: any;
+    model: any;
+    effort: any;
+    sdk: any;
+    cancelled: any;
+    error: any;
+    errorDetails: any;
+    failureKind: string;
+    providerSessionId: any;
+    runtimeWarnings: any;
+    diagnostics: any;
+    capabilitiesUsed: any;
+};
+/**
+ * The verbatim outer-catch error result. Pure assembly.
+ * @param {object} params
+ */
+export function buildErrorResult(params: object): {
+    text: any;
+    events: any;
+    usage: {};
+    durationMs: number;
+    numTurns: any;
+    model: any;
+    effort: any;
+    sdk: any;
+    cancelled: any;
+    error: any;
+    errorDetails: {
+        pi_stop_reason: string;
+        last_tool_name: any;
+        tool_results_seen: any;
+        turn_count: any;
+        max_turns_hit: any;
+        provider_session_id: any;
+        pi_engine: string;
+        pi_error_retryable: any;
+    };
+    failureKind: string;
+    providerSessionId: any;
+    runtimeWarnings: any;
+    diagnostics: {
+        provider_session_id: any;
+        pi_stop_reason: string;
+        pi_engine: string;
+        max_turns_hit: any;
+        turn_count: any;
+        external_abort: any;
+    };
+};
+/**
+ * Assemble the success-path diagnostics object. Pure.
+ * @param {object} params
+ * @returns {Record<string, unknown>}
+ */
+export function buildDiagnostics(params: object): Record<string, unknown>;
+/**
+ * Assemble the success-path errorDetails object (or null when no error). Pure.
+ * @param {object} params
+ * @returns {Record<string, unknown>|null}
+ */
+export function buildErrorDetails(params: object): Record<string, unknown> | null;

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

@@ -0,0 +1,62 @@
+export function resolveDurableNativeSessionRepo(piSessionsRoot: any): any;
+/**
+ * Resolve the session for this run: warm registry hit, durable cold reopen,
+ * create-on-miss (durable resume only), or fresh create. Mutates runState
+ * (session / sessionEntry / createdOnMiss / reservation). Returns
+ * `{ done: true, result }` for a fast-fail early return (session_not_found /
+ * session_busy), else `{ done: false }` to proceed.
+ * @param {any} runState
+ * @param {any} params
+ * @returns {Promise<{done: true, result: any} | {done: false}>}
+ */
+export function resolveSession(runState: any, { requestedSessionId, providerSessionId, durableRepo, sessionTtlMs, cwd, resolved, options, events, runtimeWarnings, start, }: any): Promise<{
+    done: true;
+    result: any;
+} | {
+    done: false;
+}>;
+/**
+ * Drop an uncommitted fresh session (and any create-on-miss reservation) on the
+ * pre-request abort path. A resumed (user-owned) session is NEVER deleted
+ * (guarded `session && !sessionEntry`).
+ * @param {any} runState
+ * @param {{durableRepo: any}} params
+ */
+export function discardUncommittedSession(runState: any, { durableRepo }: {
+    durableRepo: any;
+}): Promise<void>;
+/**
+ * Session lifecycle commit: keep-alive registration, resumed-turn rollback, or
+ * fresh/non-keep-alive drop. The harness already durably persisted the
+ * transcript; this tracks LIVENESS so disposeProviderSession / idle-TTL
+ * eviction can reach native sessions, and rolls a failed/aborted resumed turn
+ * back to its pre-turn leaf.
+ * @param {any} runState
+ * @param {any} params
+ */
+export function commitSession(runState: any, { options, requestedSessionId, providerSessionId, durableRepo, sessionTtlMs, externalAbort, errorMessage, onEvent, }: any): Promise<void>;
+/**
+ * Final abort guard (durable cancel TOCTOU) rollback actions: a resumed session
+ * moves to its baseline leaf and drops its live entry; a fresh durable session
+ * deletes its jsonl. The orchestrator keeps the abort re-check + return inline
+ * so no await sits between the re-check and the return (I10); this only runs the
+ * rollback body when the guard fires.
+ * @param {any} runState
+ * @param {{requestedSessionId: string|null, providerSessionId: string, durableRepo: any}} params
+ */
+export function rollbackAbortedTurn(runState: any, { requestedSessionId, providerSessionId, durableRepo }: {
+    requestedSessionId: string | null;
+    providerSessionId: string;
+    durableRepo: any;
+}): Promise<void>;
+/**
+ * Outer-catch session cleanup: drop a just-created fresh durable session, drop a
+ * create-on-miss reservation placeholder, and roll a resumed session back to its
+ * pre-turn leaf for host/runtime-side throws that landed after the harness
+ * already mutated the live session.
+ * @param {any} runState
+ * @param {{durableRepo: any}} params
+ */
+export function cleanupSessionOnThrow(runState: any, { durableRepo }: {
+    durableRepo: any;
+}): Promise<void>;

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

@@ -0,0 +1,50 @@
+/**
+ * The tool-start progress line surfaced as a thinking block, or null for a
+ * blank/invalid tool name.
+ * @param {unknown} toolName
+ * @returns {string|null}
+ */
+export function toolStartProgressText(toolName: unknown): string | null;
+/**
+ * The slice of run state the stream subscriber reads and mutates. A structural
+ * subset of the orchestrator's runState.
+ * @typedef {object} StreamSubscriberState
+ * @property {string[]} assistantTexts
+ * @property {string[]} assistantThinking
+ * @property {Set<unknown>} textDeltaIndexes
+ * @property {Set<unknown>} thinkingDeltaIndexes
+ * @property {Map<string, number>} toolStartTimes
+ * @property {number} turnCount
+ * @property {number} toolResultsSeen
+ * @property {string|null} lastToolName
+ * @property {boolean} maxTurnsHit
+ */
+/**
+ * Build the harness subscribe handler. `harness` is passed for the maxTurns
+ * abort; it is already constructed when this is wired (subscribe follows the
+ * AgentHarness constructor).
+ * @param {StreamSubscriberState} runState
+ * @param {{onEvent: (event: any) => void, options: any, toolLimits: any, harness: any}} deps
+ * @returns {(event: any) => void}
+ */
+export function createStreamSubscriber(runState: StreamSubscriberState, { onEvent, options, toolLimits, harness }: {
+    onEvent: (event: any) => void;
+    options: any;
+    toolLimits: any;
+    harness: any;
+}): (event: any) => void;
+/**
+ * The slice of run state the stream subscriber reads and mutates. A structural
+ * subset of the orchestrator's runState.
+ */
+export type StreamSubscriberState = {
+    assistantTexts: string[];
+    assistantThinking: string[];
+    textDeltaIndexes: Set<unknown>;
+    thinkingDeltaIndexes: Set<unknown>;
+    toolStartTimes: Map<string, number>;
+    turnCount: number;
+    toolResultsSeen: number;
+    lastToolName: string | null;
+    maxTurnsHit: boolean;
+};

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

@@ -0,0 +1,69 @@
+/**
+ * Append the StructuredOutput usage instruction to the system prompt when an
+ * output schema is active. No schema → the prompt is returned unchanged. A host
+ * or run `prompts.structuredOutputInstruction(systemPrompt)` override, when
+ * supplied, replaces the default instruction text (it receives the raw system
+ * prompt and returns the augmented one); otherwise the default below is used.
+ * @param {string} systemPrompt
+ * @param {unknown} outputSchema
+ * @param {import('../../types.js').RuntimePromptOverrides} [prompts]
+ * @returns {string}
+ */
+export function appendStructuredOutputInstruction(systemPrompt: string, outputSchema: unknown, prompts?: import("../../types.js").RuntimePromptOverrides): string;
+/**
+ * The finalization re-prompt issued when a turn ended without submitting the
+ * required structured result. A `prompts.structuredOutputFinalization()`
+ * override, when supplied, replaces the default text.
+ * @param {import('../../types.js').RuntimePromptOverrides} [prompts]
+ * @returns {string}
+ */
+export function structuredOutputFinalizationPrompt(prompts?: import("../../types.js").RuntimePromptOverrides): string;
+/**
+ * Whether the run should re-prompt once for structured-output finalization: a
+ * schema is active, no structured result was produced, the turn ended with no
+ * text, the run was not aborted / did not hit max turns, and the stop reason is
+ * not an error/abort.
+ * @param {{outputSchema: unknown, structuredResult: unknown, finalText: unknown, stopReason: unknown, externalAbort: boolean, maxTurnsHit: boolean}} params
+ * @returns {boolean}
+ */
+export function shouldRetryStructuredOutputFinalization({ outputSchema, structuredResult, finalText, stopReason, externalAbort, maxTurnsHit, }: {
+    outputSchema: unknown;
+    structuredResult: unknown;
+    finalText: unknown;
+    stopReason: unknown;
+    externalAbort: boolean;
+    maxTurnsHit: boolean;
+}): boolean;
+/**
+ * The structured-output finalization diagnostics spread into the run's
+ * diagnostics/errorDetails. Empty when no retry was attempted.
+ * @param {number} attempts
+ * @param {string|null} reason
+ * @param {boolean} failed
+ * @returns {Record<string, unknown>}
+ */
+export function structuredOutputRetryDiagnostics(attempts: number, reason: string | null, failed: boolean): Record<string, unknown>;
+/**
+ * Run the single structured-output finalization re-prompt in the same session.
+ *
+ * The harness is idle after waitForIdle(), so re-prompt (not followUp, which
+ * only queues onto an active run) with only StructuredOutput active. This
+ * re-prompts ONCE in the same session, matching the legacy single
+ * agent.continue() finalization re-prompt. Tools are restored in finally.
+ *
+ * Returns the retry bookkeeping ({attempts, reason}); the caller computes
+ * `failed` from the (closure-owned) structuredResult after re-capturing state.
+ * @param {{harness: any, structuredTool: {name: string}|null, runtimeWarnings: Array<Record<string, unknown>>, prompts?: import('../../types.js').RuntimePromptOverrides}} deps
+ * @returns {Promise<{attempts: number, reason: string}>}
+ */
+export function runStructuredOutputFinalizationRetry({ harness, structuredTool, runtimeWarnings, prompts }: {
+    harness: any;
+    structuredTool: {
+        name: string;
+    } | null;
+    runtimeWarnings: Array<Record<string, unknown>>;
+    prompts?: import("../../types.js").RuntimePromptOverrides;
+}): Promise<{
+    attempts: number;
+    reason: string;
+}>;

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

@@ -0,0 +1,60 @@
+/**
+ * Build the turn's tool set: the sandboxed/allowlisted/bloat-guarded builtin
+ * tools, the MCP tool bridge, and the StructuredOutput tool (whose callback
+ * writes runState.structuredResult). Surfaces MCP init/list failures to both the
+ * event stream and runtimeWarnings. Returns the assembled tools plus the MCP
+ * clients (closed by the caller's finally) and the structured tool.
+ * @param {any} runState
+ * @param {any} params
+ * @returns {Promise<{tools: any[], structuredTool: any, mcpClients: any[]}>}
+ */
+export function buildTurnTools(runState: any, { options, capabilities, toolLimits, approvalManager, runtime, resolved, onEvent, runtimeWarnings, }: any): Promise<{
+    tools: any[];
+    structuredTool: any;
+    mcpClients: any[];
+}>;
+/**
+ * Map an effort level to the harness thinkingLevel, respecting model reasoning
+ * capability (no reasoning / reasoning_mode "none" → "off").
+ * @param {string} effort
+ * @param {any} capabilities
+ * @returns {string}
+ */
+export function thinkingLevelForEffort(effort: string, capabilities: any): string;
+/**
+ * Construct the AgentHarness for this turn, subscribe the stream-subscriber, and
+ * wire the external abort handler. Sets runState.harness and
+ * runState.removeAbortHandler; the abort handler sets runState.externalAbort and
+ * aborts the harness. Returns the harness.
+ * @param {any} runState
+ * @param {any} params
+ * @returns {any}
+ */
+export function buildTurnHarness(runState: any, { cwd, session, piModels, model, thinkingLevel, systemPrompt, outputSchema, tools, maxRetries, maxRetryDelayMs, steeringMode, onEvent, options, toolLimits, }: any): any;
+/**
+ * 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
+ * runComplete flag) so it stops steering once the run finishes and does not
+ * swallow a follow-up meant for a later turn. Returns a `stop()` teardown.
+ * @param {{harness: any, options: any, onEvent: (event: any) => void}} deps
+ * @returns {{stop: () => Promise<void>}}
+ */
+export function startLiveInput({ harness, options, onEvent }: {
+    harness: any;
+    options: any;
+    onEvent: (event: any) => void;
+}): {
+    stop: () => Promise<void>;
+};
+/**
+ * Run a single prompt on the harness and wait for it to go idle. A stream error
+ * surfaces on the harness (not a throw), so a thrown prompt is captured as
+ * runError; waitForIdle always runs afterward.
+ * @param {any} harness
+ * @param {string} promptText
+ * @param {Array<any>} promptImages
+ * @returns {Promise<{runError: any}>}
+ */
+export function runHarnessPrompt(harness: any, promptText: string, promptImages: Array<any>): Promise<{
+    runError: any;
+}>;

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

@@ -0,0 +1,18 @@
+export function createDynamicCredentialStore(apiKeys: any, resolvePiApiKey: any, runtimeWarnings: any): any;
+export function splitPromptMessages(messages: any, model: any): {
+    priorMessages: any[];
+    promptText: string;
+    promptImages: {
+        type: string;
+        data: any;
+        mimeType: any;
+    }[];
+};
+export function generatePiNativeResponse(systemPrompt: any, options?: {}): Promise<any>;
+export namespace piNativeRuntimeBridge {
+    export let id: string;
+    export let kind: string;
+    export let capabilities: any;
+    export function supports(ref: any): boolean;
+    export { generatePiNativeResponse as execute };
+}

package/types/ai/registry.d.ts

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

package/types/ai/runtime/capabilities-used.d.ts

@@ -0,0 +1,21 @@
+export function buildCapabilitiesUsed({ promptCacheActive, thinkingEnabled, structuredOutputEnforced, subagentInvoked, mcpServersUsed, nativeSubagentsUsed, toolCompactionApplied, contextCompactionApplied, }?: {
+    promptCacheActive?: any;
+    thinkingEnabled?: any;
+    structuredOutputEnforced?: boolean;
+    subagentInvoked?: any;
+    mcpServersUsed?: any[];
+    nativeSubagentsUsed?: any[];
+    toolCompactionApplied?: boolean;
+    contextCompactionApplied?: any;
+}): {
+    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 function toolCompactionAppliedFromWarnings(runtimeWarnings?: any[]): boolean;
+export const UNKNOWN_CAPABILITY: any;

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

@@ -0,0 +1,33 @@
+export function runtimeCapabilities(sdkOrModel: any): any;
+export namespace COMMON_CAPABILITIES {
+    let streaming: boolean;
+    let structured_output: boolean;
+    let supports_session_resume: boolean;
+    let native_runtime_config: any;
+    let supports_mcp: boolean;
+    let supports_skills: boolean;
+    let supports_builtin_tools: boolean;
+    let supports_live_input: boolean;
+    let supports_native_subagents: boolean;
+}
+export namespace RUNTIME_CAPABILITIES {
+    namespace claude {
+        let supports_session_resume_1: boolean;
+        export { supports_session_resume_1 as supports_session_resume };
+        export let runtime: string;
+    }
+    namespace pi {
+        let supports_session_resume_2: boolean;
+        export { supports_session_resume_2 as supports_session_resume };
+        let supports_native_subagents_1: boolean;
+        export { supports_native_subagents_1 as supports_native_subagents };
+        let runtime_1: string;
+        export { runtime_1 as runtime };
+    }
+    namespace codex {
+        let supports_session_resume_3: boolean;
+        export { supports_session_resume_3 as supports_session_resume };
+        let runtime_2: string;
+        export { runtime_2 as runtime };
+    }
+}

package/types/ai/runtime/context-windows.d.ts

@@ -0,0 +1,8 @@
+export function normalizeContextWindow(value: any): "default" | "1m";
+export function stripContextWindowSuffix(model: any): string;
+export function claudeModelSupportsOneMillionContext(model: any): boolean;
+export function claudeModelSupportsContextWindow(model: any, contextWindow: any): boolean;
+export function modelWithContextWindow(model: any, contextWindow: any): string;
+export const DEFAULT_CONTEXT_WINDOW: "default";
+export const ONE_MILLION_CONTEXT_WINDOW: "1m";
+export const CLAUDE_ONE_MILLION_CONTEXT_MODELS: Set<string>;

package/types/ai/runtime/fast-mode.d.ts

@@ -0,0 +1,2 @@
+export function codexModelSupportsFastMode(model: any): boolean;
+export function normalizeFastMode(value: any, fallback?: boolean): boolean;