@mono-agent/agent-runtime 0.14.0 → 0.15.1

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/live-input-events.js

@@ -0,0 +1,94 @@
+// Metadata-only live-input acknowledgement instrumentation.
+//
+// Provider bridges already call message.acknowledge() only after their native
+// steering boundary accepts guidance. Wrapping that callback here creates one
+// adapter-neutral `live_input_applied` event without copying the guidance body
+// into runtime telemetry. A wrapper owns one logical-run dedupe set and is
+// intentionally reused by the fallback router across provider attempts.
+
+// @ts-check
+
+const LIVE_INPUT_APPLIED_INSTRUMENTED = Symbol("mono-agent.live-input-applied-instrumented");
+
+/**
+ * @typedef {{body: string, id?: string, receivedAt?: string, acknowledge?: () => void, reject?: (reason?: unknown) => void}} RuntimeLiveInputMessage
+ * @typedef {{type: "live_input_applied", inputId: string, receivedAt?: string}} LiveInputAppliedEvent
+ */
+
+/**
+ * @param {AsyncIterable<RuntimeLiveInputMessage>|undefined} liveInput
+ * @param {(event: LiveInputAppliedEvent) => void} onApplied
+ * @returns {AsyncIterable<RuntimeLiveInputMessage>|undefined}
+ */
+export function instrumentLiveInputAppliedEvents(liveInput, onApplied) {
+  if (liveInput === undefined || isInstrumented(liveInput)) return liveInput;
+
+  const appliedInputIds = new Set();
+  const instrumented = {
+    [LIVE_INPUT_APPLIED_INSTRUMENTED]: true,
+    [Symbol.asyncIterator]() {
+      const iterator = liveInput[Symbol.asyncIterator]();
+      let ordinal = 0;
+      return {
+        async next() {
+          const next = await iterator.next();
+          if (next.done === true) return next;
+          ordinal += 1;
+          const message = next.value;
+          const inputId = stableInputId(message?.id, ordinal);
+          const receivedAt = typeof message?.receivedAt === "string" && message.receivedAt.length > 0
+            ? message.receivedAt
+            : undefined;
+          const acknowledge = typeof message?.acknowledge === "function"
+            ? message.acknowledge.bind(message)
+            : undefined;
+          return {
+            done: false,
+            value: {
+              ...message,
+              acknowledge: () => {
+                acknowledge?.();
+                if (appliedInputIds.has(inputId)) return;
+                appliedInputIds.add(inputId);
+                try {
+                  onApplied({
+                    type: "live_input_applied",
+                    inputId,
+                    ...(receivedAt === undefined ? {} : { receivedAt }),
+                  });
+                } catch {
+                  // Telemetry must never turn accepted guidance into a provider
+                  // failure after the native steering call already succeeded.
+                }
+              },
+            },
+          };
+        },
+        async return(value) {
+          return typeof iterator.return === "function"
+            ? iterator.return(value)
+            : { done: true, value };
+        },
+        async throw(error) {
+          if (typeof iterator.throw === "function") return iterator.throw(error);
+          throw error;
+        },
+      };
+    },
+  };
+  return /** @type {AsyncIterable<RuntimeLiveInputMessage>} */ (instrumented);
+}
+
+/** @param {unknown} value */
+function isInstrumented(value) {
+  return typeof value === "object"
+    && value !== null
+    && value[LIVE_INPUT_APPLIED_INSTRUMENTED] === true;
+}
+
+/** @param {unknown} value @param {number} ordinal */
+function stableInputId(value, ordinal) {
+  return typeof value === "string" && value.trim().length > 0
+    ? value
+    : `anonymous:${ordinal}`;
+}

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/runtime/router.js

@@ -41,6 +41,8 @@ import { runtimeCapabilities } from "./capabilities.js";
 import { buildTranscriptTailSnapshot, renderResumeSnapshot } from "../../agent/transcript.js";
 import { passthroughSandbox } from "../../agent/sandbox-seam.js";
 import { resolveRuntimeBrand } from "../../runtime-brand.js";
