@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/providers/opencode-adapter.ts

@@ -9,13 +9,28 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import {
+  baseUrlOverride,
+  ignoredBaseUrlVar,
+  type OpenAICompatibleProvider,
+  openAICompatibleKeyVars,
+  openAICompatibleProvider,
+  openAICompatibleProviders,
+  providerBaseUrl,
+  providerForKeyVar,
+  providerKeyVars,
+} from "@desplega/model-catalog";
 import type { OpenCode, OpenCodeEvent } from "@opencode/sdk";
 import {
   CONTEXT_FORMULA,
   clampContextPercent,
   getContextWindowSize,
 } from "../utils/context-window";
-import { validateOpencodeCredentials } from "../utils/credentials";
+import {
+  openAICompatibleKeyLabels,
+  splitCredentialPool,
+  validateOpencodeCredentials,
+} from "../utils/credentials";
 import { isEnvFlagEnabled } from "../utils/env-flag";
 import { fetchInstalledMcpServers } from "../utils/mcp-server-fetcher";
 import { swarmRuntimeInstanceId } from "../utils/multi-runtime";
@@ -24,9 +39,10 @@ import {
   getOpenRouterAttributionHeaders,
   getOpenRouterBaseUrl,
 } from "../utils/openrouter-base-url";
-import { scrubSecrets } from "../utils/secret-scrubber";
+import { registerVolatileSecret, scrubSecrets } from "../utils/secret-scrubber";
 import { resolveSlashSkillPrompt } from "./codex-skill-resolver";
 import { CTX_MODE_NUDGE_EVERY } from "./ctx-mode-env";
