@mono-agent/agent-runtime 0.13.0 → 0.15.0

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;
+    }
   }
 }
 
@@ -1051,12 +1062,6 @@ export async function generateClaudeResponse(systemPrompt, options) {
   };
 }
 
-export const claudeSdkBackend = {
-  kind: "claude",
-  capabilities: runtimeCapabilities("claude"),
-  execute: generateClaudeResponse,
-};
-
 export const claudeRuntimeBridge = {
   id: "claude",
   kind: "claude",

package/src/ai/providers/codex-app.js

@@ -1048,6 +1048,27 @@ function usageFromTokenUsage(tokenUsage) {
   };
 }
 
+function contextUsageFromTokenUsage(tokenUsage) {
+  const last = tokenUsage?.last;
+  const total = Number(last?.totalTokens);
+  if (!last || !Number.isFinite(total) || total <= 0) return null;
+  const input = Number(last.inputTokens) || 0;
+  const cachedInput = Number(last.cachedInputTokens) || 0;
+  const output = Number(last.outputTokens) || 0;
+  const reasoning = Number(last.reasoningOutputTokens) || 0;
+  const contextWindow = Number(tokenUsage?.modelContextWindow) || 0;
+  return {
+    tokens: {
+      input: Math.max(0, input - cachedInput),
+      cachedInput,
+      output,
+      reasoning,
+      total,
+    },
+    ...(contextWindow > 0 ? { contextWindow } : {}),
+  };
+}
+
 const noopNotificationHandler = () => {};
 
 async function closeCodexClient(client) {
@@ -1076,6 +1097,7 @@ const codexLiveness = createSessionLiveness(codexSessions);
 export async function generateCodexAppResponse(systemPrompt, options = {}) {
   const start = Date.now();
   const resolved = options.model;
+  const requestedReference = resolved?.reference || `codex:${resolved?.model || ""}`;
   // Resolve every credential-bearing value before the app-server client is
   // constructed. The same set protects transport errors and provider events,
   // including MCP servers whose custom env/header names are not recognizable
@@ -1105,8 +1127,13 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
   const events = [];
   const texts = [];
   const agentTextByItem = new Map();
+  const compactionStatuses = new Map();
+  const activeCompactions = new Map();
+  const nativeCompactionTurnKeys = new Set();
+  const legacyCompactionTurnKeys = new Set();
   let threadId = null;
   let activeTurnId = null;
+  let actualModel = resolved?.model || null;
   let turnCompleted = false;
   let errorMessage = null;
   let failureKind = null;
@@ -1148,6 +1175,77 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
     options.onEvent?.(safeEvent);
   }
 
+  const compactionTurnKey = (params = {}) => `${params.threadId || threadId || "thread"}:${params.turnId || activeTurnId || "turn"}`;
+
+  /**
+   * @param {{operationId: string, status: string, turnKey?: string, reason?: string, message?: string}} event
+   */
+  function emitCompaction({
+    operationId,
+    status,
+    turnKey,
+    reason,
+    message,
+  }) {
+    const previous = compactionStatuses.get(operationId);
+    if (previous === status || previous === "succeeded" || previous === "failed" || previous === "skipped") return;
+    compactionStatuses.set(operationId, status);
+    if (status === "running") activeCompactions.set(operationId, { turnKey: turnKey || compactionTurnKey() });
+    else activeCompactions.delete(operationId);
+    emitEvent({
+      type: "context_compaction",
+      operationId,
+      status,
+      sdk: "codex",
+      trigger: "automatic",
+      timestamp: Date.now(),
+      model: actualModel ? `codex:${actualModel}` : requestedReference,
+      ...(reason ? { reason } : {}),
+      ...(message ? { message } : {}),
+    });
+  }
+
+  function finalizeOpenCompactions(reason, message) {
+    for (const [operationId, active] of [...activeCompactions]) {
+      emitCompaction({
+        operationId,
+        status: "failed",
+        turnKey: active.turnKey,
+        reason,
+        message,
+      });
+    }
+  }
+
+  function handleContextCompactionItem(method, params) {
+    const item = params.item;
+    const turnKey = compactionTurnKey(params);
+    nativeCompactionTurnKeys.add(turnKey);
+    if (legacyCompactionTurnKeys.has(turnKey)) return;
+    const operationId = `codex:${item.id}`;
+    emitCompaction({
+      operationId,
+      status: method === "item/started" ? "running" : "succeeded",
+      turnKey,
+    });
+  }
+
+  function handleLegacyCompaction(params) {
+    const turnKey = compactionTurnKey(params);
+    const active = [...activeCompactions].find(([, value]) => value.turnKey === turnKey);
+    if (active) {
+      emitCompaction({ operationId: active[0], status: "succeeded", turnKey });
+      return;
+    }
+    if (nativeCompactionTurnKeys.has(turnKey) || legacyCompactionTurnKeys.has(turnKey)) return;
+    legacyCompactionTurnKeys.add(turnKey);
+    emitCompaction({
+      operationId: `codex:${turnKey}:legacy`,
+      status: "succeeded",
+      turnKey,
+    });
+  }
+
   function handleAgentText(text) {
     const safeText = redactCodexDiagnostic(text, sensitiveValues);
     pushUniqueText(texts, safeText);
@@ -1229,6 +1327,13 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
         errorMessage = safeDiagnostic(params.turn?.error?.message || params.turn?.error || "Codex turn failed");
         failureKind = "provider_unavailable";
       }
+      if (activeCompactions.size > 0) {
+        const cancelled = params.turn?.status === "cancelled" || params.turn?.status === "interrupted";
+        finalizeOpenCompactions(
+          cancelled ? "cancelled" : "incomplete",
+          cancelled ? "Compaction was interrupted." : "Compaction ended without a completion event.",
+        );
+      }
       const safeTurn = params.turn?.error === undefined
         ? params.turn
         : { ...params.turn, error: safeResponseError(params.turn.error) };
@@ -1238,6 +1343,27 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
     }
     if (method === "thread/tokenUsage/updated") {
       usage = usageFromTokenUsage(params.tokenUsage);
+      const contextUsage = contextUsageFromTokenUsage(params.tokenUsage);
+      if (contextUsage) {
+        emitEvent({
+          type: "context_usage",
+          sdk: "codex",
+          model: actualModel ? `codex:${actualModel}` : requestedReference,
+          timestamp: Date.now(),
+          ...(typeof params.turnId === "string" && params.turnId.length > 0
+            ? { measurementId: params.turnId }
+            : {}),
+          ...contextUsage,
+        });
+      }
+      return;
+    }
+    if (method === "model/rerouted") {
+      if (typeof params.toModel === "string" && params.toModel.trim().length > 0) actualModel = params.toModel;
+      return;
+    }
+    if (method === "thread/compacted") {
+      handleLegacyCompaction(params);
       return;
     }
     if (method === "item/agentMessage/delta") {
@@ -1258,6 +1384,10 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
       return;
     }
     if (method === "item/started" || method === "item/completed") {
+      if (params.item?.type === "contextCompaction") {
+        handleContextCompactionItem(method, params);
+        return;
+      }
       const raw = mapThreadItem(method, params.item);
       if (params.item?.type === "agentMessage") {
         const text = params.item.text || agentTextByItem.get(params.item.id) || "";
@@ -1363,60 +1493,79 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
 
   async function steerLiveInput() {
     if (!options.liveInput) return;
-    for await (const message of options.liveInput) {
-      if (turnCompleted) break;
-      if (!threadId || !activeTurnId || !turnReadyResolved) {
-        await Promise.race([
-          turnReady,
-          turnDone,
-          client.closed.then((err) => { throw err; }),
+    const iterator = options.liveInput[Symbol.asyncIterator]();
+    try {
+      while (!turnCompleted) {
+        const next = await Promise.race([
+          iterator.next(),
+          turnDone.then(() => ({ done: true, value: undefined })),
         ]);
-        if (turnCompleted || !turnReadyResolved) break;
-      }
-      const input = userTextInput(formatLiveInputGuidance(message.body, options.prompts));
-      try {
-        const response = await client.request("turn/steer", {
-          threadId,
-          expectedTurnId: activeTurnId,
-          input,
-        });
-        activeTurnId = response?.turnId || activeTurnId;
-      } catch (err) {
-        const providerError = err?.responseError;
-        if (isNoActiveTurnToSteer(providerError || err)) {
+        if (next.done || turnCompleted) break;
+        const message = next.value;
+        if (!threadId || !activeTurnId || !turnReadyResolved) {
           await Promise.race([
             turnReady,
             turnDone,
-            client.closed.then((closedErr) => { throw closedErr; }),
+            client.closed.then((err) => { throw err; }),
           ]);
-          if (turnCompleted) break;
-          try {
-            const response = await client.request("turn/steer", {
-              threadId,
-              expectedTurnId: activeTurnId,
-              input,
-            });
-            activeTurnId = response?.turnId || activeTurnId;
-            continue;
-          } catch (retryErr) {
-            const retryProviderError = retryErr?.responseError
-              ? safeResponseError(retryErr.responseError)
-              : null;
-            emitEvent({
-              type: "runtime_warning",
-              warning_kind: isActiveTurnNotSteerable(retryProviderError) ? "active_turn_not_steerable" : "live_input_rejected",
-              message: safeDiagnostic(codexErrorMessage(retryProviderError || retryErr)),
-            });
-            continue;
+          if (turnCompleted || !turnReadyResolved) break;
+        }
+        const input = userTextInput(formatLiveInputGuidance(message.body, options.prompts));
+        try {
+          const response = await client.request("turn/steer", {
+            threadId,
+            expectedTurnId: activeTurnId,
+            input,
+          });
+          activeTurnId = response?.turnId || activeTurnId;
+          message.acknowledge?.();
+        } catch (err) {
+          const providerError = err?.responseError;
+          if (isNoActiveTurnToSteer(providerError || err)) {
+            await Promise.race([
+              turnReady,
+              turnDone,
+              client.closed.then((closedErr) => { throw closedErr; }),
+            ]);
+            if (turnCompleted) break;
+            try {
+              const response = await client.request("turn/steer", {
+                threadId,
+                expectedTurnId: activeTurnId,
+                input,
+              });
+              activeTurnId = response?.turnId || activeTurnId;
+              message.acknowledge?.();
+              continue;
+            } catch (retryErr) {
+              message.reject?.(retryErr);
+              const retryProviderError = retryErr?.responseError
+                ? safeResponseError(retryErr.responseError)
+                : null;
+              emitEvent({
+                type: "runtime_warning",
+                warning_kind: isActiveTurnNotSteerable(retryProviderError) ? "active_turn_not_steerable" : "live_input_rejected",
+                message: safeDiagnostic(codexErrorMessage(retryProviderError || retryErr)),
+              });
+              // Preserve FIFO fallback: once one message is rejected, later
+              // entries must not overtake it inside this provider attempt.
+              break;
+            }
           }
+          message.reject?.(err);
+          emitEvent({
+            type: "runtime_warning",
+            warning_kind: isActiveTurnNotSteerable(providerError) ? "active_turn_not_steerable" : "live_input_rejected",
+            message: safeDiagnostic(codexErrorMessage(
+              providerError ? safeResponseError(providerError) : err,
+            )),
+          });
+          break;
         }
-        emitEvent({
-          type: "runtime_warning",
-          warning_kind: isActiveTurnNotSteerable(providerError) ? "active_turn_not_steerable" : "live_input_rejected",
-          message: safeDiagnostic(codexErrorMessage(
-            providerError ? safeResponseError(providerError) : err,
-          )),
-        });
+      }
+    } finally {
+      if (typeof iterator.return === "function") {
+        try { void Promise.resolve(iterator.return()).catch(() => {}); } catch { /* best-effort */ }
       }
     }
   }
@@ -1656,7 +1805,7 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
       abortRaceCleanup();
     }
     turnCompleted = true;
-    await Promise.race([steerTask, Promise.resolve()]);
+    await steerTask;
 
     const text = texts[texts.length - 1] || "";
     let codexErrorCode = prematureClose ? "codex_app_server_closed" : null;
@@ -1683,7 +1832,7 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
       });
     }
     const hadPartialProgress = events.length > 0 || texts.length > 0;
-    const reference = `codex:${resolved.model}`;
+    const reference = requestedReference;
     const inputTokens = usage?.input_tokens ?? usage?.inputTokens ?? 0;
     const outputTokens = usage?.output_tokens ?? usage?.outputTokens ?? 0;
     const cachedTokens = usage?.cache_read_tokens ?? usage?.cachedInputTokens ?? 0;
@@ -1774,6 +1923,13 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
       }),
     };
   } finally {
+    if (activeCompactions.size > 0) {
+      const cancelled = !!options.abortSignal?.aborted;
+      finalizeOpenCompactions(
+        cancelled ? "cancelled" : "incomplete",
+        cancelled ? "Compaction was interrupted." : "Compaction ended without a completion event.",
+      );
+    }
     options.abortSignal?.removeEventListener?.("abort", abortHandler);
     if (resumeEntry) {
       resumeEntry.busy = false;
@@ -1784,12 +1940,6 @@ export async function generateCodexAppResponse(systemPrompt, options = {}) {
   }
 }
 
-export const codexAppBackend = {
-  kind: "codex-app",
-  capabilities: CODEX_APP_CAPABILITIES,
-  execute: generateCodexAppResponse,
-};
-
 // CLI bridge for sdk='codex' agents that opt into execution_mode='cli'. The
 // codex `app-server` is more capable than `codex exec` (better event
 // streaming, MCP support), so this is the default CLI path for Codex.

package/src/ai/providers/opencode-app.js

@@ -319,6 +319,57 @@ function usageFromInfo(info) {
   };
 }
 
