@mono-agent/agent-runtime 0.20.11 → 0.21.0

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

@@ -45,7 +45,7 @@ export function thinkingLevelForEffort(effort: string, capabilities: any): strin
 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, }: {
+export function buildTurnHarness(runState: any, { session, piModels, model, thinkingLevel, systemPrompt, outputSchema, tools, transport, maxRetries, maxRetryDelayMs, steeringMode, options, }: {
     session: any;
     piModels: any;
     model: any;
@@ -57,27 +57,80 @@ export function buildTurnHarness(runState: any, { session, piModels, model, thin
     maxRetries: any;
     maxRetryDelayMs: any;
     steeringMode: any;
-    onEvent: any;
+    options: any;
+}): Promise<{
+    getPromptCacheRequest: () => any;
+    models: any;
+    getModel: () => any;
+    getThinkingLevel: () => any;
+    getActiveTools: () => any;
+    setActiveTools(names: any): Promise<void>;
+    setCompactionSettings(settings: any): Promise<void>;
+    appendMessage(message: any): Promise<any>;
+    prompt(text: any, promptOptions: any): Promise<any>;
+    steer(message: any): Promise<string>;
+    cancelQueued(entryId: any): Promise<any>;
+    abort(): Promise<void>;
+    waitForIdle(): any;
+    compact(): Promise<any>;
+    on(type: any, handler: any): any;
+    subscribe(listener: any): () => void;
+    abortOpenOperations(): Promise<void>;
+    close(): Promise<void>;
+}>;
+/**
+ * Subscribe only after prior history has been seeded. Pi emits message
+ * lifecycle events for manual appendMessage() calls; subscribing earlier makes
+ * restored assistant messages look like fresh output boundaries.
+ * @param {any} runState
+ * @param {{harness: any, onEvent: (event: any) => void, options: any, toolLimits: any, sdk: string, reference: string}} deps
+ */
+export function activateTurnHarness(runState: any, { harness, onEvent, options, toolLimits, sdk, reference, }: {
+    harness: any;
+    onEvent: (event: any) => void;
     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>>;
+    sdk: string;
+    reference: string;
+}): void;
 /**
  * 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
+ * @param {{harness: any, options: any, onEvent: (event: any) => void, promptEpoch?: any}} deps
  * @returns {{stop: () => Promise<void>}}
  */
-export function startLiveInput({ harness, options, onEvent }: {
+export function startLiveInput({ harness, options, onEvent, promptEpoch }: {
     harness: any;
     options: any;
     onEvent: (event: any) => void;
+    promptEpoch?: any;
 }): {
     stop: () => Promise<void>;
 };
+/**
+ * Own exact Pi run/entry correlation for the one main prompt in this Mono run.
+ * @param {{harness: any, onEvent: (event: any) => void}} deps
+ */
+export function createLiveInputPromptEpoch({ harness, onEvent }: {
+    harness: any;
+    onEvent: (event: any) => void;
+}): {
+    ownedRunId: () => string;
+    consumedInputIds: () => any[];
+    register(entryId: any, message: any): void;
+    isConsumed: (entryId: any) => boolean;
+    /**
+     * Own the admitted operation as soon as Pi reports its id, before the run
+     * settles, so entries consumed mid-run are acknowledged when their
+     * message_end arrives rather than in one batch at the end of the run.
+     * Safe in either order with run_start; a conflicting id invalidates.
+     */
+    confirm(operationId: any): void;
+    finish(operationId: any): void;
+    close(): 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
@@ -85,9 +138,14 @@ export function startLiveInput({ harness, options, onEvent }: {
  * @param {any} harness
  * @param {string} promptText
  * @param {Array<any>} promptImages
- * @returns {Promise<{runError: any}>}
+ * @param {{onOperationAdmitted?: (operationId: string) => void}} [hooks]
+ *   `onOperationAdmitted` fires as soon as Pi admits the run, before any
+ *   provider request, so the live-input epoch can own the operation up front.
+ * @returns {Promise<{runError: any, operationId?: string}>}
  */
-export function runHarnessPrompt(harness: any, promptText: string, promptImages: Array<any>): Promise<{
+export function runHarnessPrompt(harness: any, promptText: string, promptImages: Array<any>, hooks?: {
+    onOperationAdmitted?: (operationId: string) => void;
+}): Promise<{
     runError: any;
+    operationId?: string;
 }>;
-import { AgentHarness } from "@earendil-works/pi-agent-core";

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

@@ -1,7 +1,8 @@
 /**
- * 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.
+ * Resolve mono-agent's programmatic mode once per run. Tool builders mark
+ * stateful/mutating tools sequential; the Pi 0.85 harness adapter promotes any
+ * such marker to its global toolExecution setting because mixed scheduling is
+ * no longer available upstream.
  */
 export function resolvePiToolExecutionMode(options?: {}): {
     mode: any;
@@ -24,7 +25,23 @@ export function generatePiNativeResponse(systemPrompt: any, options?: {}): Promi
 export namespace piNativeRuntimeBridge {
     export let id: string;
     export let kind: string;
-    export let capabilities: any;
+    export let capabilities: {
+        kind: "pi";
+    } & {
+        supports_session_resume: boolean;
+        supports_native_subagents: boolean;
+        supports_request_tool_environment: boolean;
+        supports_mcp_apps: boolean;
+        tool_policy: "projected";
+        streaming: boolean;
+        structured_output: boolean;
+        native_runtime_config: any;
+        supports_mcp: boolean;
+        supports_skills: boolean;
+        supports_builtin_tools: boolean;
+        supports_live_input: boolean;
+        runtime: string;
+    };
     export function supports(ref: any): boolean;
     export { generatePiNativeResponse as execute };
 }

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

@@ -1,84 +1,35 @@
-export function runtimeCapabilities(sdkOrModel: any): any;
+/**
+ * @param {*} [_legacySelection]
+ * @returns {{kind: "pi"} & typeof RUNTIME_CAPABILITIES.pi}
+ */
+export function runtimeCapabilities(_legacySelection?: any): {
+    kind: "pi";
+} & typeof RUNTIME_CAPABILITIES.pi;
 export namespace COMMON_CAPABILITIES {
-    export let streaming: boolean;
-    export let structured_output: boolean;
-    export let supports_session_resume: boolean;
-    export let native_runtime_config: any;
-    export let supports_mcp: boolean;
-    export let supports_mcp_apps: boolean;
-    export let supports_skills: boolean;
-    export let supports_builtin_tools: boolean;
-    export let supports_live_input: boolean;
-    export let supports_native_subagents: boolean;
-    export let supports_request_tool_environment: boolean;
-    export let supports_fast_mode: boolean;
-    export { TOOL_POLICY_PROJECTED as tool_policy };
+    let streaming: boolean;
+    let structured_output: boolean;
+    let supports_session_resume: boolean;
+    let native_runtime_config: any;
+    let supports_mcp: boolean;
+    let supports_mcp_apps: boolean;
+    let supports_skills: boolean;
+    let supports_builtin_tools: boolean;
+    let supports_live_input: boolean;
+    let supports_native_subagents: boolean;
+    let supports_request_tool_environment: boolean;
 }
 export namespace RUNTIME_CAPABILITIES {
-    namespace claude {
+    namespace pi {
         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 supports_request_tool_environment_1: boolean;
         export { supports_request_tool_environment_1 as supports_request_tool_environment };
         let supports_mcp_apps_1: boolean;
         export { supports_mcp_apps_1 as supports_mcp_apps };
-        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 supports_fast_mode_1: boolean;
-        export { supports_fast_mode_1 as supports_fast_mode };
-        export { TOOL_POLICY_ALLOW_ALL_ONLY as tool_policy };
-        let runtime_2: string;
-        export { runtime_2 as runtime };
-    }
-    namespace opencode {
-        let structured_output_1: boolean;
-        export { structured_output_1 as structured_output };
-        let supports_session_resume_4: boolean;
-        export { supports_session_resume_4 as supports_session_resume };
-        let supports_mcp_1: boolean;
-        export { supports_mcp_1 as supports_mcp };
-        let supports_skills_1: boolean;
-        export { supports_skills_1 as supports_skills };
-        let supports_live_input_1: boolean;
-        export { supports_live_input_1 as supports_live_input };
-        let supports_native_subagents_2: boolean;
-        export { supports_native_subagents_2 as supports_native_subagents };
-        export { TOOL_POLICY_ALLOW_ALL_ONLY as tool_policy };
-        let runtime_3: string;
-        export { runtime_3 as runtime };
-    }
-    namespace acp {
-        let structured_output_2: boolean;
-        export { structured_output_2 as structured_output };
-        let supports_session_resume_5: boolean;
-        export { supports_session_resume_5 as supports_session_resume };
-        let supports_mcp_2: boolean;
-        export { supports_mcp_2 as supports_mcp };
-        let supports_skills_2: boolean;
-        export { supports_skills_2 as supports_skills };
-        let supports_builtin_tools_1: boolean;
-        export { supports_builtin_tools_1 as supports_builtin_tools };
-        let supports_live_input_2: boolean;
-        export { supports_live_input_2 as supports_live_input };
-        let supports_native_subagents_3: boolean;
-        export { supports_native_subagents_3 as supports_native_subagents };
-        let supports_request_tool_environment_2: boolean;
-        export { supports_request_tool_environment_2 as supports_request_tool_environment };
-        export { TOOL_POLICY_ALLOW_ALL_ONLY as tool_policy };
-        let runtime_4: string;
-        export { runtime_4 as runtime };
+        export { TOOL_POLICY_PROJECTED as tool_policy };
+        export let runtime: string;
     }
 }
 import { TOOL_POLICY_PROJECTED } from "./tool-policy.js";
-import { TOOL_POLICY_ALLOW_ALL_ONLY } from "./tool-policy.js";

package/types/ai/runtime/live-input-events.d.ts

@@ -1,22 +1,46 @@
 /**
- * @typedef {{body: string, id?: string, receivedAt?: string, acknowledge?: () => void, reject?: (reason?: unknown) => void}} RuntimeLiveInputMessage
- * @typedef {{type: "live_input_applied", inputId: string, receivedAt?: string}} LiveInputAppliedEvent
+ * @typedef {{providerEntryId?: string, providerRunId?: string}} RuntimeLiveInputEvidence
+ * @typedef {{reason: "delivery_uncertain", providerEntryId?: string, providerRunId?: string}} RuntimeLiveInputUncertainty
+ * @typedef {{body: string, id?: string, receivedAt?: string, logicalOwner?: object, accepted?: (evidence?: RuntimeLiveInputEvidence) => unknown, acknowledge?: (evidence?: RuntimeLiveInputEvidence) => unknown, uncertain?: (details: RuntimeLiveInputUncertainty) => unknown, reject?: (reason?: unknown) => unknown}} RuntimeLiveInputMessage
+ * @typedef {{message: RuntimeLiveInputMessage, callbackMessage: RuntimeLiveInputMessage, logicalOwner?: object, inputId: string, receivedAt?: string, phase: "available"|"leased"|"native_accepted"|"consumed"|"uncertain", attempt: number, generation: number}} LiveInputOwner
+ * @typedef {{type: string, [key: string]: unknown}} LiveInputEvent
  */
 /**
  * @param {AsyncIterable<RuntimeLiveInputMessage>|undefined} liveInput
- * @param {(event: LiveInputAppliedEvent) => void} onApplied
+ * @param {(event: LiveInputEvent) => void} onEvent
  * @returns {AsyncIterable<RuntimeLiveInputMessage>|undefined}
  */
-export function instrumentLiveInputAppliedEvents(liveInput: AsyncIterable<RuntimeLiveInputMessage> | undefined, onApplied: (event: LiveInputAppliedEvent) => void): AsyncIterable<RuntimeLiveInputMessage> | undefined;
+export function instrumentLiveInputAppliedEvents(liveInput: AsyncIterable<RuntimeLiveInputMessage> | undefined, onEvent: (event: LiveInputEvent) => void): AsyncIterable<RuntimeLiveInputMessage> | undefined;
+export type RuntimeLiveInputEvidence = {
+    providerEntryId?: string;
+    providerRunId?: string;
+};
+export type RuntimeLiveInputUncertainty = {
+    reason: "delivery_uncertain";
+    providerEntryId?: string;
+    providerRunId?: string;
+};
 export type RuntimeLiveInputMessage = {
     body: string;
     id?: string;
     receivedAt?: string;
-    acknowledge?: () => void;
-    reject?: (reason?: unknown) => void;
+    logicalOwner?: object;
+    accepted?: (evidence?: RuntimeLiveInputEvidence) => unknown;
+    acknowledge?: (evidence?: RuntimeLiveInputEvidence) => unknown;
+    uncertain?: (details: RuntimeLiveInputUncertainty) => unknown;
+    reject?: (reason?: unknown) => unknown;
 };
-export type LiveInputAppliedEvent = {
-    type: "live_input_applied";
+export type LiveInputOwner = {
+    message: RuntimeLiveInputMessage;
+    callbackMessage: RuntimeLiveInputMessage;
+    logicalOwner?: object;
     inputId: string;
     receivedAt?: string;
+    phase: "available" | "leased" | "native_accepted" | "consumed" | "uncertain";
+    attempt: number;
+    generation: number;
+};
+export type LiveInputEvent = {
+    type: string;
+    [key: string]: unknown;
 };

package/types/ai/runtime/model-refs.d.ts

@@ -1,35 +1,11 @@
-/**
- * @param {string} value
- * @returns {string}
- */
-export function canonicalizeLegacyModelReference(value: string): string;
 /**
  * @param {string} value
  * @returns {RuntimeModelRef}
  */
 export function normalizeRuntimeModelReference(value: string): RuntimeModelRef;
-/**
- * @param {string} value
- * @returns {RuntimeModelRef["sdk"]}
- */
-export function sdkFromModelReference(value: string): RuntimeModelRef["sdk"];
 /**
  * @param {string} value
  * @returns {RuntimeModelRef}
  */
 export function parseRuntimeModelReference(value: string): RuntimeModelRef;
-/**
- * @param {string|RuntimeModelRef} modelRefOrParsed
- * @param {string} executionMode
- * @returns {string|null}
- */
-export function executionModeIncompatibilityReason(modelRefOrParsed: string | RuntimeModelRef, executionMode: string): string | null;
-/**
- * @param {string|RuntimeModelRef} modelRefOrParsed
- * @param {string} executionMode
- * @returns {boolean}
- */
-export function isModelCompatibleWithExecutionMode(modelRefOrParsed: string | RuntimeModelRef, executionMode: string): boolean;
-export const ACTIVE_RUNTIME_KINDS: string[];
-export const RESERVED_RUNTIME_KINDS: string[];
 export type RuntimeModelRef = import("../types.js").RuntimeModelRef;

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

@@ -2,22 +2,18 @@
  * @param {Object} [options]
  * @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, retryIndex: number, routeSafety: "uniform"|"per-route-native"}) => (RouterAttemptResolution|Promise<RouterAttemptResolution>)} [options.resolveAttempt]
+ * @param {(input: {model: RuntimeModelRef, attemptIndex: number, retryIndex: number}) => (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, retry }?: {
+export function createRouterRuntime({ host, chain, resolveAttempt, retry }?: {
     host?: AgentRuntimeHostOptions;
     chain?: ReadonlyArray<RuntimeModelRef | RouterChainEntryInput>;
-    routeSafety?: "uniform" | "per-route-native";
     resolveAttempt?: (input: {
         model: RuntimeModelRef;
-        executionMode: string | null;
         attemptIndex: number;
         retryIndex: number;
-        routeSafety: "uniform" | "per-route-native";
     }) => (RouterAttemptResolution | Promise<RouterAttemptResolution>);
     retry?: Partial<RouterRetryPolicy>;
 }): AgentRuntimeInstance & {
@@ -30,12 +26,10 @@ 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?,
- * attempts?}` form.
+ * RuntimeModelRef, or the full `{model, effort?, requires?, attempts?}` form.
  */
 export type RouterChainEntryInput = {
     model: RuntimeModelRef;
-    executionMode?: string;
     effort?: string | null;
     requires?: {
         [x: string]: any;
@@ -44,7 +38,6 @@ export type RouterChainEntryInput = {
 };
 export type RouterChainEntry = {
     model: RuntimeModelRef;
-    executionMode: string | null;
     effort: string | null | undefined;
     requires: {
         [x: string]: any;

package/types/ai/runtime/tool-policy.d.ts

@@ -11,5 +11,3 @@
 export function isAllowAllToolPolicy(allowedTools: any, disallowedTools: any): boolean;
 /** @type {"projected"} */
 export const TOOL_POLICY_PROJECTED: "projected";
-/** @type {"allow_all_only"} */
-export const TOOL_POLICY_ALLOW_ALL_ONLY: "allow_all_only";

package/types/ai/tool-lifecycle.d.ts

@@ -1,9 +1,10 @@
 /**
- * @param {{sink?: (event: any) => Promise<any>, onObserve?: (event: any) => void, onEvent?: (event: any) => void, abortSignal?: AbortSignal}} options
+ * @param {{sink?: (event: any) => Promise<any>, onObserve?: (event: any) => void, onLifecycleAdmitted?: (event: any) => void, onEvent?: (event: any) => void, abortSignal?: AbortSignal}} options
  */
-export function createToolLifecycleEventGate({ sink, onObserve, onEvent, abortSignal }: {
+export function createToolLifecycleEventGate({ sink, onObserve, onLifecycleAdmitted, onEvent, abortSignal }: {
     sink?: (event: any) => Promise<any>;
     onObserve?: (event: any) => void;
+    onLifecycleAdmitted?: (event: any) => void;
     onEvent?: (event: any) => void;
     abortSignal?: AbortSignal;
 }): {
@@ -35,7 +36,7 @@ export function historyMetadata(persisted: any, terminalStateValue: string | und
     originalBytes?: number;
     truncated?: any;
     terminalState?: string;
-    persistence: string;
+    persistence: any;
     sequence?: number;
     recordId?: any;
 };