@desplega.ai/agent-swarm 1.79.4 → 1.80.0

package/src/tests/http/context-routes.test.ts

@@ -0,0 +1,161 @@
+// Phase 10: HTTP context-route ingestion semantics.
+//
+// Asserts:
+//   * `agent_tasks.peakContextTokens` is monotonic-max (a dip on a later
+//     snapshot doesn't reduce the stored value).
+//   * `agent_tasks.contextWindowSize` is set on the FIRST snapshot that
+//     carries one, not gated on `eventType='completion'`.
+//   * `cumulativeInputTokens` round-trips through the route into the
+//     persisted snapshot row.
+//   * `contextFormula` round-trips into the snapshot.
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getContextSnapshotsByTaskId,
+  getContextSummaryByTaskId,
+  initDb,
+} from "../../be/db";
+import { handleContext } from "../../http/context";
+import { handleCore } from "../../http/core";
+import { getPathSegments, parseQueryParams } from "../../http/utils";
+
+const TEST_DB_PATH = "./test-context-routes.sqlite";
+const API_KEY = "test-context-routes";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+async function listen(server: Server): Promise<number> {
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return addr.port;
+}
+
+function createTestServer(apiKey: string): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleCore(req, res, myAgentId, apiKey);
+    if (handled) return;
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const ok = await handleContext(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+let server: Server;
+let port: number;
+let testAgent: { id: string };
+let testTask: { id: string };
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  testAgent = createAgent({ name: "context-route-test", isLead: false, status: "idle" });
+  testTask = createTaskExtended("phase-10 ingestion", { agentId: testAgent.id, source: "mcp" });
+  server = createTestServer(API_KEY);
+  port = await listen(server);
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+function postSnapshot(body: Record<string, unknown>): Promise<Response> {
+  return fetch(`http://localhost:${port}/api/tasks/${testTask.id}/context`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "X-Agent-ID": testAgent.id,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+describe("Phase 10 — POST /api/tasks/:id/context", () => {
+  test("peakContextTokens is a monotonic max across snapshots", async () => {
+    const r1 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 50_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 25,
+    });
+    expect(r1.status).toBe(200);
+
+    const r2 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 120_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 60,
+    });
+    expect(r2.status).toBe(200);
+
+    // Dip — the unified formula occasionally undercounts on the next turn
+    // (e.g. when the SDK reuses cache more aggressively). The aggregate
+    // column must NOT regress to the dipped value.
+    const r3 = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-1",
+      contextUsedTokens: 80_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 40,
+    });
+    expect(r3.status).toBe(200);
+
+    const summary = getContextSummaryByTaskId(testTask.id);
+    expect(summary.peakContextTokens).toBe(120_000);
+  });
+
+  test("contextWindowSize is set on the first snapshot, not on completion", () => {
+    // The first POST in the previous test already set this; assert it stuck
+    // and a later POST with a different total doesn't overwrite it.
+    const summary = getContextSummaryByTaskId(testTask.id);
+    expect(summary.contextWindowSize).toBe(200_000);
+  });
+
+  test("cumulativeInputTokens + contextFormula round-trip into the row", async () => {
+    const res = await postSnapshot({
+      eventType: "progress",
+      sessionId: "sess-2",
+      contextUsedTokens: 30_000,
+      contextTotalTokens: 200_000,
+      contextPercent: 15,
+      cumulativeInputTokens: 1234,
+      cumulativeOutputTokens: 567,
+      contextFormula: "input-cache-output",
+    });
+    expect(res.status).toBe(200);
+
+    const snapshots = getContextSnapshotsByTaskId(testTask.id);
+    const last = snapshots[snapshots.length - 1];
+    expect(last.cumulativeInputTokens).toBe(1234);
+    expect(last.cumulativeOutputTokens).toBe(567);
+    expect(last.contextFormula).toBe("input-cache-output");
+  });
+});

package/src/tests/migration-063-schema-relax.test.ts

