@mono-agent/agent-runtime 0.14.0 → 0.15.1

package/src/ai/index.js

@@ -1,6 +1,5 @@
 // Public surface of the provider layer.
 
-export * from "./registry.js";
 export * from "./runtime/model-refs.js";
 export * from "./runtime/registry.js";
 export {
@@ -13,6 +12,13 @@ export {
 } 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,

package/src/ai/observer.js

@@ -82,10 +82,11 @@ function addObserver(list, observer) {
 //   cache: { hits, misses, hitRatio },          // hitRatio in [0,1]; null if no signal
 //   tools: { callsByName: { ... }, errorsByName: { ... } },
 //   errors: { total, byKind: { ... } },
-//   turns: { count, latencyMsP50, latencyMsP95 },
+//   turns: { count, sampleCount, latencyMsP50, latencyMsP95 },
 //   approvals: { pending, granted, denied },
 // }
-export function createMetricsObserver({ name = "metrics" } = {}) {
+export function createMetricsObserver({ name = "metrics", maxLatencySamples = 2_048 } = {}) {
+  const latencySampleLimit = normalizePositiveInteger(maxLatencySamples, 2_048);
   const state = {
     eventsTotal: 0,
     eventsByType: new Map(),
@@ -99,7 +100,8 @@ export function createMetricsObserver({ name = "metrics" } = {}) {
     errorTotal: 0,
     errorsByKind: new Map(),
     turnLatencies: [],
-    turnStartByModel: new Map(),
+    turnLatencyCount: 0,
+    pendingTurnStarts: [],
     approvalPending: 0,
     approvalGranted: 0,
     approvalDenied: 0,
@@ -167,17 +169,24 @@ export function createMetricsObserver({ name = "metrics" } = {}) {
     }
 
     if (type === "provider_request_started" && event.model) {
-      state.turnStartByModel.set(event.model, (Number.isFinite(event.timestamp) ? event.timestamp : Date.now()));
+      state.pendingTurnStarts.push({
+        key: latencyEventKey(event),
+        model: String(event.model),
+        timestamp: Number.isFinite(event.timestamp) ? event.timestamp : Date.now(),
+      });
+      if (state.pendingTurnStarts.length > latencySampleLimit) state.pendingTurnStarts.shift();
     }
     if (type === "provider_request_completed" && event.model) {
-      const started = state.turnStartByModel.get(event.model);
-      if (started !== undefined) {
-        state.turnLatencies.push(Math.max(0, ((Number.isFinite(event.timestamp) ? event.timestamp : Date.now())) - started));
-        state.turnStartByModel.delete(event.model);
+      const startIndex = matchingStartIndex(state.pendingTurnStarts, event);
+      const started = startIndex === -1 ? undefined : state.pendingTurnStarts.splice(startIndex, 1)[0];
+      const explicitDuration = Number(event.durationMs);
+      if (Number.isFinite(explicitDuration)) recordTurnLatency(Math.max(0, explicitDuration));
+      else if (started !== undefined) {
+        recordTurnLatency(Math.max(0, ((Number.isFinite(event.timestamp) ? event.timestamp : Date.now())) - started.timestamp));
       }
     }
     if (type === "turn_latency" && Number.isFinite(Number(event.durationMs))) {
-      state.turnLatencies.push(Number(event.durationMs));
+      recordTurnLatency(Math.max(0, Number(event.durationMs)));
     }
 
     if (type === "tool_approval_pending") state.approvalPending += 1;
@@ -187,6 +196,12 @@ export function createMetricsObserver({ name = "metrics" } = {}) {
 
   function recordMetric() { /* future hook */ }
 
+  function recordTurnLatency(durationMs) {
+    state.turnLatencyCount += 1;
+    state.turnLatencies.push(durationMs);
+    if (state.turnLatencies.length > latencySampleLimit) state.turnLatencies.shift();
+  }
+
   function snapshot() {
     const cacheTotal = state.cacheHits + state.cacheMisses;
     const hitRatio = cacheTotal > 0 ? state.cacheHits / cacheTotal : null;
@@ -205,7 +220,7 @@ export function createMetricsObserver({ name = "metrics" } = {}) {
         errorsByName: Object.fromEntries(state.toolErrorsByName),
       },
       errors: { total: state.errorTotal, byKind: Object.fromEntries(state.errorsByKind) },
-      turns: percentilesFor(state.turnLatencies),
+      turns: percentilesFor(state.turnLatencies, state.turnLatencyCount),
       approvals: { pending: state.approvalPending, granted: state.approvalGranted, denied: state.approvalDenied },
     };
   }
@@ -213,16 +228,36 @@ export function createMetricsObserver({ name = "metrics" } = {}) {
   return { name, recordEvent, recordMetric, snapshot };
 }
 
-function percentilesFor(samples) {
+function percentilesFor(samples, count = samples.length) {
   const arr = Array.isArray(samples) ? samples.filter((n) => Number.isFinite(n)).slice().sort((a, b) => a - b) : [];
-  if (!arr.length) return { count: 0, latencyMsP50: null, latencyMsP95: null };
+  if (!arr.length) return { count, sampleCount: 0, latencyMsP50: null, latencyMsP95: null };
   return {
-    count: arr.length,
+    count,
+    sampleCount: arr.length,
     latencyMsP50: percentile(arr, 0.5),
     latencyMsP95: percentile(arr, 0.95),
   };
 }
 
+function latencyEventKey(event) {
+  const requestId = event.requestId ?? event.turnId;
+  return requestId === undefined || requestId === null ? undefined : String(requestId);
+}
+
+function matchingStartIndex(starts, event) {
+  const key = latencyEventKey(event);
+  if (key !== undefined) {
+    const keyedIndex = starts.findIndex((start) => start.key === key);
+    if (keyedIndex !== -1) return keyedIndex;
+  }
+  return starts.findIndex((start) => start.model === String(event.model));
+}
+
+function normalizePositiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isSafeInteger(number) && number > 0 ? number : fallback;
+}
+
 function percentile(sortedArr, q) {
   if (!sortedArr.length) return null;
   const rank = q * (sortedArr.length - 1);

package/src/ai/pi-interop.js

@@ -0,0 +1,156 @@
+// Runtime-owned interoperability facade for Pi's built-in model and OAuth
+// surfaces. Consumers should use these functions instead of importing pi-ai
+// directly so the runtime's known-good Pi version remains authoritative.
+
+import { getBuiltinModel, getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+import { getOAuthApiKey, getOAuthProvider } from "@earendil-works/pi-ai/oauth";
+import { reasoningLevelsForPiModel as resolveReasoningLevels } from "./providers/pi-models.js";
+
+/**
+ * @typedef {{
+ *   id: string,
+ *   name: string,
+ *   api: string,
+ *   provider: string,
+ *   baseUrl: string,
+ *   reasoning: boolean,
+ *   input: Array<"text"|"image">,
+ *   cost: {
+ *     input: number,
+ *     output: number,
+ *     cacheRead: number,
+ *     cacheWrite: number,
+ *     tiers?: Array<{
+ *       inputTokensAbove: number,
+ *       input: number,
+ *       output: number,
+ *       cacheRead: number,
+ *       cacheWrite: number
+ *     }>
+ *   },
+ *   contextWindow: number,
+ *   maxTokens: number,
+ *   thinkingLevelMap?: Object<string, string|null>,
+ *   compat?: Object<string, *>,
+ *   headers?: Object<string, string>,
+ *   [key: string]: *
+ * }} PiBuiltinModelSnapshot
+ */
+
+/**
+ * @typedef {"none"|"minimal"|"low"|"medium"|"high"|"xhigh"|"max"} PiReasoningLevel
+ */
+
+/**
+ * @typedef {{
+ *   refresh: string,
+ *   access: string,
+ *   expires: number,
+ *   [key: string]: *
+ * }} PiOAuthCredentialsSnapshot
+ */
+
+/**
+ * @typedef {Object} PiOAuthLoginCallbacks
+ * @property {(info: {url: string, instructions?: string}) => void} onAuth
+ * @property {(info: {userCode: string, verificationUri: string, intervalSeconds?: number, expiresInSeconds?: number}) => void} onDeviceCode
+ * @property {(prompt: {message: string, placeholder?: string, allowEmpty?: boolean}) => Promise<string>} onPrompt
+ * @property {(message: string) => void} [onProgress]
+ * @property {() => Promise<string>} [onManualCodeInput]
+ * @property {(prompt: {message: string, options: Array<{id: string, label: string}>}) => Promise<string|undefined>} onSelect
+ * @property {AbortSignal} [signal]
+ */
+
+/**
+ * Clone provider-owned data before it crosses the public runtime boundary.
+ * Pi's built-in models and OAuth credentials are structured data on the
+ * supported version, and the package requires a Node release with
+ * `structuredClone`.
+ *
+ * @template T
+ * @param {T} value
+ * @returns {T}
+ */
+function cloneInteropValue(value) {
+  return structuredClone(value);
+}
+
+/**
+ * List defensive snapshots of Pi's built-in models for one provider.
+ *
+ * @param {string} providerId
+ * @returns {PiBuiltinModelSnapshot[]}
+ */
+export function listPiBuiltinModels(providerId) {
+  const models = getBuiltinModels(/** @type {any} */ (providerId));
+  return /** @type {PiBuiltinModelSnapshot[]} */ (cloneInteropValue(models));
+}
+
+/**
+ * Read a defensive snapshot of one Pi built-in model.
+ *
+ * @param {string} providerId
+ * @param {string} modelId
+ * @returns {PiBuiltinModelSnapshot|undefined}
+ */
+export function getPiBuiltinModel(providerId, modelId) {
+  const model = getBuiltinModel(
+    /** @type {any} */ (providerId),
+    /** @type {any} */ (modelId),
+  );
+  return model === undefined
+    ? undefined
+    : /** @type {PiBuiltinModelSnapshot} */ (cloneInteropValue(model));
+}
+
+/**
+ * Translate Pi's model-native thinking levels to mono-agent effort spelling.
+ *
+ * @param {PiBuiltinModelSnapshot} model
+ * @returns {PiReasoningLevel[]}
+ */
+export function reasoningLevelsForPiModel(model) {
+  return /** @type {PiReasoningLevel[]} */ (resolveReasoningLevels(model));
+}
+
+/**
+ * Resolve an OAuth-backed API key without allowing Pi to mutate the caller's
+ * credential record or returning Pi-owned credential objects.
+ *
+ * @param {string} providerId
+ * @param {Object<string, PiOAuthCredentialsSnapshot>} credentials
+ * @returns {Promise<{apiKey: string, newCredentials: PiOAuthCredentialsSnapshot}|null>}
+ */
+export async function resolvePiOAuthApiKey(providerId, credentials) {
+  const result = await getOAuthApiKey(
+    providerId,
+    /** @type {any} */ (cloneInteropValue(credentials)),
+  );
+  if (!result) return null;
+  return {
+    apiKey: result.apiKey,
+    newCredentials: cloneInteropValue(result.newCredentials),
+  };
+}
+
+/**
+ * Run a supported Pi OAuth login flow without exposing Pi's mutable provider
+ * registry or provider instances.
+ *
+ * @param {string} providerId
+ * @param {PiOAuthLoginCallbacks} callbacks
+ * @returns {Promise<PiOAuthCredentialsSnapshot>}
+ */
+export async function loginPiOAuth(providerId, callbacks) {
+  const provider = getOAuthProvider(providerId);
+  if (!provider || typeof provider.login !== "function") {
+    throw new Error(`Pi OAuth provider is unavailable: ${providerId}`);
+  }
+  for (const callbackName of ["onAuth", "onDeviceCode", "onPrompt", "onSelect"]) {
+    if (typeof callbacks?.[callbackName] !== "function") {
+      throw new TypeError(`loginPiOAuth requires callbacks.${callbackName}()`);
+    }
+  }
+  const credentials = await provider.login(/** @type {any} */ ({ ...callbacks }));
+  return cloneInteropValue(credentials);
+}

package/src/ai/providers/claude-cli.js

@@ -83,7 +83,8 @@ const DORMANT_CLI_CAPABILITIES = {
   supports_mcp: true,
   supports_skills: true,
   supports_builtin_tools: true,
-  supports_live_input: true,
+  // The one-shot CLI bridge cannot add stdin messages after process launch.
+  supports_live_input: false,
   supports_native_subagents: true,
 };
 
@@ -776,18 +777,6 @@ export async function generateCliResponse(systemPrompt, options = {}) {
   }
 }
 
-export const claudeCodeBackend = {
-  kind: "claude-code",
-  capabilities: { kind: "claude-code", runtime: "cli", ...DORMANT_CLI_CAPABILITIES },
-  execute: generateCliResponse,
-};
-
-export const codexCliBackend = {
-  kind: "codex-cli",
-  capabilities: { kind: "codex-cli", runtime: "cli", ...DORMANT_CLI_CAPABILITIES },
-  execute: generateCliResponse,
-};
-
 // CLI bridge for sdk='claude' agents that opt into execution_mode='cli'.
 // generateCliResponse internally branches on resolved.sdk; the SDK shape
 // from parseModelReference uses 'claude', the CLI builder expects

package/src/ai/providers/claude-sdk.js

@@ -563,7 +563,18 @@ function createClaudeCanUseTool(approvalManager, modelName) {
 async function* livePromptMessages({ initialPrompt, liveInput, sessionId, prompts }) {
   yield makeSdkUserMessage(initialPrompt, sessionId);
   for await (const message of liveInput) {
-    yield makeSdkUserMessage(formatLiveInputGuidance(message.body, prompts), sessionId, message.id || randomUUID());
+    try {
+      const sdkMessage = makeSdkUserMessage(
+        formatLiveInputGuidance(message.body, prompts),
+        sessionId,
+        message.id || randomUUID(),
+      );
+      message.acknowledge?.();
+      yield sdkMessage;
+    } catch (err) {
+      message.reject?.(err);
+      throw err;
+    }
   }
 }
 
@@ -737,6 +748,7 @@ export async function generateClaudeResponse(systemPrompt, options) {
   const prompt = options.liveInput
     ? livePromptMessages({ initialPrompt: promptString, liveInput: options.liveInput, sessionId: reusableProviderSessionId || randomUUID(), prompts: options.prompts })
     : promptString;
+  const claudeAgentQuery = options.claudeAgentQuery ?? query;
   const providerRequestStartedAt = Date.now();
   emitEvent({
     type: "provider_request_started",
@@ -794,7 +806,7 @@ export async function generateClaudeResponse(systemPrompt, options) {
   }
 
   try {
-    stream = query({ prompt: /** @type {any} */ (prompt), options: queryOptions });
+    stream = claudeAgentQuery({ prompt: /** @type {any} */ (prompt), options: queryOptions });
     for await (const event of stream) {
       const nextSessionId = sessionIdFromEvent(event);
       if (nextSessionId) providerSessionId = nextSessionId;
@@ -1051,12 +1063,6 @@ export async function generateClaudeResponse(systemPrompt, options) {
   };
 }
 
-export const claudeSdkBackend = {
-  kind: "claude",
-  capabilities: runtimeCapabilities("claude"),
-  execute: generateClaudeResponse,
-};
-
 export const claudeRuntimeBridge = {
   id: "claude",
   kind: "claude",