@mono-agent/agent-runtime 0.13.0 → 0.15.0

package/src/ai/providers/pi-native/compaction-driver.js

@@ -33,6 +33,7 @@ import {
   prepareCompaction,
   shouldCompact,
 } from "@earendil-works/pi-agent-core";
+import { randomUUID } from "node:crypto";
 import {
   estimateFixedOverheadTokens,
   isLikelyContextTermination,
@@ -204,6 +205,52 @@ function previewCompactedContext(branchEntries, result) {
   return estimateBuiltContextTokens([...branchEntries, previewEntry]);
 }
 
+function canonicalCompactionTrigger(trigger) {
+  return trigger === "reactive_overflow" ? "overflow" : trigger;
+}
+
+function finiteTokenCount(value) {
+  if (value === null || value === undefined) return undefined;
+  const count = Number(value);
+  return Number.isFinite(count) && count >= 0 ? count : undefined;
+}
+
+/**
+ * @param {((event: any) => void)|undefined} onEvent
+ * @param {{operationId: string, status: string, trigger: string, model?: string, tokensBefore?: number|null, tokensAfter?: number|null, reason?: string, message?: string}} event
+ */
+function emitCompactionEvent(onEvent, {
+  operationId,
+  status,
+  trigger,
+  model,
+  tokensBefore,
+  tokensAfter,
+  reason,
+  message,
+}) {
+  const before = finiteTokenCount(tokensBefore);
+  const after = finiteTokenCount(tokensAfter);
+  try {
+    onEvent?.({
+      type: "context_compaction",
+      operationId,
+      status,
+      sdk: "pi",
+      trigger: canonicalCompactionTrigger(trigger),
+      timestamp: Date.now(),
+      ...(model ? { model } : {}),
+      ...(before === undefined ? {} : { tokensBefore: before }),
+      ...(after === undefined ? {} : { tokensAfter: after }),
+      ...(before === undefined && after === undefined ? {} : { tokenCountsExact: false }),
+      ...(reason ? { reason } : {}),
+      ...(message ? { message } : {}),
+    });
+  } catch {
+    // Observability must never change whether compaction itself succeeds.
+  }
+}
+
 // Run a single guarded compaction. Requires the harness idle (callers
 // waitForIdle first). Never throws — classifies AgentHarnessError into a warning
 // and reports back whether anything was compacted. Fires onCompactionRecorded on
@@ -218,14 +265,22 @@ export async function tryCompact(harness, {
   session,
   policy,
 }) {
-  const adaptivePolicy = resolveAgentCompactionPolicy({}, {
-    contextWindow: typeof harness?.getModel === "function" ? harness.getModel()?.contextWindow : undefined,
+  const operationId = randomUUID();
+  emitCompactionEvent(onEvent, {
+    operationId,
+    status: "running",
+    trigger,
+    model,
   });
-  const effectivePolicy = { ...adaptivePolicy, ...(policy || {}) };
+  let effectivePolicy = policy || {};
   /** @type {null | {kind: string, tokensBefore?: number|null, tokensAfter?: number|null, savings?: number|null, error?: any}} */
   let hookDecision = null;
   let removeHook = null;
   try {
+    const adaptivePolicy = resolveAgentCompactionPolicy({}, {
+      contextWindow: typeof harness?.getModel === "function" ? harness.getModel()?.contextWindow : undefined,
+    });
+    effectivePolicy = { ...adaptivePolicy, ...(policy || {}) };
     if (typeof harness?.on !== "function") {
       throw new Error("Pi AgentHarness does not expose session_before_compact hooks");
     }
@@ -298,14 +353,13 @@ export async function tryCompact(harness, {
     const reduced = measuredTokensBefore === null || tokensAfter === null
       ? null
       : tokensAfter < measuredTokensBefore;
-    onEvent?.({
-      type: "runtime_warning",
-      warning_kind: "context_compaction_applied",
-      source: "pi",
+    emitCompactionEvent(onEvent, {
+      operationId,
+      status: "succeeded",
       trigger,
-      tokens_before: tokensBefore,
-      tokens_after: tokensAfter,
-      reduced,
+      model,
+      tokensBefore,
+      tokensAfter,
     });
     if (reduced === false) {
       runtimeWarnings?.push({
@@ -354,6 +408,15 @@ export async function tryCompact(harness, {
           ? { minimum_savings_tokens: effectivePolicy.compactionMinSavingsTokens }
           : {}),
       });
+      emitCompactionEvent(onEvent, {
+        operationId,
+        status: "skipped",
+        trigger,
+        model,
+        tokensBefore: hookDecision.tokensBefore,
+        tokensAfter: hookDecision.tokensAfter,
+        reason: hookDecision.kind,
+      });
       return {
         applied: false,
         tokensBefore: hookDecision.tokensBefore ?? null,
@@ -369,6 +432,13 @@ export async function tryCompact(harness, {
         trigger,
         message: "Nothing to compact",
       });
+      emitCompactionEvent(onEvent, {
+        operationId,
+        status: "skipped",
+        trigger,
+        model,
+        reason: "nothing_to_compact",
+      });
       return { applied: false, tokensBefore: null, tokensAfter: null, reduced: null, nothingToCompact: true };
     }
     const effectiveError = hookDecision?.kind === "failed" && hookDecision.error
@@ -385,6 +455,32 @@ export async function tryCompact(harness, {
           ? "context_compaction_busy"
           : "context_compaction_failed";
     runtimeWarnings?.push({ warning_kind: warningKind, source: "pi", trigger, message });
+    emitCompactionEvent(onEvent, {
+      operationId,
+      status: nothingToCompact ? "skipped" : "failed",
+      trigger,
+      model,
+      reason: nothingToCompact
+        ? "nothing_to_compact"
+        : code === "auth"
+          ? "authentication"
+          : code === "busy"
+            ? "busy"
+            : code === "aborted"
+              ? "cancelled"
+              : "provider_error",
+      ...(nothingToCompact
+        ? {}
+        : {
+          message: code === "auth"
+            ? "Compaction authentication failed."
+            : code === "busy"
+              ? "Context was busy and could not be compacted."
+              : code === "aborted"
+                ? "Compaction was cancelled."
+                : "Compaction failed.",
+        }),
+    });
     return { applied: false, tokensBefore: null, tokensAfter: null, reduced: null, nothingToCompact };
   } finally {
     removeHook?.();

package/src/ai/providers/pi-native/result-builder.js

@@ -33,7 +33,7 @@ export function usageFromMessages(messages = []) {
 }
 
 /**
- * Normalize the final provider request's usage into an exact context snapshot.
+ * Normalize one provider request's usage into an exact context snapshot.
  * Unlike usageFromMessages(), this deliberately does not aggregate earlier
  * requests in the run: the last assistant usage is the same provider-counted
  * value Pi's compaction logic trusts, so it can decrease after compaction.
@@ -74,15 +74,13 @@ export function failureKindForPiError(message, diagnostics, { maxTurnsHit = fals
 
 /**
  * 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}, contextUsage?: {input: number, output: number, cacheRead: number, cacheCreation: number, total: number}|null, contextWindow?: number, estimatedCost: number, start: number, externalAbort: boolean}} params
+ * @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,
-  contextUsage,
-  contextWindow,
   estimatedCost,
   start,
   externalAbort,
@@ -105,16 +103,6 @@ export function emitUsageCostEvents({
       cacheCreationTokens: Number(usage.cacheWrite) || 0,
     },
   });
-  if (contextUsage) {
-    const effectiveContextWindow = Number(contextWindow) || 0;
-    onEvent({
-      type: "context_usage",
-      sdk: resolved.sdk,
-      model: reference,
-      ...(effectiveContextWindow > 0 ? { contextWindow: effectiveContextWindow } : {}),
-      tokens: contextUsage,
-    });
-  }
   onEvent({
     type: "provider_request_completed",
     sdk: resolved.sdk,

package/src/ai/providers/pi-native/stream-subscriber.js

@@ -13,6 +13,7 @@ import {
   jsonSerializable,
   streamContentKey,
 } from "../pi-events.js";
+import { contextUsageFromAssistantMessage } from "./result-builder.js";
 
 function toolResultFileChange(result) {
   const fileChange = result?.details?.file_change;
@@ -41,10 +42,10 @@ function toolResultFileChange(result) {
  * 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
+ * @param {{onEvent: (event: any) => void, options: any, toolLimits: any, harness: any, sdk: string, model: string}} deps
  * @returns {(event: any) => void}
  */
-export function createStreamSubscriber(runState, { onEvent, options, toolLimits, harness }) {
+export function createStreamSubscriber(runState, { onEvent, options, toolLimits, harness, sdk, model }) {
   return (event) => {
     if (event.type === "message_update") {
       const streamEvent = event.assistantMessageEvent;
@@ -69,6 +70,23 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
           onEvent({ type: "assistant", message: { content: [{ type: "thinking", text: streamEvent.content }] } });
         }
       }
+    } else if (event.type === "message_end") {
+      const contextUsage = contextUsageFromAssistantMessage(event.message);
+      if (contextUsage) {
+        const contextWindow = Number(harness?.getModel?.()?.contextWindow) || 0;
+        const measurementId = typeof event.message?.id === "string" && event.message.id.trim().length > 0
+          ? event.message.id
+          : undefined;
+        onEvent({
+          type: "context_usage",
+          sdk,
+          model,
+          timestamp: Date.now(),
+          ...(measurementId === undefined ? {} : { measurementId }),
+          ...(contextWindow > 0 ? { contextWindow } : {}),
+          tokens: contextUsage,
+        });
+      }
     } else if (event.type === "tool_execution_start") {
       if (event.toolName) runState.lastToolName = event.toolName;
       if (event.toolCallId) runState.toolStartTimes.set(event.toolCallId, Date.now());

package/src/ai/providers/pi-native/turn-runner.js

@@ -205,6 +205,8 @@ export function buildTurnHarness(runState, {
   onEvent,
   options,
   toolLimits,
+  sdk,
+  reference,
 }) {
   const harness = new AgentHarness({
     env: new NodeExecutionEnv({ cwd: cwd || process.cwd() }),
@@ -228,7 +230,14 @@ export function buildTurnHarness(runState, {
     : undefined);
   runState.harness = harness;
 
-  harness.subscribe(createStreamSubscriber(runState, { onEvent, options, toolLimits, harness }));
+  harness.subscribe(createStreamSubscriber(runState, {
+    onEvent,
+    options,
+    toolLimits,
+    harness,
+    sdk,
+    model: reference,
+  }));
 
   const abortHandler = () => {
     runState.externalAbort = true;
@@ -255,12 +264,24 @@ export function startLiveInput({ harness, options, onEvent }) {
     ? options.liveInput[Symbol.asyncIterator]()
     : options.liveInput;
   let runComplete = false;
+  /** @type {() => void} */
+  let signalStop = () => {};
+  const stopped = new Promise((resolve) => { signalStop = () => resolve(); });
   const task = (async () => {
     try {
       while (!runComplete && !options.abortSignal?.aborted) {
-        const next = await iterator.next();
+        const next = await Promise.race([
+          iterator.next(),
+          stopped.then(() => ({ done: true, value: undefined })),
+        ]);
         if (next.done || runComplete || options.abortSignal?.aborted) break;
-        await harness.steer(formatLiveInputGuidance(next.value.body, options.prompts));
+        try {
+          await harness.steer(formatLiveInputGuidance(next.value.body, options.prompts));
+          next.value.acknowledge?.();
+        } catch (err) {
+          next.value.reject?.(err);
+          throw err;
+        }
       }
     } catch (err) {
       onEvent({
@@ -273,15 +294,17 @@ export function startLiveInput({ harness, options, onEvent }) {
   return {
     // The run is done: stop the live-steering consumer so it cannot steer a
     // finished harness or swallow a follow-up meant for the next turn. We signal
-    // completion, then best-effort return() the iterator to unblock a pending
-    // next(). We do NOT await the task (it could block on next() if the source
-    // has no return()), but the runComplete guard prevents any further steering.
+    // completion, then best-effort return() the iterator. The explicit stop
+    // race releases the task even when a third-party iterator's return() does
+    // not unblock its pending next(); awaiting the task still closes any steer
+    // acknowledgement already in progress.
     stop: async () => {
       runComplete = true;
+      signalStop();
       if (iterator && typeof iterator.return === "function") {
-        try { await iterator.return(); } catch { /* best-effort */ }
+        try { void Promise.resolve(iterator.return()).catch(() => {}); } catch { /* best-effort */ }
       }
-      void task;
+      await task;
     },
   };
 }

package/src/ai/providers/pi-native.js

@@ -52,7 +52,6 @@ import {
   buildErrorDetails,
   buildErrorResult,
   buildSuccessResult,
-  contextUsageFromAssistantMessage,
   emitCapabilitiesResolved,
   emitUsageCostEvents,
   usageFromMessages,
@@ -453,6 +452,8 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       onEvent,
       options,
       toolLimits,
+      sdk: resolved.sdk,
+      reference,
     });
 
     // Seed prior transcript (everything before the trailing user turn) into the
@@ -614,10 +615,6 @@ export async function generatePiNativeResponse(systemPrompt, options = {}) {
       resolved,
       reference,
       usage,
-      contextUsage: runState.externalAbort || runState.maxTurnsHit || runError
-        ? null
-        : contextUsageFromAssistantMessage(lastAssistant),
-      contextWindow: runState.compaction.policy?.contextWindow,
       estimatedCost,
       start,
       externalAbort: runState.externalAbort,

package/src/ai/runtime/model-refs.js

@@ -123,7 +123,7 @@ export const RESERVED_RUNTIME_KINDS = [...RESERVED_RUNTIME_IDS];
 //   sdk='claude'   → CLI (claude binary) or SDK (Anthropic)
 //   sdk='codex'    → CLI only (codex app-server)
 //   sdk='opencode' → CLI only (opencode server via @opencode-ai/sdk)
-//   sdk='pi'       → SDK only (pi-sdk handles openai-codex and other providers)
+//   sdk='pi'       → SDK only (the pi-native bridge handles openai-codex and other providers)
 
 // Returns null when the combo is fine; otherwise a short reason string the
 // UI / API can show.

package/src/ai/runtime/registry.js

@@ -29,7 +29,14 @@ const builtinBridgeSpecs = {
     id: "claude-code",
     supports: (ref, options) => ref?.sdk === "claude" && options?.executionMode === "cli",
     // The claude CLI resumes prior sessions via `--resume <sessionId>`.
-    capabilities: () => ({ kind: "claude-code", runtime: "cli", ...COMMON_CAPABILITIES, supports_session_resume: true }),
+    capabilities: () => ({
+      kind: "claude-code",
+      runtime: "cli",
+      ...COMMON_CAPABILITIES,
+      supports_session_resume: true,
+      // The one-shot CLI bridge has no bidirectional stdin steering channel.
+      supports_live_input: false,
+    }),
     load: async () => (await import("../providers/claude-cli.js")).claudeCodeRuntimeBridge,
   },
   "codex-app": {

package/src/ai/types.js

@@ -133,7 +133,7 @@
  * @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 {AsyncIterable<{body: string, id?: string, receivedAt?: string, acknowledge?: () => void, reject?: (error?: unknown) => void}>} [liveInput] Stream of in-flight user messages for steering an active run. Providers acknowledge only after accepting a message into the active turn.
  * @property {ReadonlyArray<*>} [observers]               Per-call observers (see RuntimeObserver) merged with host-level (createRuntime) observers.
  * @property {(event: RuntimeEvent) => void} [onEvent]
  * @property {ReadonlyArray<Object>} [messages]

package/src/runtime.js

@@ -8,10 +8,10 @@
 // method that resolves the right provider bridge based on `options.model` +
 // `options.executionMode`.
 //
-// The built-in bridges (claude-sdk, claude-cli, pi-native, codex-app,
-// opencode-app) register themselves on import via the runtime registry. Hosts
-// that need
-// finer control can keep using the named exports (resolveRuntimeBridge,
+// The runtime registry contains a static table for the five built-in bridges
+// (claude-sdk, claude-cli, pi-native, codex-app, opencode-app) and lazily imports
+// the matching implementation only when a run selects it. Hosts that need finer
+// control can keep using the named exports (resolveRuntimeBridge,
 // generateClaudeResponse, etc.) directly.
 //
 // Return shape from `.run()`:

package/types/ai/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./registry.js";
 export * from "./runtime/model-refs.js";
 export * from "./runtime/registry.js";
 export { createSessionRegistry, disposeAllProviderSessions, disposeProviderSession, invalidateProviderSession, refreshProviderSession, syncProviderSession } from "./runtime/sessions.js";

package/types/ai/observer.d.ts

@@ -14,8 +14,9 @@ export function createObserverHub({ observers, onEvent }?: {
     flush: () => Promise<void>;
     observers: () => any[];
 };
-export function createMetricsObserver({ name }?: {
+export function createMetricsObserver({ name, maxLatencySamples }?: {
     name?: string;
+    maxLatencySamples?: number;
 }): {
     name: string;
     recordEvent: (event: any) => void;
@@ -49,7 +50,8 @@ export function createMetricsObserver({ name }?: {
             byKind: any;
         };
         turns: {
-            count: number;
+            count: any;
+            sampleCount: number;
             latencyMsP50: any;
             latencyMsP95: any;
         };

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

@@ -155,9 +155,10 @@ export function generateCliResponse(systemPrompt: any, options?: {}): Promise<{
         context_compaction_applied: any;
     };
 }>;
-export namespace claudeCodeBackend {
-    export let kind: string;
-    export namespace capabilities {
+export namespace claudeCodeRuntimeBridge {
+    let id: string;
+    let kind: string;
+    namespace capabilities {
         export let streaming: boolean;
         export let structured_output: boolean;
         export let supports_session_resume: boolean;
@@ -171,33 +172,8 @@ export namespace claudeCodeBackend {
         export { kind_1 as kind };
         export let runtime: string;
     }
-    export { generateCliResponse as execute };
-}
-export namespace codexCliBackend {
-    let kind_2: string;
-    export { kind_2 as kind };
-    export namespace capabilities_1 {
-        let kind_3: string;
-        export { kind_3 as kind };
-        let runtime_1: string;
-        export { runtime_1 as runtime };
-    }
-    export { capabilities_1 as capabilities };
-    export { generateCliResponse as execute };
-}
-export namespace claudeCodeRuntimeBridge {
-    export let id: string;
-    let kind_4: string;
-    export { kind_4 as kind };
-    export namespace capabilities_2 {
-        let kind_5: string;
-        export { kind_5 as kind };
-        let runtime_2: string;
-        export { runtime_2 as runtime };
-    }
-    export { capabilities_2 as capabilities };
-    export function supports(ref: any, options: any): boolean;
-    export function execute(systemPrompt: any, options: any): Promise<{
+    function supports(ref: any, options: any): boolean;
+    function execute(systemPrompt: any, options: any): Promise<{
         text: any;
         structuredResult: any;
         structuredResultSource: any;

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

@@ -129,17 +129,10 @@ export function generateClaudeResponse(systemPrompt: any, options: any): Promise
         context_compaction_applied: any;
     };
 }>;
-export namespace claudeSdkBackend {
-    export let kind: string;
-    export let capabilities: any;
-    export { generateClaudeResponse as execute };
-}
 export namespace claudeRuntimeBridge {
     export let id: string;
-    let kind_1: string;
-    export { kind_1 as kind };
-    let capabilities_1: any;
-    export { capabilities_1 as capabilities };
+    export let kind: string;
+    export let capabilities: any;
     export function supports(ref: any): boolean;
     export { generateClaudeResponse as execute };
 }

package/types/ai/providers/codex-app.d.ts

@@ -62,7 +62,7 @@ export function generateCodexAppResponse(systemPrompt: any, options?: {}): Promi
     };
     durationMs: number;
     numTurns: number;
-    model: string;
+    model: any;
     effort: any;
     sdk: string;
     providerSessionId: any;
@@ -124,22 +124,16 @@ export function generateCodexAppResponse(systemPrompt: any, options?: {}): Promi
         context_compaction_applied: any;
     };
 }>;
-export namespace codexAppBackend {
-    export let kind: string;
-    export { CODEX_APP_CAPABILITIES as capabilities };
-    export { generateCodexAppResponse as execute };
-}
 export namespace codexAppRuntimeBridge {
     export let id: string;
-    let kind_1: string;
-    export { kind_1 as kind };
+    export let kind: string;
     export { CODEX_APP_CAPABILITIES as capabilities };
     export function supports(ref: any, options: any): boolean;
     export { generateCodexAppResponse as execute };
 }
 declare namespace CODEX_APP_CAPABILITIES {
-    let kind_2: string;
-    export { kind_2 as kind };
+    let kind_1: string;
+    export { kind_1 as kind };
     export let runtime: string;
     export let streaming: boolean;
     export let structured_output: boolean;

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

@@ -1,4 +1,3 @@
-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;

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

@@ -11,7 +11,7 @@ export function usageFromMessages(messages?: Array<any>): {
     cost: number;
 };
 /**
- * Normalize the final provider request's usage into an exact context snapshot.
+ * Normalize one provider request's usage into an exact context snapshot.
  * Unlike usageFromMessages(), this deliberately does not aggregate earlier
  * requests in the run: the last assistant usage is the same provider-counted
  * value Pi's compaction logic trusts, so it can decrease after compaction.
@@ -40,9 +40,9 @@ export function failureKindForPiError(message: string | null, diagnostics: Recor
 }): 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}, contextUsage?: {input: number, output: number, cacheRead: number, cacheCreation: number, total: number}|null, contextWindow?: number, estimatedCost: number, start: number, externalAbort: boolean}} params
+ * @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, contextUsage, contextWindow, estimatedCost, start, externalAbort, }: {
+export function emitUsageCostEvents({ onEvent, resolved, reference, usage, estimatedCost, start, externalAbort, }: {
     onEvent: (event: any) => void;
     resolved: any;
     reference: string;
@@ -53,14 +53,6 @@ export function emitUsageCostEvents({ onEvent, resolved, reference, usage, conte
         cacheWrite: number;
         cost: number;
     };
-    contextUsage?: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheCreation: number;
-        total: number;
-    } | null;
-    contextWindow?: number;
     estimatedCost: number;
     start: number;
     externalAbort: boolean;

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

@@ -17,14 +17,16 @@
  * 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
+ * @param {{onEvent: (event: any) => void, options: any, toolLimits: any, harness: any, sdk: string, model: string}} deps
  * @returns {(event: any) => void}
  */
-export function createStreamSubscriber(runState: StreamSubscriberState, { onEvent, options, toolLimits, harness }: {
+export function createStreamSubscriber(runState: StreamSubscriberState, { onEvent, options, toolLimits, harness, sdk, model }: {
     onEvent: (event: any) => void;
     options: any;
     toolLimits: any;
     harness: any;
+    sdk: string;
+    model: string;
 }): (event: any) => void;
 /**
  * The slice of run state the stream subscriber reads and mutates. A structural

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

@@ -32,7 +32,7 @@ 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, }: any): 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;
 /**
  * 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

package/types/ai/types.d.ts

@@ -104,7 +104,7 @@
  * @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 {AsyncIterable<{body: string, id?: string, receivedAt?: string, acknowledge?: () => void, reject?: (error?: unknown) => void}>} [liveInput] Stream of in-flight user messages for steering an active run. Providers acknowledge only after accepting a message into the active turn.
  * @property {ReadonlyArray<*>} [observers]               Per-call observers (see RuntimeObserver) merged with host-level (createRuntime) observers.
  * @property {(event: RuntimeEvent) => void} [onEvent]
  * @property {ReadonlyArray<Object>} [messages]
@@ -490,9 +490,15 @@ export type RuntimeRunOptions = {
      */
     sessionIdleTimeoutMs?: number;
     /**
-     * Whether this run expects a live/streaming input channel.
+     * Stream of in-flight user messages for steering an active run. Providers acknowledge only after accepting a message into the active turn.
      */
-    liveInput?: boolean;
+    liveInput?: AsyncIterable<{
+        body: string;
+        id?: string;
+        receivedAt?: string;
+        acknowledge?: () => void;
+        reject?: (error?: unknown) => void;
+    }>;
     /**
      * Per-call observers (see RuntimeObserver) merged with host-level (createRuntime) observers.
      */