@@ -0,0 +1,109 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, initDb } from "../be/db";
+
+const TEST_DB_PATH = "./test-migration-063.sqlite";
+
+describe("Migration 063 — cost & context schema relax", () => {
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // doesn't exist
+      }
+    }
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  test("pricing CHECKs are dropped — accepts every provider in the new Zod enum", () => {
+    const stmt = getDb().prepare(
+      `INSERT INTO pricing (provider, model, token_class, effective_from, price_per_million_usd, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, 0, 1.0, 0, 0)`,
+    );
+
+    for (const provider of [
+      "claude",
+      "claude-managed",
+      "codex",
+      "pi",
+      "opencode",
+      "devin",
+      "gemini",
+    ]) {
+      expect(() => stmt.run(provider, "test-model", "input")).not.toThrow();
+    }
+
+    for (const tokenClass of [
+      "input",
+      "cached_input",
+      "output",
+      "cache_write",
+      "runtime_hour",
+      "acu",
+    ]) {
+      expect(() => stmt.run("claude-managed", "mm", tokenClass)).not.toThrow();
+    }
+  });
+
+  test("agent_tasks.totalContextTokensUsed renamed to peakContextTokens", () => {
+    const cols = getDb()
+      .prepare<{ name: string }, []>("PRAGMA table_info(agent_tasks)")
+      .all() as Array<{ name: string }>;
+    const names = new Set(cols.map((c) => c.name));
+    expect(names.has("peakContextTokens")).toBe(true);
+    expect(names.has("totalContextTokensUsed")).toBe(false);
+  });
+
+  test("task_context_snapshots has contextFormula column", () => {
+    const cols = getDb()
+      .prepare<{ name: string }, []>("PRAGMA table_info(task_context_snapshots)")
+      .all() as Array<{ name: string }>;
+    expect(cols.some((c) => c.name === "contextFormula")).toBe(true);
+  });
+
+  test("session_costs has reasoningOutputTokens + thinkingTokens", () => {
+    const cols = getDb()
+      .prepare<{ name: string; dflt_value: string | null }, []>("PRAGMA table_info(session_costs)")
+      .all() as Array<{ name: string; dflt_value: string | null }>;
+    const byName = new Map(cols.map((c) => [c.name, c]));
+    expect(byName.has("reasoningOutputTokens")).toBe(true);
+    expect(byName.has("thinkingTokens")).toBe(true);
+    expect(byName.get("reasoningOutputTokens")?.dflt_value).toBe("0");
+    expect(byName.get("thinkingTokens")?.dflt_value).toBe("0");
+  });
+
+  test("session_costs.costSource CHECK is dropped — accepts 'unpriced'", () => {
+    // Insert a row using the relaxed costSource. We use a raw INSERT (no FKs)
+    // so we don't have to seed agents/tasks. Disable FK enforcement for the
+    // test since we don't care about referential integrity here.
+    getDb().exec("PRAGMA foreign_keys = OFF");
+    const stmt = getDb().prepare(
+      `INSERT INTO session_costs
+        (id, sessionId, taskId, agentId, totalCostUsd, durationMs, numTurns, model, costSource, createdAt)
+       VALUES (?, ?, NULL, ?, 0, 0, NULL, 'm', ?, '2026-05-15T00:00:00.000Z')`,
+    );
+    expect(() => stmt.run(crypto.randomUUID(), "s", "a", "unpriced")).not.toThrow();
+    getDb().exec("PRAGMA foreign_keys = ON");
+  });
+
+  test("session_costs.numTurns and cacheWriteTokens are nullable", () => {
+    const cols = getDb()
+      .prepare<{ name: string; notnull: number }, []>("PRAGMA table_info(session_costs)")
+      .all() as Array<{ name: string; notnull: number }>;
+    const byName = new Map(cols.map((c) => [c.name, c]));
+    expect(byName.get("numTurns")?.notnull).toBe(0);
+    expect(byName.get("cacheWriteTokens")?.notnull).toBe(0);
+  });
+});

package/src/tests/opencode-adapter.test.ts

@@ -225,7 +225,9 @@ describe("OpencodeSession — cost aggregation", () => {
             reasoning: 0,
             cache: { read: i * 2, write: i },
           },
-          time: { created: Date.now() },
+          // Phase 9 fix: accumulator gates on `time.completed` so simulated steps
+          // must look like finalized opencode messages.
+          time: { created: Date.now(), completed: Date.now() + 1 },
           parentID: "",
           modelID: "claude-opus",
           providerID: "anthropic",
@@ -317,6 +319,149 @@ describe("OpencodeSession — raw_log persistence", () => {
   });
 });
 