+import { OpenRouterBilling } from "./opencode-billing";
 import { createOpencodeSwarmPlugin, type OpencodeToolLister } from "./opencode-swarm-plugin";
 import {
   apiHeaders,
@@ -60,8 +76,12 @@ export type OpencodeConfig = {
   provider?: Record<
     string,
     {
+      /** Env var names OpenCode reads the key from; `[]` stops it reading `process.env`. */
+      env?: string[];
+      npm?: string;
+      name?: string;
       options?: Record<string, unknown>;
-      models?: Record<string, { options?: Record<string, unknown> }>;
+      models?: Record<string, { options?: Record<string, unknown>; [key: string]: unknown }>;
     }
   >;
   [key: string]: unknown;
@@ -79,18 +99,41 @@ function opencodeModelToCredKey(modelStr: string | undefined): string | null {
     if (provider === "anthropic") return "ANTHROPIC_API_KEY";
     if (provider === "openrouter") return "OPENROUTER_API_KEY";
     if (provider === "openai") return "OPENAI_API_KEY";
+    // OpenAI-compatible registry providers (`nan`, `helmcode`).
+    const direct = openAICompatibleProvider(provider);
+    if (direct) return direct.envVar;
   }
   return null;
 }
 
+/**
+ * Env var names that satisfy `requiredKey`. The runner copies a registry
+ * key alias (`HELMCODE_API_NAN`) into its canonical var per task, but a
+ * check that reads `process.env` directly sees only the alias.
+ */
+function credKeyNames(requiredKey: string): readonly string[] {
+  const direct = providerForKeyVar(requiredKey);
+  return direct ? providerKeyVars(direct) : [requiredKey];
+}
+
+/** Keys that satisfy opencode when no model pins a provider. */
+const OPENCODE_ANY_KEY_VARS = [
+  "OPENROUTER_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  ...openAICompatibleKeyVars(),
+];
+
 /**
  * Opencode is satisfied by ANY of:
  *   1. `~/.local/share/opencode/auth.json` exists (the file `opencode auth login`
  *      writes; OpenCode 2 imports it into its credential store on start).
  *   2. `MODEL_OVERRIDE` resolves to a provider-prefixed model — only that
- *      provider's key is required.
+ *      provider's key is required (a registry provider also accepts its key
+ *      aliases: `nan/*` takes `HELMCODE_API_NAN`).
  *   3. Otherwise any one of OPENROUTER_API_KEY / ANTHROPIC_API_KEY /
- *      OPENAI_API_KEY suffices.
+ *      OPENAI_API_KEY / a registry provider key (canonical or alias)
+ *      suffices.
  */
 export function checkOpencodeCredentials(
   env: Record<string, string | undefined>,
@@ -105,7 +148,7 @@ export function checkOpencodeCredentials(
 
   const requiredKey = opencodeModelToCredKey(env.MODEL_OVERRIDE);
   if (requiredKey) {
-    if (env[requiredKey]) {
+    if (credKeyNames(requiredKey).some((name) => env[name])) {
       return { ready: true, missing: [], satisfiedBy: "env" };
     }
     return {
@@ -115,13 +158,26 @@ export function checkOpencodeCredentials(
     };
   }
 
-  if (env.OPENROUTER_API_KEY || env.ANTHROPIC_API_KEY || env.OPENAI_API_KEY) {
+  if (OPENCODE_ANY_KEY_VARS.some((name) => env[name])) {
     return { ready: true, missing: [], satisfiedBy: "env" };
   }
   return {
     ready: false,
-    missing: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY", authFile],
-    hint: "Set one of OPENROUTER_API_KEY / ANTHROPIC_API_KEY / OPENAI_API_KEY (any one suffices), or run `opencode auth login` to create ~/.local/share/opencode/auth.json.",
+    missing: [
+      "OPENROUTER_API_KEY",
+      "ANTHROPIC_API_KEY",
+      "OPENAI_API_KEY",
+      ...openAICompatibleProviders().map((p) => p.envVar),
+      authFile,
+    ],
+    hint: `Set one of ${[
+      "OPENROUTER_API_KEY",
+      "ANTHROPIC_API_KEY",
+      "OPENAI_API_KEY",
+      ...openAICompatibleKeyLabels(),
+    ].join(
+      " / ",
+    )} (any one suffices), or run \`opencode auth login\` to create ~/.local/share/opencode/auth.json.`,
   };
 }
 
@@ -216,9 +272,156 @@ export function applyOpenRouterBaseUrlOverride(
   };
 }
 
+/**
+ * OpenCode provider block for an OpenAI-compatible registry provider that
+ * OpenCode does not ship (`catalog: "registry"`, e.g. `helmcode`). `apiKey` is
+ * a literal key (embedded host) or an `{env:NAME}` reference (ACP
+ * subprocess). `baseUrl` is the `<ID>_BASE_URL` override or the registry
+ * default. `env: []` keeps OpenCode from reading a key out of `process.env`.
+ * A `modelId` missing from the registry (accepted through `allowCustomModel`)
+ * gets a bare entry so OpenCode still resolves it instead of falling back to
+ * its default model.
+ */
+export function buildOpenAICompatibleProviderBlock(
+  provider: OpenAICompatibleProvider,
+  apiKey: string,
+  modelId?: string,
+  baseUrl: string = provider.baseUrl,
+): NonNullable<OpencodeConfig["provider"]>[string] {
+  const models: Record<string, Record<string, unknown>> = {};
+  for (const m of provider.models) {
+    models[m.id] = {
+      name: m.name,
+      tool_call: true,
+      reasoning: m.reasoning,
+      limit: { context: m.contextWindow, output: m.maxOutputTokens },
+    };
+  }
+  if (modelId && !models[modelId]) models[modelId] = { name: modelId, tool_call: true };
+  return {
+    npm: provider.npm,
+    name: provider.displayName,
+    env: [],
+    options: { baseURL: baseUrl, apiKey },
+    models,
+  };
+}
+
+/**
+ * Built-in OpenCode providers whose key OpenCode reads from `process.env`:
+ * `openrouter` plus every registry provider models.dev lists
+ * (`catalog: "models.dev"`, e.g. `nan`), which OpenCode ships built in.
+ */
+function envBoundKeyVars(providerId: string): readonly string[] | undefined {
+  if (providerId === "openrouter") return ["OPENROUTER_API_KEY"];
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "models.dev" ? providerKeyVars(direct) : undefined;
+}
+
+/** Registry providers OpenCode does not ship (`catalog: "registry"`); they get a full custom block. */
+function customBlockProvider(providerId: string): OpenAICompatibleProvider | undefined {
+  const direct = openAICompatibleProvider(providerId);
+  return direct?.catalog === "registry" ? direct : undefined;
+}
+
+/**
+ * One key from the first non-empty var in `names`. The runner's per-task env
+ * already holds one picked pool member; a value that still carries a comma
+ * pool (no runner, or `process.env`) yields its first member.
+ */
+function pickProviderKey(
+  env: Record<string, string | undefined>,
+  names: readonly string[],
+): { key: string; name: string } | undefined {
+  for (const name of names) {
+    const value = env[name]?.trim();
+    if (!value) continue;
+    const key = splitCredentialPool(value)[0];
+    if (key) return { key, name };
+  }
+  return undefined;
+}
+
+/**
+ * Hand the embedded host exactly one key for the active model's provider.
+ *
+ * Embedded OpenCode reads a built-in provider's key from the shared
+ * `process.env`, and that value beats `options.apiKey`. The entrypoint exports
+ * a credential pool there as a raw comma list, and a key saved from the
+ * dashboard after boot never reaches `process.env` at all, so both 401 without
+ * this splice. For `openrouter` and the built-in registry providers (`nan`,
+ * `vercel`) it sets `env: []` plus `options.apiKey` (and `options.baseURL`
+ * when `<ID>_BASE_URL` is set; a `baseUrlLocked` provider gets none); for registry providers OpenCode does not ship
+ * (`helmcode`) it writes the full custom provider block at
+ * `<ID>_BASE_URL` or the registry default. No splice when the key is absent
+ * (credStatus reports that).
+ *
+ * The key lives only in the in-memory config string handed to the SDK.
+ * Mutates `opencodeConfig` in place and returns the env var the key came from,
+ * or `undefined` when nothing was spliced.
+ */
+export function applyProviderKeySplice(
+  opencodeConfig: OpencodeConfig,
+  model: string | undefined,
+  env: Record<string, string | undefined>,
+): { key: string; name: string } | undefined {
+  const slash = model?.indexOf("/") ?? -1;
+  if (!model || slash <= 0) return undefined;
+  const providerId = model.slice(0, slash);
+  const existing = opencodeConfig.provider?.[providerId];
+
+  const custom = customBlockProvider(providerId);
+  if (custom) {
+    const picked = pickProviderKey(env, providerKeyVars(custom));
+    if (!picked) return undefined;
+    const block = buildOpenAICompatibleProviderBlock(
+      custom,
+      picked.key,
+      model.slice(slash + 1),
+      providerBaseUrl(custom, env),
+    );
+    opencodeConfig.provider = {
+      ...opencodeConfig.provider,
+      [providerId]: {
+        ...existing,
+        ...block,
+        options: { ...existing?.options, ...block.options },
+        models: { ...existing?.models, ...block.models },
+      },
+    };
+    return picked;
+  }
+
+  const names = envBoundKeyVars(providerId);
+  if (!names) return undefined;
+  const picked = pickProviderKey(env, names);
+  if (!picked) return undefined;
+  const direct = openAICompatibleProvider(providerId);
+  const baseURL = direct ? baseUrlOverride(direct, env) : undefined;
+  const options = { ...existing?.options, ...(baseURL ? { baseURL } : {}), apiKey: picked.key };
+  if (direct?.baseUrlLocked) {
+    // OpenCode's built-in SDK (AI Gateway) knows its endpoint; any URL here is wrong.
+    const ignored = ignoredBaseUrlVar(direct, env);
+    if (ignored || options.baseURL !== undefined) {
+      console.warn(
+        `[opencode] ${ignored ?? `provider.${providerId}.options.baseURL`} is ignored: ${direct.displayName} uses its built-in endpoint`,
+      );
+    }
+    delete options.baseURL;
+  }
+  opencodeConfig.provider = {
+    ...opencodeConfig.provider,
+    [providerId]: { ...existing, env: [], options },
+  };
+  return picked;
+}
+
 const SWARM_AGENT_NAME = "swarm";
 const TRANSCRIPT_TAIL_CHARS = 20_000;
 const TOOL_RESULT_PREVIEW_CHARS = 500;
+// The last response body finishes streaming with the step; this only covers
+// a read still in flight when the session ends.
+const BILLING_SETTLE_MS = 2_000;
 
 /** The swarm MCP server's name in the OpenCode config. */
 const SWARM_MCP_SERVER = "swarm";
@@ -339,6 +542,7 @@ export class OpencodeSession implements ProviderSession {
     private readonly swarm: SwarmHooksConfig,
     private readonly cwd: string,
     private readonly appliedReasoningEffort: ReasoningEffort | null = null,
+    private readonly billing?: OpenRouterBilling,
   ) {
     this.completionPromise = new Promise<ProviderResult>((resolve) => {
       this.completionResolve = resolve;
@@ -494,12 +698,13 @@ export class OpencodeSession implements ProviderSession {
         this.usage = { cost: ev.data.cost, tokens: ev.data.tokens };
         break;
 
-      case "session.execution.succeeded": {
-        const cost = this.buildCostData(false);
-        this.emit({ type: "result", cost, isError: false });
-        void this.finish({ exitCode: 0, sessionId: this._sessionId, cost, isError: false });
+      case "session.execution.succeeded":
+        void this.finish(async () => {
+          const cost = await this.buildCostData(false);
+          this.emit({ type: "result", cost, isError: false });
+          return { exitCode: 0, sessionId: this._sessionId, cost, isError: false };
+        });
         break;
-      }
 
       case "session.execution.failed":
         this.fail(errorMessage(ev.data.error, "opencode session error"));
@@ -541,27 +746,34 @@ export class OpencodeSession implements ProviderSession {
   }
 
   /** Settle the session as failed; also used when the event stream dies. */
-  fail(message: string): void {
+  fail(rawMessage: string): void {
     if (this.aborted || this.completed) return;
+    // SDK and provider errors can echo request details; the message reaches
+    // the runner's logs and the task's failure reason.
+    const message = scrubSecrets(rawMessage);
     this.emit({ type: "error", message });
-    void this.finish({
+    void this.finish(async () => ({
       exitCode: 1,
       sessionId: this._sessionId,
-      cost: this.buildCostData(true),
+      cost: await this.buildCostData(true),
       isError: true,
       failureReason: message,
-    });
+    }));
   }
 
-  private buildCostData(isError: boolean): CostData {
+  private async buildCostData(isError: boolean): Promise<CostData> {
     const { cost, tokens } = this.usage;
+    const billed = await this.billing?.settle(BILLING_SETTLE_MS);
     return {
       sessionId: this._sessionId,
       taskId: this.swarm.taskId,
       agentId: this.swarm.agentId,
-      totalCostUsd: cost,
+      ...(billed?.complete
+        ? { totalCostUsd: billed.costUsd, harnessCostBilled: true }
+        : { totalCostUsd: cost }),
       inputTokens: tokens.input,
-      outputTokens: tokens.output,
+      // OpenCode 2's `output` excludes reasoning; both bill at the output rate.
+      outputTokens: tokens.output + tokens.reasoning,
       reasoningOutputTokens: tokens.reasoning,
       cacheReadTokens: tokens.cache.read,
       cacheWriteTokens: tokens.cache.write,
@@ -596,10 +808,11 @@ export class OpencodeSession implements ProviderSession {
    * Settle the session. Session-end work is bounded and cancellable, so the
    * host always closes and completion always resolves.
    */
-  private async finish(result: ProviderResult): Promise<void> {
+  private async finish(settle: ProviderResult | (() => Promise<ProviderResult>)): Promise<void> {
     if (this.completed) return;
     this.completed = true;
     const { signal } = this.sessionEnd;
+    const result = typeof settle === "function" ? await settle() : settle;
     try {
       if (!this.aborted) {
         await settleWithin(this.runSessionEnd(signal), sessionHooks.budgetMs, signal);
@@ -722,6 +935,12 @@ export class OpencodeAdapter implements ProviderAdapter {
       },
     };
 
+    // One picked key for the model's provider (D3). It stays in this
+    // in-memory config; registering it lets every scrubbed egress redact it
+    // even when it never reached `process.env` (a key saved after boot).
+    const splicedKey = applyProviderKeySplice(opencodeConfig, config.model, env);
+    if (splicedKey) registerVolatileSecret(splicedKey.key, splicedKey.name);
+
     // Splice the provider-keyed reasoning options into
     // `provider[providerId].models[modelId].options`. `off` (and any
     // capability-rejected level) resolves to `noop`.
@@ -762,20 +981,31 @@ export class OpencodeAdapter implements ProviderAdapter {
     };
     const { sdk, version: opencodeVersion } = await loadOpencodeSdkImpl();
     let listTools: OpencodeToolLister | undefined;
-    const host = await sdk.OpenCode.create({
-      config: { content: JSON.stringify(opencodeConfig) },
-      plugins: [
-        createOpencodeSwarmPlugin(swarm, {
-          onToolRegistry: (lister) => {
-            listTools = lister;
-          },
-        }),
-      ],
-      log: {
-        level: "warn",
-        emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`)),
-      },
-    });
+    const billing = config.model.startsWith("openrouter/") ? new OpenRouterBilling() : undefined;
+    // The config string carries the spliced provider key and the swarm MCP
+    // bearer. It goes to the SDK only; nothing logs, writes, or uploads it,
+    // and errors raised while the SDK parses it are scrubbed before they
+    // propagate to the runner.
+    let host: OpenCode.Interface;
+    try {
+      host = await sdk.OpenCode.create({
+        config: { content: JSON.stringify(opencodeConfig) },
+        plugins: [
+          createOpencodeSwarmPlugin(swarm, {
+            onToolRegistry: (lister) => {
+              listTools = lister;
+            },
+            ...(billing ? { onOpenRouterResponse: (response) => billing.observe(response) } : {}),
+          }),
+        ],
+        log: {
+          level: "warn",
+          emit: (entry) => console.warn(scrubSecrets(`[opencode] ${entry.message}`)),
+        },
+      });
+    } catch (err) {
+      throw new Error(scrubSecrets(`opencode host failed to start: ${errorMessage(err, "")}`));
+    }
 
     let sessionId: string;
     try {
@@ -786,7 +1016,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       sessionId = created.id;
     } catch (err) {
       await host.close().catch(() => {});
-      throw err;
+      throw new Error(scrubSecrets(`opencode session create failed: ${errorMessage(err, "")}`));
     }
 
     const session = new OpencodeSession(
@@ -796,6 +1026,7 @@ export class OpencodeAdapter implements ProviderAdapter {
       swarm,
       config.cwd,
       appliedReasoningEffort,
+      billing,
     );
     session.emitSessionInit(opencodeVersion ? { version: opencodeVersion } : undefined);
 

package/src/providers/opencode-billing.ts

@@ -0,0 +1,86 @@
+/**
+ * OpenRouter's billed cost for an OpenCode 2 session.
+ *
+ * OpenCode prices tokens from its model catalog, and the swarm pricing table
+ * holds OpenRouter's model-level list price. Both are the cheapest endpoint's
+ * rate, while OpenRouter bills the endpoint that served the request, which
+ * can cost 100x more. OpenCode asks OpenRouter for `usage: { include: true }`,
+ * so every response carries `usage.cost`, the USD OpenRouter charged. The
+ * swarm plugin hands each OpenRouter response here, and the session reports
+ * the sum as billed when every response carried one.
+ */
+
+/** The billed USD in an OpenRouter chat response (SSE or JSON), or null. */
+export function parseOpenRouterBilledCost(body: string): number | null {
+  const payloads = body.trimStart().startsWith("{")
+    ? [body]
+    : body
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trim());
+  let cost: number | null = null;
+  for (const payload of payloads) {
+    if (!payload.includes('"cost"')) continue;
+    let usage: { cost?: unknown; is_byok?: unknown } | undefined;
+    try {
+      usage = (JSON.parse(payload) as { usage?: typeof usage }).usage;
+    } catch {
+      continue;
+    }
+    // A BYOK `cost` is OpenRouter's fee only; the upstream bills the rest.
+    if (usage?.is_byok === true) return null;
+    if (typeof usage?.cost === "number" && Number.isFinite(usage.cost)) cost = usage.cost;
+  }
+  return cost;
+}
+
+export interface BilledCost {
+  costUsd: number;
+  /** True when every observed response reported what OpenRouter charged. */
+  complete: boolean;
+}
+
+export class OpenRouterBilling {
+  private requests = 0;
+  private billed = 0;
+  private costUsd = 0;
+  private pending = new Set<Promise<void>>();
+
+  /** Reads a copy of `response`; the caller keeps streaming the original. */
+  observe(response: Response): void {
+    this.requests++;
+    // OpenRouter does not charge for a rejected request.
+    if (!response.ok) {
+      this.billed++;
+      return;
+    }
+    const read = response
+      .clone()
+      .text()
+      .then((body) => {
+        const cost = parseOpenRouterBilledCost(body);
+        if (cost === null) return;
+        this.billed++;
+        this.costUsd += cost;
+      })
+      .catch(() => {})
+      .finally(() => this.pending.delete(read));
+    this.pending.add(read);
+  }
+
+  /** Waits up to `timeoutMs` for in-flight responses, then reports. */
+  async settle(timeoutMs: number): Promise<BilledCost | null> {
+    if (this.pending.size > 0) {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      await Promise.race([
+        Promise.all(this.pending),
+        new Promise<void>((resolve) => {
+          timer = setTimeout(resolve, timeoutMs);
+        }),
+      ]);
+      clearTimeout(timer);
+    }
+    if (this.requests === 0) return null;
+    return { costUsd: this.costUsd, complete: this.billed === this.requests };
+  }
+}

package/src/providers/opencode-swarm-plugin.ts

@@ -28,6 +28,29 @@ export type OpencodeToolLister = () => Promise<ReadonlyArray<{ readonly id: stri
 export interface OpencodeSwarmPluginOptions {
   /** Receives the tool lister once OpenCode sets the plugin up. */
   onToolRegistry?: (listTools: OpencodeToolLister) => void;
+  /** Receives every OpenRouter model response, for the billed cost. */
+  onOpenRouterResponse?: (response: Response) => void;
+}
+
+/** Keys OpenCode sets on each shell call, on top of its base env. */
+const OPENCODE_SHELL_ENV_KEYS = ["TERM", "OPENCODE_TERMINAL"] as const;
+
+/**
+ * Rewrites one OpenCode shell call's env, in place, to the session's own env
+ * plus the keys OpenCode set for the call. Nothing else from the process env
+ * gets through.
+ */
+function applyOpencodeShellEnv(
+  callEnv: Record<string, string | undefined>,
+  sessionEnv: Record<string, string | undefined>,
+): void {
+  const keep = new Set<string>(OPENCODE_SHELL_ENV_KEYS);
+  for (const key of Object.keys(callEnv)) {
+    if (!keep.has(key)) delete callEnv[key];
+  }
+  for (const [key, value] of Object.entries(sessionEnv)) {
+    if (value !== undefined && !keep.has(key)) callEnv[key] = value;
+  }
 }
 
 export function createOpencodeSwarmPlugin(
@@ -39,6 +62,16 @@ export function createOpencodeSwarmPlugin(
     async setup(ctx) {
       options.onToolRegistry?.(() => ctx.tool.list());
 
+      // OpenCode runs in-process, so its shell tool spawns with process.env,
+      // which every concurrent session shares and which never sees this
+      // task's env (rows admitted or withheld by fetchResolvedEnv after boot).
+      const sessionEnv = config.env;
+      if (sessionEnv) {
+        await ctx.shell.hook("create.before", (event) => {
+          applyOpencodeShellEnv(event.env, sessionEnv);
+        });
+      }
+
       // A throw blocks the tool; OpenCode hands the message back to the model.
       await ctx.tool.hook("execute.before", async (event) => {
         if (!config.isLead && config.taskId) {
@@ -75,6 +108,24 @@ export function createOpencodeSwarmPlugin(
         if (concurrent) event.system.push({ type: "text", text: concurrent });
       });
 
+      // Nobody reads a headless session's title. Generating one is a second
+      // model call, on OpenCode's small model, that the session usage folds
+      // into the main model's tokens.
+      await ctx.session.hook("title", (event) => {
+        event.result = config.taskId ? `swarm task ${config.taskId}` : "swarm session";
+      });
+
+      const onOpenRouterResponse = options.onOpenRouterResponse;
+      if (onOpenRouterResponse) {
+        await ctx.session.hook(
+          "http.response",
+          (event) => {
+            onOpenRouterResponse(event.response);
+          },
+          { providerID: "openrouter" },
+        );
+      }
+
       // PreCompact parity: keep the task goal in the checkpoint summary.
       await ctx.session.hook("compaction", async (event) => {
         if (!config.taskId) return;