+import { createObserverHub } from "../observer.js";
+import { instrumentLiveInputAppliedEvents } from "./live-input-events.js";
 
 /**
  * @typedef {import('../types.js').RuntimeModelRef} RuntimeModelRef
@@ -127,6 +129,22 @@ export function createRouterRuntime({ host = {}, chain = [], routeSafety = "unif
      * @returns {Promise<RuntimeResult>}
      */
     async run(systemPrompt, options = {}) {
+      const liveInputHub = options.liveInput === undefined
+        ? undefined
+        : createObserverHub({
+            observers: [
+              ...(Array.isArray(host.observers) ? host.observers : []),
+              ...(Array.isArray(options.observers) ? options.observers : []),
+            ],
+            onEvent: options.onEvent,
+          });
+      if (options.liveInput !== undefined && liveInputHub !== undefined) {
+        options = {
+          ...options,
+          liveInput: instrumentLiveInputAppliedEvents(options.liveInput, liveInputHub.emit),
+        };
+      }
+      try {
       /** @type {Array<{model: RuntimeModelRef, failureKind: (string|null), requestId?: (string|null|undefined), retryableSubkind?: (string|null|undefined), requirements?: (Object<string,*>|null), routeSafety?: import('../types.js').RuntimeRouteSafetyMode, safetyContract?: import('../types.js').RuntimeRouteSafetyContract}>} */
       const failoverHistory = [];
       /** @type {RuntimeResult|null} */
@@ -374,6 +392,9 @@ export function createRouterRuntime({ host = {}, chain = [], routeSafety = "unif
         failoverHistory,
         routeSafetyHistory,
       };
+      } finally {
+        await liveInputHub?.flush();
+      }
     },
     chain: () => entries.slice(),
     configureTools(next = {}) {

package/src/ai/types.js

@@ -131,9 +131,10 @@
  * @property {string} [executionMode]                     "sdk" (default) or "cli"; selects which bridge variant handles the model.
  * @property {string} [sessionId]                         Host conversation/session key for resumable bridges.
  * @property {string} [providerSessionId]                 Provider-owned resume id for resumable bridges.
+ * @property {typeof import("@anthropic-ai/claude-agent-sdk").query} [claudeAgentQuery] Advanced programmatic/test seam for the Claude SDK route; omitted runs use the runtime's pinned SDK query implementation.
  * @property {boolean} [sessionKeepAlive]                 Keep resumable provider state alive after the turn.
  * @property {number} [sessionIdleTimeoutMs]              Idle TTL for resumable provider state.
- * @property {AsyncIterable<{body: string, id?: string}>} [liveInput] Stream of in-flight user messages for steering an active run.
+ * @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

@@ -40,6 +40,7 @@ import {
 import { createToolContext, updateToolContext } from "./agent/tools/shared/tool-context.js";
 import { resolveRuntimeBrand } from "./runtime-brand.js";
 import { retireDurableNativeSession } from "./ai/providers/pi-native/session-lifecycle.js";
+import { instrumentLiveInputAppliedEvents } from "./ai/runtime/live-input-events.js";
 
 /**
  * @typedef {import('./ai/types.js').AgentRuntimeHostOptions} AgentRuntimeHostOptions
@@ -159,6 +160,7 @@ export function createRuntime(host = {}) {
         observers: [...hostObservers, ...callObservers],
         onEvent: options.onEvent,
       });
+      const liveInput = instrumentLiveInputAppliedEvents(options.liveInput, hub.emit);
       const prompts = resolvePrompts(host.prompts, options.prompts);
       const result = await bridge.execute(systemPrompt, {
         ...hostDefaults,
@@ -172,6 +174,7 @@ export function createRuntime(host = {}) {
         toolContext,
         observerHub: hub,
         onEvent: hub.emit,
+        ...(liveInput === undefined ? {} : { liveInput }),
         // Merged AFTER the spreads so the per-field run>host>default precedence
         // wins over either bag's whole-object `prompts`.
         ...(prompts === undefined ? {} : { prompts }),

package/types/agent/compaction.d.ts

@@ -84,8 +84,6 @@ export type AgentCompactionPolicy = {
     summaryMaxTokens: number;
     fixedOverheadEnabled: boolean;
     compactionMinSavingsTokens: number;
-    toolPayloadCompactionTriggerChars: number;
-    toolPruneTriggerTokens: number;
     toolTextLimitChars: number;
     bashOutputLimitChars: number;
     mcpTextLimitChars: number;

package/types/agent/prompt/skill-index.d.ts

@@ -8,6 +8,9 @@ export function buildSkillPathNote({ assetsPath, skillsRoot }?: {
     skillsRoot?: any;
 }): string;
 /**
+ * Render a complete skill body plus its path note. Omitting `maxChars` returns
+ * the full text; pass a positive `maxChars` only when explicit truncation is
+ * required by the caller.
  * @param {{body?: string, assetsPath?: string, skillsRoot?: any, maxChars?: number}} [options]
  */
 export function formatSkillBodyWithPathNote({ body, assetsPath, skillsRoot, maxChars }?: {

package/types/ai/index.d.ts

@@ -1,8 +1,8 @@
-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";
 export { createMetricsObserver, createObserverHub } from "./observer.js";
 export { generatePiNativeResponse, piNativeRuntimeBridge } from "./providers/pi-native.js";
+export { getPiBuiltinModel, listPiBuiltinModels, loginPiOAuth, reasoningLevelsForPiModel, resolvePiOAuthApiKey } from "./pi-interop.js";
 export { CLAUDE_SDK_CATALOG_VERSION, createClaudeSdkDiscoveryIsolation, curatedClaudeSdkModels, discoverClaudeSdkModels, normalizeClaudeSdkCatalog, normalizeClaudeSdkModelId } from "./providers/claude-sdk-discovery.js";
 export { buildCapabilitiesUsed, toolCompactionAppliedFromWarnings, UNKNOWN_CAPABILITY } from "./runtime/capabilities-used.js";

package/types/ai/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;
         };