+// ── Phase 9: context_usage emission ───────────────────────────────────────────
+
+describe("OpencodeSession — context_usage emission (phase 9 fix)", () => {
+  beforeEach(() => {
+    mock.restore();
+  });
+
+  /** Build a `message.updated` event with optional finalize flag. */
+  function makeMessageUpdated(
+    overrides: {
+      sessionID?: string;
+      completed?: boolean;
+      input?: number;
+      output?: number;
+      cacheRead?: number;
+      cacheWrite?: number;
+      cost?: number;
+      modelID?: string;
+    } = {},
+  ): OpencodeEvent {
+    const now = Date.now();
+    return {
+      type: "message.updated",
+      properties: {
+        info: {
+          id: `msg-${now}`,
+          sessionID: overrides.sessionID ?? "sess-abc-123",
+          role: "assistant",
+          cost: overrides.cost ?? 0.001,
+          tokens: {
+            input: overrides.input ?? 0,
+            output: overrides.output ?? 0,
+            reasoning: 0,
+            cache: {
+              read: overrides.cacheRead ?? 0,
+              write: overrides.cacheWrite ?? 0,
+            },
+          },
+          time: overrides.completed ? { created: now, completed: now + 1 } : { created: now },
+          parentID: "",
+          modelID: overrides.modelID ?? "claude-sonnet-4-5",
+          providerID: "anthropic",
+          mode: "live",
+          path: { cwd: "/", root: "/" },
+        } as never,
+      },
+    };
+  }
+
+  test("finalized message with real tokens → emits context_usage matching the cost row", async () => {
+    // Mirrors the E2E evidence: opencode reports `in=12, cache.read=99970,
+    // cache.write=104606, out=288` on the FINAL message.updated for the turn.
+    const events: OpencodeEvent[] = [
+      makeMessageUpdated({
+        completed: true,
+        input: 12,
+        output: 288,
+        cacheRead: 99970,
+        cacheWrite: 104606,
+      }),
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+
+    const { emitted, result } = await driveSession(events);
+
+    const contextEvents = emitted.filter((e) => e.type === "context_usage");
+    expect(contextEvents.length).toBe(1);
+    const ctx = contextEvents[0];
+    if (ctx?.type === "context_usage") {
+      // Unified formula: input + cache_read + cache_write + output
+      expect(ctx.contextUsedTokens).toBe(12 + 99970 + 104606 + 288);
+      expect(ctx.contextFormula).toBe("input-cache-output");
+      expect(ctx.outputTokens).toBe(288);
+      expect(ctx.contextTotalTokens).toBeGreaterThan(0);
+      expect(ctx.contextPercent).toBeGreaterThan(0);
+    }
+    // The cost row stays consistent — same tokens, single turn.
+    expect(result.cost?.inputTokens).toBe(12);
+    expect(result.cost?.cacheReadTokens).toBe(99970);
+    expect(result.cost?.cacheWriteTokens).toBe(104606);
+    expect(result.cost?.outputTokens).toBe(288);
+    expect(result.cost?.numTurns).toBe(1);
+  });
+
+  test("non-finalized message.updated (tokens all zero) → NO context_usage emission", async () => {
+    // Simulates opencode's intermediate streaming updates that arrive before
+    // the model returns usage counts. Pre-fix, these emitted a 0-token snapshot
+    // that the runner-side throttle pinned for the rest of the session.
+    const events: OpencodeEvent[] = [
+      makeMessageUpdated({ completed: false }),
+      makeMessageUpdated({ completed: false }),
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+
+    const { emitted, result } = await driveSession(events);
+
+    const contextEvents = emitted.filter((e) => e.type === "context_usage");
+    expect(contextEvents.length).toBe(0);
+    // Cost accumulator also skipped non-finalized updates.
+    expect(result.cost?.numTurns).toBe(0);
+    expect(result.cost?.totalCostUsd).toBe(0);
+  });
+
+  test("mix of streaming-zero updates then finalized update → exactly one context_usage from the final", async () => {
+    // The realistic opencode event stream: many intermediate zero-token updates
+    // followed by a single finalized update. Only the finalized one should
+    // produce a context_usage row.
+    const events: OpencodeEvent[] = [
+      makeMessageUpdated({ completed: false }),
+      makeMessageUpdated({ completed: false }),
+      makeMessageUpdated({
+        completed: true,
+        input: 50,
+        output: 200,
+        cacheRead: 1000,
+        cacheWrite: 500,
+      }),
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+
+    const { emitted, result } = await driveSession(events);
+
+    const contextEvents = emitted.filter((e) => e.type === "context_usage");
+    expect(contextEvents.length).toBe(1);
+    if (contextEvents[0]?.type === "context_usage") {
+      expect(contextEvents[0].contextUsedTokens).toBe(50 + 1000 + 500 + 200);
+    }
+    expect(result.cost?.numTurns).toBe(1);
+    expect(result.cost?.inputTokens).toBe(50);
+  });
+
+  test("finalized message with all-zero tokens → still no emission (guards against pathological zero turns)", async () => {
+    const events: OpencodeEvent[] = [
+      makeMessageUpdated({ completed: true }), // all zero tokens
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+
+    const { emitted } = await driveSession(events);
+    const contextEvents = emitted.filter((e) => e.type === "context_usage");
+    expect(contextEvents.length).toBe(0);
+  });
+});
+
 // ── DES-300: per-task isolation ────────────────────────────────────────────────
 
 describe("OpencodeAdapter — per-task isolation (DES-300)", () => {

package/src/tests/otel-impl-secret-scrubbing.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { scrubOtelException, scrubOtelStatus } from "../otel-impl";
+
+const SECRET = "ghp_1234567890abcdefghijklmnopqrstuv";
+
+describe("otel-impl secret scrubbing", () => {
+  test("scrubs Error messages and stacks before recording exceptions", () => {
+    const error = new Error(`request failed with token ${SECRET}`);
+    error.stack = `Error: request failed with token ${SECRET}\n    at fake`;
+
+    const scrubbed = scrubOtelException(error);
+
+    expect(scrubbed).toBeInstanceOf(Error);
+    expect((scrubbed as Error).message).not.toContain(SECRET);
+    expect((scrubbed as Error).message).toContain("[REDACTED:github_token]");
+    expect((scrubbed as Error).stack).not.toContain(SECRET);
+  });
+
+  test("scrubs non-Error exception values", () => {
+    const scrubbed = scrubOtelException(`raw failure ${SECRET}`);
+
+    expect(scrubbed).toBe("raw failure [REDACTED:github_token]");
+  });
+
+  test("scrubs span status messages", () => {
+    const status = scrubOtelStatus({
+      code: 2,
+      message: `worker failed with token ${SECRET}`,
+    });
+
+    expect(status.message).toBe("worker failed with token [REDACTED:github_token]");
+  });
+});

package/src/tests/pages-view-count.test.ts

@@ -24,8 +24,7 @@ import { handlePagesPublic } from "../http/pages-public";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 
 const TEST_DB_PATH = "./test-pages-view-count.sqlite";
-const TEST_PORT = 13095;
-const BASE = `http://localhost:${TEST_PORT}`;
+let BASE = "";
 
 function createTestServer(): Server {
   return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
@@ -39,6 +38,23 @@ function createTestServer(): Server {
   });
 }
 
+async function startTestServer(): Promise<Server> {
+  const candidateServer = createTestServer();
+  await new Promise<void>((resolve, reject) => {
+    candidateServer.once("error", reject);
+    candidateServer.listen(0, () => {
+      const addr = candidateServer.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to resolve pages view-count test server port"));
+        return;
+      }
+      BASE = `http://localhost:${addr.port}`;
+      resolve();
+    });
+  });
+  return candidateServer;
+}
+
 async function getViewCount(id: string, agentId: string): Promise<number> {
   const res = await fetch(`${BASE}/api/pages/${id}`, {
     headers: { "X-Agent-ID": agentId },
@@ -50,23 +66,32 @@ async function getViewCount(id: string, agentId: string): Promise<number> {
 
 describe("Pages — view_count counter", () => {
   let server: Server;
+  let originalPageSessionSecret: string | undefined;
   const agentId = crypto.randomUUID();
   const headers = { "Content-Type": "application/json", "X-Agent-ID": agentId };
 
   beforeAll(async () => {
+    originalPageSessionSecret = process.env.PAGE_SESSION_SECRET;
+    process.env.PAGE_SESSION_SECRET = "test-view-count-secret";
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         await unlink(`${TEST_DB_PATH}${suffix}`);
       } catch {}
     }
     initDb(TEST_DB_PATH);
-    server = createTestServer();
-    await new Promise<void>((resolve) => server.listen(TEST_PORT, () => resolve()));
+    server = await startTestServer();
   });
 
   afterAll(async () => {
-    await new Promise<void>((resolve) => server.close(() => resolve()));
+    if (server) {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
     closeDb();
+    if (originalPageSessionSecret === undefined) {
+      delete process.env.PAGE_SESSION_SECRET;
+    } else {
+      process.env.PAGE_SESSION_SECRET = originalPageSessionSecret;
+    }
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         await unlink(`${TEST_DB_PATH}${suffix}`);

package/src/tests/providers/codex-cost.test.ts

@@ -0,0 +1,18 @@
+// Phase 6: codex adapter reads `reasoning_output_tokens` off `turn.completed`
+// and stuffs it into CostData. Pre-fix the field was read into `lastUsage`
+// but never propagated, so reasoning-model sessions silently under-billed.
+
+import { describe, expect, test } from "bun:test";
+import { computeCodexCostUsd } from "../../providers/codex-models";
+
+describe("codex-models (Phase 6)", () => {
+  test("known model still computes a non-zero cost from tokens", () => {
+    const usd = computeCodexCostUsd("gpt-5.4", 1_000_000, 0, 0);
+    expect(usd).toBeCloseTo(2.5, 5); // 1M input × $2.50/M
+  });
+
+  test("unknown model returns 0 (and logs a warning under the hood)", () => {
+    const usd = computeCodexCostUsd("gpt-future-2027", 1_000_000, 0, 1_000_000);
+    expect(usd).toBe(0);
+  });
+});

package/src/tests/providers/opencode-cost.test.ts

@@ -0,0 +1,74 @@
+// Phase 3 fix — regression guard that OpencodeSession stamps `provider:
+// "opencode"` on every CostData it emits. Without this tag the API server
+// recompute branch in src/http/session-data.ts falls through to
+// costSource='harness' instead of engaging the pricing-table lookup, so a
+// perfectly-priced model still renders as un-priced in the dashboard.
+//
+// Mirrors the narrow, single-purpose shape of src/tests/providers/codex-cost.test.ts.
+
+import { describe, expect, test } from "bun:test";
+import type { Event as OpencodeEvent } from "@opencode-ai/sdk";
+import { OpencodeSession } from "../../providers/opencode-adapter";
+import type { ProviderEvent } from "../../providers/types";
+
+function makeSession(): {
+  session: OpencodeSession;
+  events: ProviderEvent[];
+} {
+  const sessionId = "sess-cost-test";
+  const session = new OpencodeSession(
+    sessionId,
+    { url: "http://127.0.0.1:0", close: () => {} },
+    "openrouter/deepseek/deepseek-v4-flash",
+    "agent-1",
+    "task-1",
+    "/tmp/opencode-agent.md",
+    "/tmp/opencode-config.json",
+    "/tmp/opencode-data",
+  );
+  const events: ProviderEvent[] = [];
+  session.onEvent((e) => events.push(e));
+  return { session, events };
+}
+
+describe("OpencodeSession — provider tag on CostData", () => {
+  test("session.idle → emitted `result.cost.provider === 'opencode'`", async () => {
+    const { session, events } = makeSession();
+
+    // Drive the SSE event that causes OpencodeSession to build + emit CostData.
+    session.handleOpencodeEvent({
+      type: "session.idle",
+      properties: { sessionID: "sess-cost-test" },
+    } as unknown as OpencodeEvent);
+
+    const result = await session.waitForCompletion();
+
+    const resultEvent = events.find((e) => e.type === "result");
+    expect(resultEvent).toBeDefined();
+    if (resultEvent?.type === "result") {
+      // The load-bearing assertion. Phase 2's API recompute path keys off
+      // exactly this field; emitting CostData without it silently disables
+      // pricing-table tagging for the entire opencode provider.
+      expect(resultEvent.cost.provider).toBe("opencode");
+    }
+    expect(result.cost?.provider).toBe("opencode");
+  });
+
+  test("session.error → emitted `result.cost.provider === 'opencode'` on error path too", async () => {
+    const { session, events } = makeSession();
+
+    session.handleOpencodeEvent({
+      type: "session.error",
+      properties: {
+        sessionID: "sess-cost-test",
+        error: { message: "boom" },
+      },
+    } as unknown as OpencodeEvent);
+
+    const result = await session.waitForCompletion();
+    // The error-path also routes through buildCostData; same regression risk.
+    expect(result.cost?.provider).toBe("opencode");
+    const errEvent = events.find((e) => e.type === "error");
+    expect(errEvent).toBeDefined();
+  });
+});