+async function opencodeContextWindows(client, directoryParams) {
+  try {
+    if (typeof client?.provider?.list !== "function") return new Map();
+    const listed = unwrap(await client.provider.list(directoryParams));
+    const providers = Array.isArray(listed?.all) ? listed.all : [];
+    const windows = new Map();
+    for (const provider of providers) {
+      const models = provider?.models && typeof provider.models === "object"
+        ? Object.values(provider.models)
+        : [];
+      for (const model of models) {
+        const providerID = model?.providerID || provider?.id;
+        const modelID = model?.id;
+        const contextWindow = Number(model?.limit?.context) || 0;
+        if (providerID && modelID && contextWindow > 0) {
+          windows.set(`${providerID}:${modelID}`, contextWindow);
+        }
+      }
+    }
+    return windows;
+  } catch {
+    return new Map();
+  }
+}
+
+function contextUsageFromInfo(info, contextWindows, fallbackProviderID, fallbackModelID) {
+  if (info?.role !== "assistant" || info.error) return null;
+  const total = num(info?.tokens?.total);
+  if (total === null || total <= 0) return null;
+  const providerID = info.providerID || fallbackProviderID;
+  const modelID = info.modelID || fallbackModelID;
+  const input = num(info.tokens?.input) || 0;
+  const output = num(info.tokens?.output) || 0;
+  const reasoning = num(info.tokens?.reasoning) || 0;
+  const cachedInput = num(info.tokens?.cache?.read) || 0;
+  const cacheCreation = num(info.tokens?.cache?.write) || 0;
+  const contextWindow = contextWindows.get(`${providerID}:${modelID}`);
+  return {
+    model: `opencode:${providerID}:${modelID}`,
+    tokens: {
+      input: Math.max(0, input - cachedInput),
+      cachedInput,
+      cacheCreation,
+      output,
+      reasoning,
+      total,
+    },
+    ...(contextWindow === undefined ? {} : { contextWindow }),
+  };
+}
+
 function aggregateAssistantInfos(infos) {
   const entries = [...infos];
   const totals = {
@@ -587,11 +638,71 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
   const textDeltaPartIds = new Set();
   const reasoningDeltaPartIds = new Set();
   const assistantInfos = new Map();
-  const recordAssistantInfo = (info, fallbackKey) => {
+  const contextUsageSignatures = new Map();
+  const compactionStatuses = new Map();
+  const activeCompactions = new Map();
+  const seenLegacyCompactionIds = new Set();
+  let nativeCompactionSeen = false;
+  let legacyCompactionMode = false;
+  let contextWindows = new Map();
+
+  /**
+   * @param {{operationId: string, status: string, trigger?: string, timestamp?: number, reason?: string, message?: string}} event
+   */
+  const emitCompaction = ({ operationId, status, trigger = "automatic", timestamp, reason, message }) => {
+    const previous = compactionStatuses.get(operationId);
+    if (previous === status || previous === "succeeded" || previous === "failed" || previous === "skipped") return;
+    compactionStatuses.set(operationId, status);
+    if (status === "running") activeCompactions.set(operationId, { trigger });
+    else activeCompactions.delete(operationId);
+    emit({
+      type: "context_compaction",
+      operationId,
+      status,
+      sdk: "opencode",
+      trigger,
+      timestamp: Number.isFinite(timestamp) ? timestamp : Date.now(),
+      model: reference,
+      ...(reason ? { reason } : {}),
+      ...(message ? { message } : {}),
+    });
+  };
+
+  const finalizeOpenCompactions = (reason, message) => {
+    for (const [operationId, active] of [...activeCompactions]) {
+      emitCompaction({
+        operationId,
+        status: "failed",
+        trigger: active.trigger,
+        reason,
+        message,
+      });
+    }
+  };
+
+  const recordAssistantInfo = (info, fallbackKey, { terminal = false } = {}) => {
     if (info?.role !== "assistant") return;
     const key = typeof info.id === "string" && info.id.length > 0 ? info.id : fallbackKey;
     assistantInfos.set(key, info);
     usage = aggregateAssistantInfos(assistantInfos.values()).usage;
+    const completed = terminal
+      || Number.isFinite(info?.time?.completed)
+      || (typeof info?.finish === "string" && info.finish.length > 0);
+    if (!completed) return;
+    const contextUsage = contextUsageFromInfo(info, contextWindows, providerID, modelID);
+    if (!contextUsage) return;
+    const signature = JSON.stringify([contextUsage.model, contextUsage.contextWindow, contextUsage.tokens]);
+    if (contextUsageSignatures.get(key) === signature) return;
+    contextUsageSignatures.set(key, signature);
+    emit({
+      type: "context_usage",
+      sdk: "opencode",
+      model: contextUsage.model,
+      timestamp: Number.isFinite(info?.time?.completed) ? info.time.completed : Date.now(),
+      measurementId: key,
+      ...(contextUsage.contextWindow === undefined ? {} : { contextWindow: contextUsage.contextWindow }),
+      tokens: contextUsage.tokens,
+    });
   };
 
   const abortHandler = () => {
@@ -618,6 +729,7 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
     client = opencode.client;
     server = opencode.server;
     options.abortSignal?.addEventListener?.("abort", abortHandler, { once: true });
+    contextWindows = await opencodeContextWindows(client, directoryParams);
 
     if (!sessionId) {
       const created = unwrap(await client.session.create(directoryParams));
@@ -758,6 +870,47 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
           recordAssistantInfo(info, "event-anonymous");
           return;
         }
+        case "session.next.compaction.started": {
+          if (props.sessionID && props.sessionID !== sessionId) return;
+          nativeCompactionSeen = true;
+          if (legacyCompactionMode) return;
+          const operationId = `opencode:${sessionId}:${props.messageID || event.id || "compaction"}`;
+          emitCompaction({
+            operationId,
+            status: "running",
+            trigger: props.reason === "manual" ? "manual" : "automatic",
+            timestamp: props.timestamp,
+          });
+          return;
+        }
+        case "session.next.compaction.ended": {
+          if (props.sessionID && props.sessionID !== sessionId) return;
+          nativeCompactionSeen = true;
+          if (legacyCompactionMode) return;
+          const operationId = `opencode:${sessionId}:${props.messageID || event.id || "compaction"}`;
+          emitCompaction({
+            operationId,
+            status: "succeeded",
+            trigger: props.reason === "manual" ? "manual" : "automatic",
+            timestamp: props.timestamp,
+          });
+          return;
+        }
+        case "session.compacted": {
+          if (props.sessionID && props.sessionID !== sessionId) return;
+          if (nativeCompactionSeen) return;
+          legacyCompactionMode = true;
+          const legacyId = typeof event.id === "string" && event.id.length > 0
+            ? event.id
+            : randomUUID();
+          if (seenLegacyCompactionIds.has(legacyId)) return;
+          seenLegacyCompactionIds.add(legacyId);
+          emitCompaction({
+            operationId: `opencode:${sessionId}:legacy:${legacyId}`,
+            status: "succeeded",
+          });
+          return;
+        }
         case "permission.asked":
           await respondToPermission(props);
           return;
@@ -765,10 +918,14 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
           if (props.sessionID && props.sessionID !== sessionId) return;
           errorMessage = safeOpenCodeErrorMessage(props.error, "OpenCode session error.");
           failureKind = mapErrorFailureKind(props.error);
+          finalizeOpenCompactions("provider_error", "Compaction was interrupted by a provider error.");
           pumpDone = true;
           return;
         case "session.idle":
-          if (props.sessionID === sessionId) pumpDone = true;
+          if (props.sessionID === sessionId) {
+            finalizeOpenCompactions("incomplete", "Compaction ended without a completion event.");
+            pumpDone = true;
+          }
           return;
         default:
           return;
@@ -815,7 +972,7 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
     }
 
     const info = promptResult?.info || {};
-    recordAssistantInfo(info, "prompt-final");
+    recordAssistantInfo(info, "prompt-final", { terminal: true });
     if (info.error && !errorMessage) {
       errorMessage = safeOpenCodeErrorMessage(info.error, "OpenCode turn failed.");
       failureKind = mapErrorFailureKind(info.error);
@@ -882,6 +1039,10 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
       }),
     };
   } catch (err) {
+    finalizeOpenCompactions(
+      options.abortSignal?.aborted ? "cancelled" : "provider_error",
+      options.abortSignal?.aborted ? "Compaction was interrupted." : "Compaction was interrupted by a provider error.",
+    );
     const partialAggregate = aggregateAssistantInfos(assistantInfos.values());
     const partialUsage = partialAggregate.usage ?? usage;
     const partialCost = partialAggregate.reportedCost !== null
@@ -929,6 +1090,10 @@ async function generateOpencodeAppResponse(systemPrompt, options = {}) {
       }),
     };
   } finally {
+    finalizeOpenCompactions(
+      options.abortSignal?.aborted ? "cancelled" : "incomplete",
+      options.abortSignal?.aborted ? "Compaction was interrupted." : "Compaction ended without a completion event.",
+    );
     options.abortSignal?.removeEventListener?.("abort", abortHandler);
     try { await server?.close?.(); } catch { /* best effort */ }
   }

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

@@ -1,13 +1,5 @@
 import { EMPTY_USAGE } from "./pi-models.js";
 
-export function promptTextFromMessages(messages) {
-  if (!Array.isArray(messages) || !messages.length) return "";
-  return messages
-    .filter((message) => message?.role === "user")
-    .map((message) => typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? ""))
-    .join("\n");
-}
-
 function messageContent(value) {
   if (typeof value === "string") return value;
   if (Array.isArray(value)) {