@vellumai/assistant 0.10.7-dev.202607100720.fba456e → 0.10.7-dev.202607101106.c87f4e3

package/openapi.yaml

@@ -17727,10 +17727,6 @@ paths:
                           enum:
                             - user
                             - assistant
-                        content:
-                          type: string
-                          deprecated: true
-                          description: "Deprecated: superseded by contentBlocks. Flat plain-text body (joined text segments)."
                         timestamp:
                           type: string
                         attachments:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.7-dev.202607100720.fba456e",
+  "version": "0.10.7-dev.202607101106.c87f4e3",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/compaction-trail-store.test.ts

@@ -60,6 +60,7 @@ function insertLogAt(
   callSite: "mainAgent" | "compactionAgent" | null,
   requestPayload = "{}",
 ): string {
+  // Logging is enabled in these tests, so the write always returns an id.
   const id = recordRequestLog(
     conversationId,
     requestPayload,
@@ -67,7 +68,7 @@ function insertLogAt(
     undefined,
     "anthropic",
     callSite ?? undefined,
-  );
+  )!;
   // Use the Drizzle update builder rather than `db.run("UPDATE … ?")` —
   // the drizzle wrapper doesn't accept positional parameters the same
   // way `bun:sqlite` does, and a silent no-op there manifests as zero

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -51,7 +51,9 @@ mock.module("../util/logger.js", () => ({
 let appControlFlagEnabled = false;
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "app-control") return appControlFlagEnabled;
+    if (key === "app-control") {
+      return appControlFlagEnabled;
+    }
     return true;
   },
   loadDefaultsRegistry: () => ({}),
@@ -143,7 +145,20 @@ mock.module("../tools/registry.js", () => ({
     let found: Tool | undefined;
     for (const tools of mockRegisteredTools.values()) {
       for (const tool of tools) {
-        if (tool.name === name) found = tool;
+        if (tool.name === name) {
+          found = tool;
+        }
+      }
+    }
+    return found;
+  },
+  resolveTool: (name: string) => {
+    let found: Tool | undefined;
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        if (tool.name === name) {
+          found = tool;
+        }
       }
     }
     return found;
@@ -158,7 +173,9 @@ mock.module("../tools/registry.js", () => ({
     let ownerSkillId: string | undefined;
     for (const [skillId, tools] of mockRegisteredTools.entries()) {
       for (const tool of tools) {
-        if (tool.name === name) ownerSkillId = skillId;
+        if (tool.name === name) {
+          ownerSkillId = skillId;
+        }
       }
     }
     return ownerSkillId === undefined

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -3220,6 +3220,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       createdAt: opts.createdAt,
       metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
       clientMessageId: null,
+      finalized: 1,
     };
   }
 
@@ -3241,6 +3242,7 @@ describe("Slack channel chronological rendering — multi-thread", () => {
       createdAt: opts.createdAt,
       metadata: Object.keys(outer).length > 0 ? JSON.stringify(outer) : null,
       clientMessageId: null,
+      finalized: 1,
     };
   }
 

package/src/__tests__/conversation-skill-tools.test.ts

@@ -57,7 +57,9 @@ mock.module("../config/skills.js", () => ({
       ? skills
       : skills.filter((skill) => {
           const owner = skill.owner;
-          if (owner?.kind !== "plugin") return true;
+          if (owner?.kind !== "plugin") {
+            return true;
+          }
           return effectiveEnabledPluginSet.has(owner.id);
         }),
 }));
@@ -82,10 +84,16 @@ mock.module("../skills/active-skill-tools.js", () => {
     const entries: Array<{ id: string; version?: string }> = [];
     for (const msg of messages) {
       for (const block of msg.content) {
-        if (block.type !== "tool_result") continue;
-        if (!skillLoadUseIds.has(block.tool_use_id)) continue;
+        if (block.type !== "tool_result") {
+          continue;
+        }
+        if (!skillLoadUseIds.has(block.tool_use_id)) {
+          continue;
+        }
         const text = block.content;
-        if (!text) continue;
+        if (!text) {
+          continue;
+        }
         for (const match of text.matchAll(re)) {
           if (!seen.has(match[1])) {
             seen.add(match[1]);
@@ -170,7 +178,22 @@ mock.module("../tools/registry.js", () => ({
     let found: Tool | undefined;
     for (const tools of mockRegisteredTools.values()) {
       for (const tool of tools) {
-        if (tool.name === name) found = tool;
+        if (tool.name === name) {
+          found = tool;
+        }
+      }
+    }
+    return found;
+  },
+  // Sync peek mirrors getTool — the skill-tool projection path reads via
+  // resolveTool synchronously.
+  resolveTool: (name: string): Tool | undefined => {
+    let found: Tool | undefined;
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        if (tool.name === name) {
+          found = tool;
+        }
       }
     }
     return found;
@@ -184,7 +207,9 @@ mock.module("../tools/registry.js", () => ({
     let ownerSkillId: string | undefined;
     for (const [skillId, tools] of mockRegisteredTools.entries()) {
       for (const tool of tools) {
-        if (tool.name === name) ownerSkillId = skillId;
+        if (tool.name === name) {
+          ownerSkillId = skillId;
+        }
       }
     }
     return ownerSkillId === undefined

package/src/__tests__/list-messages-queued.test.ts

@@ -54,7 +54,7 @@ function resetTables() {
 interface MessagePayload {
   id: string;
   role: string;
-  content?: string;
+  contentBlocks?: Array<{ type: string; text?: string }>;
   clientMessageId?: string;
   queueStatus?: "queued" | "processing";
   queuePosition?: number;
@@ -123,7 +123,10 @@ describe("handleListMessages in-memory queue", () => {
     expect(first.queuePosition).toBe(1);
     expect(first.role).toBe("user");
     expect(first.id).toBe("req-queued-1");
-    expect(first.content).toBe("please also do this");
+    expect(first.contentBlocks?.[0]).toEqual({
+      type: "text",
+      text: "please also do this",
+    });
     expect(first.clientMessageId).toBe("nonce-queued");
 
     const second = body.messages[2];
@@ -148,7 +151,10 @@ describe("handleListMessages in-memory queue", () => {
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("what the user actually typed");
+    expect(body.messages[0].contentBlocks?.[0]).toEqual({
+      type: "text",
+      text: "what the user actually typed",
+    });
   });
 
   test("renders queued attachments with a derived kind", async () => {

package/src/__tests__/llm-request-log-agent-loop-exit-reason.test.ts

@@ -46,7 +46,7 @@ describe("setAgentLoopExitReasonOnLatestLog", () => {
 
   test("recordRequestLog leaves agentLoopExitReason NULL", () => {
     const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
-    const row = getRequestLogById(id);
+    const row = getRequestLogById(id!);
     expect(row).not.toBeNull();
     expect(row!.agentLoopExitReason).toBeNull();
   });
@@ -61,8 +61,8 @@ describe("setAgentLoopExitReasonOnLatestLog", () => {
 
     setAgentLoopExitReasonOnLatestLog("conv-1", "no_tool_calls");
 
-    expect(getRequestLogById(first)?.agentLoopExitReason).toBeNull();
-    expect(getRequestLogById(second)?.agentLoopExitReason).toBe(
+    expect(getRequestLogById(first!)?.agentLoopExitReason).toBeNull();
+    expect(getRequestLogById(second!)?.agentLoopExitReason).toBe(
       "no_tool_calls",
     );
   });
@@ -74,10 +74,10 @@ describe("setAgentLoopExitReasonOnLatestLog", () => {
 
     setAgentLoopExitReasonOnLatestLog("conv-a", "yield_to_user");
 
-    expect(getRequestLogById(a)?.agentLoopExitReason).toBe("yield_to_user");
+    expect(getRequestLogById(a!)?.agentLoopExitReason).toBe("yield_to_user");
     // conv-b is later overall but belongs to a different conversation —
     // must stay NULL.
-    expect(getRequestLogById(b)?.agentLoopExitReason).toBeNull();
+    expect(getRequestLogById(b!)?.agentLoopExitReason).toBeNull();
   });
 
   test("no-op when conversation has no logs", () => {
@@ -90,12 +90,12 @@ describe("setAgentLoopExitReasonOnLatestLog", () => {
     // Previous run: completes, lands a log, gets stamped.
     const prev = recordRequestLog("conv-1", '{"prev_req":1}', '{"prev_res":1}');
     setAgentLoopExitReasonOnLatestLog("conv-1", "no_tool_calls");
-    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
+    expect(getRequestLogById(prev!)?.agentLoopExitReason).toBe("no_tool_calls");
 
     // Current run aborts pre-call (or similar) before any LLM call lands.
     // The helper must NOT overwrite the previous run's row.
     setAgentLoopExitReasonOnLatestLog("conv-1", "aborted_pre_call");
-    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
+    expect(getRequestLogById(prev!)?.agentLoopExitReason).toBe("no_tool_calls");
   });
 
   test("stamps the current run's newest row even when a prior row is already stamped", () => {
@@ -112,8 +112,8 @@ describe("setAgentLoopExitReasonOnLatestLog", () => {
     );
     setAgentLoopExitReasonOnLatestLog("conv-1", "yield_to_user");
 
-    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
-    expect(getRequestLogById(current)?.agentLoopExitReason).toBe(
+    expect(getRequestLogById(prev!)?.agentLoopExitReason).toBe("no_tool_calls");
+    expect(getRequestLogById(current!)?.agentLoopExitReason).toBe(
       "yield_to_user",
     );
   });

package/src/__tests__/llm-request-log-call-site.test.ts

@@ -52,14 +52,14 @@ describe("recordRequestLog call_site stamping", () => {
       "anthropic",
       "mainAgent",
     );
-    const row = getRequestLogById(id);
+    const row = getRequestLogById(id!);
     expect(row).not.toBeNull();
     expect(row!.callSite).toBe("mainAgent");
   });
 
   test("leaves callSite NULL when omitted (backward compat)", () => {
     const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
-    const row = getRequestLogById(id);
+    const row = getRequestLogById(id!);
     expect(row).not.toBeNull();
     expect(row!.callSite).toBeNull();
   });
@@ -73,7 +73,7 @@ describe("recordRequestLog call_site stamping", () => {
       "anthropic",
       "compactionAgent",
     );
-    expect(getRequestLogById(id)?.callSite).toBe("compactionAgent");
+    expect(getRequestLogById(id!)?.callSite).toBe("compactionAgent");
   });
 
   test("two rows in the same conversation can carry different callSites", () => {
@@ -93,8 +93,8 @@ describe("recordRequestLog call_site stamping", () => {
       "anthropic",
       "compactionAgent",
     );
-    expect(getRequestLogById(mainId)?.callSite).toBe("mainAgent");
-    expect(getRequestLogById(compactId)?.callSite).toBe("compactionAgent");
+    expect(getRequestLogById(mainId!)?.callSite).toBe("mainAgent");
+    expect(getRequestLogById(compactId!)?.callSite).toBe("compactionAgent");
   });
 });
 

package/src/__tests__/llm-request-log-disabled-writes.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests the master switch for LLM request logging (`llmRequestLogs.enabled`).
+ * When logging is off, the store's insert paths (`recordRequestLog`,
+ * `recordSyntheticAgentErrorMessageLog`) must skip the write entirely — no
+ * prompt/completion payload lands on disk — and return `null`. The read-side
+ * 4xx is exercised separately at the route layer.
+ */
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Mutable so each test toggles the flag the store reads via `getConfigReadOnly`.
+let enabled = true;
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llmRequestLogs: { readSource: "local", enabled },
+  }),
+  getConfigReadOnly: () => ({
+    llmRequestLogs: { readSource: "local", enabled },
+  }),
+}));
+
+// `mock.module()` persists process-wide; reset so other files don't inherit a
+// stale value.
+afterAll(() => {
+  enabled = true;
+});
+
+import { getLogsDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getRequestLogById,
+  getRequestLogsByConversationId,
+  recordRequestLog,
+  recordSyntheticAgentErrorMessageLog,
+} from "../persistence/llm-request-log-store.js";
+import { llmRequestLogs } from "../persistence/schema/index.js";
+
+await initializeDb();
+
+function resetLogs(): void {
+  getLogsDb()!.delete(llmRequestLogs).run();
+}
+
+describe("llmRequestLogs.enabled write gate", () => {
+  beforeEach(() => {
+    resetLogs();
+    enabled = true;
+  });
+
+  test("recordRequestLog writes normally when logging is enabled", () => {
+    const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
+    expect(id).not.toBeNull();
+    expect(getRequestLogById(id!)).not.toBeNull();
+  });
+
+  test("recordRequestLog skips the write when logging is disabled", () => {
+    enabled = false;
+    const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
+    expect(id).toBeNull();
+    expect(getRequestLogsByConversationId("conv-1")).toEqual([]);
+  });
+
+  test("recordSyntheticAgentErrorMessageLog skips the write when disabled", () => {
+    enabled = false;
+    const id = recordSyntheticAgentErrorMessageLog({
+      conversationId: "conv-2",
+      messageId: "msg-2",
+      exitReason: "budget_yield_unrecovered",
+      noticeText: "Out of budget.",
+      preparedRequest: null,
+      createdAt: Date.now(),
+    });
+    expect(id).toBeNull();
+    expect(getRequestLogsByConversationId("conv-2")).toEqual([]);
+  });
+
+  test("re-enabling logging restores writes", () => {
+    enabled = false;
+    expect(recordRequestLog("conv-3", '{"req":1}', '{"res":1}')).toBeNull();
+    enabled = true;
+    const id = recordRequestLog("conv-3", '{"req":2}', '{"res":2}');
+    expect(id).not.toBeNull();
+    expect(getRequestLogsByConversationId("conv-3")).toHaveLength(1);
+  });
+});

package/src/__tests__/media-generate-image.test.ts

@@ -44,13 +44,21 @@ mock.module("../config/loader.js", () => ({
 
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (account: string) => {
-    if (account === "gemini") return mockGeminiKey;
-    if (account === "openai") return mockOpenAIKey;
+    if (account === "gemini") {
+      return mockGeminiKey;
+    }
+    if (account === "openai") {
+      return mockOpenAIKey;
+    }
     return undefined;
   },
   getProviderKeyAsync: async (provider: string) => {
-    if (provider === "gemini") return mockGeminiKey;
-    if (provider === "openai") return mockOpenAIKey;
+    if (provider === "gemini") {
+      return mockGeminiKey;
+    }
+    if (provider === "openai") {
+      return mockOpenAIKey;
+    }
     return undefined;
   },
 }));
@@ -63,13 +71,16 @@ mock.module("../media/image-service.js", () => ({
   ) => {
     lastGenerateProvider = provider;
     lastGenerateCredentials = credentials;
-    if (mockGenerateError) throw mockGenerateError;
+    if (mockGenerateError) {
+      throw mockGenerateError;
+    }
     return mockGenerateResult;
   },
   mapImageGenError: (provider: unknown, error: unknown) => {
     const providerLabel = provider === "openai" ? "OpenAI" : "Gemini";
-    if (error instanceof Error)
+    if (error instanceof Error) {
       return `Mock ${providerLabel} error: ${error.message}`;
+    }
     return `Mock ${providerLabel} unknown error`;
   },
 }));
@@ -394,7 +405,9 @@ describe("image-studio skill script wrapper", () => {
       expect(result.content).toContain("Generated 1 image");
     } finally {
       const { unlink } = await import("fs/promises");
-      if (await Bun.file(tmpPath).exists()) await unlink(tmpPath);
+      if (await Bun.file(tmpPath).exists()) {
+        await unlink(tmpPath);
+      }
     }
   });
 

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -85,7 +85,9 @@ mock.module("../permissions/checker.js", () => ({
   isDynamicSkillLoadInvocation: () => false,
   classifyRisk: async () => ({ level: riskOverride }),
   check: async () => {
-    if (checkResultOverride) return checkResultOverride;
+    if (checkResultOverride) {
+      return checkResultOverride;
+    }
     return { decision: "allow", reason: "allowed" };
   },
   generateAllowlistOptions: () => [
@@ -106,7 +108,22 @@ mock.module("../telemetry/tool-usage-store.js", () => ({
 
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => {
-    if (name === "unknown_tool") return undefined;
+    if (name === "unknown_tool") {
+      return undefined;
+    }
+    return {
+      name,
+      description: "test tool",
+      category: "shell",
+      defaultRiskLevel: "medium",
+      input_schema: {},
+      execute: async () => fakeToolResult,
+    };
+  },
+  resolveTool: (name: string) => {
+    if (name === "unknown_tool") {
+      return undefined;
+    }
     return {
       name,
       description: "test tool",

package/src/__tests__/registry.test.ts

@@ -17,6 +17,7 @@ import {
   registerSkillTools,
   registerTool,
   registerWorkspaceTools,
+  resolveTool,
   unregisterSkillTools,
   unregisterWorkspaceTool,
 } from "../tools/registry.js";
@@ -109,6 +110,23 @@ describe("tool registry dynamic-tools tools", () => {
   });
 });
 
+describe("resolveTool lazy initialization", () => {
+  test("await resolveTool initializes a cold registry, then sync getTool sees it", async () => {
+    // Empty the registry and clear the cached init promise.
+    __clearRegistryForTesting();
+    // A synchronous peek sees nothing yet — the registry is cold.
+    expect(getTool("file_read")).toBeUndefined();
+
+    // The async getter awaits initialization (like getHooksFor awaits its
+    // reconcile), so it resolves the built-in instead of a spurious undefined.
+    const tool = await resolveTool("file_read");
+    expect(tool?.name).toBe("file_read");
+
+    // After the ensure, the synchronous hot-path read sees it too.
+    expect(getTool("file_read")?.name).toBe("file_read");
+  });
+});
+
 describe("tool manifest", () => {
   test("explicit tools list includes memory tools", () => {
     const names = explicitTools.map((t) => t.name);

package/src/__tests__/require-fresh-approval.test.ts

@@ -157,6 +157,21 @@ mock.module("../tools/registry.js", () => ({
       execute: async () => fakeToolResult,
     };
   },
+  resolveTool: (name: string) => {
+    if (name === "unknown_tool") {
+      return undefined;
+    }
+    const isGmailTool = name.startsWith("gmail_");
+    return {
+      name,
+      description: "test tool",
+      category: isGmailTool ? "gmail" : "credential-execution",
+      defaultRiskLevel: "high",
+      executionTarget: isGmailTool ? ("host" as const) : undefined,
+      input_schema: {},
+      execute: async () => fakeToolResult,
+    };
+  },
   getAllTools: () => [],
 }));
 

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -55,7 +55,9 @@ let _mockOverrides: Record<string, boolean> = {};
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
     const explicit = _mockOverrides[key];
-    if (typeof explicit === "boolean") return explicit;
+    if (typeof explicit === "boolean") {
+      return explicit;
+    }
     return false; // undeclared flags default to disabled
   },
   clearFeatureFlagOverridesCache: () => {
@@ -84,15 +86,23 @@ mock.module("../skills/active-skill-tools.js", () => {
     const entries: Array<{ id: string; version?: string }> = [];
     for (const msg of messages) {
       for (const block of msg.content) {
-        if (block.type !== "tool_result") continue;
-        if (!skillLoadUseIds.has(block.tool_use_id)) continue;
+        if (block.type !== "tool_result") {
+          continue;
+        }
+        if (!skillLoadUseIds.has(block.tool_use_id)) {
+          continue;
+        }
         const text = block.content;
-        if (!text) continue;
+        if (!text) {
+          continue;
+        }
         for (const m of text.matchAll(re)) {
           if (!seen.has(m[1])) {
             seen.add(m[1]);
             const entry: { id: string; version?: string } = { id: m[1] };
-            if (m[2]) entry.version = m[2];
+            if (m[2]) {
+              entry.version = m[2];
+            }
             entries.push(entry);
           }
         }
@@ -111,7 +121,9 @@ mock.module("../skills/tool-manifest.js", () => ({
     const parts = filePath.split("/");
     const skillId = parts[parts.length - 2];
     const manifest = mockManifests[skillId];
-    if (!manifest) throw new Error(`Mock: no manifest for skill "${skillId}"`);
+    if (!manifest) {
+      throw new Error(`Mock: no manifest for skill "${skillId}"`);
+    }
     return manifest;
   },
 }));
@@ -162,7 +174,20 @@ mock.module("../tools/registry.js", () => ({
     let found: Tool | undefined;
     for (const tools of mockRegisteredTools.values()) {
       for (const tool of tools) {
-        if (tool.name === name) found = tool;
+        if (tool.name === name) {
+          found = tool;
+        }
+      }
+    }
+    return found;
+  },
+  resolveTool: (name: string): Tool | undefined => {
+    let found: Tool | undefined;
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        if (tool.name === name) {
+          found = tool;
+        }
       }
     }
     return found;
@@ -177,7 +202,9 @@ mock.module("../tools/registry.js", () => ({
     let ownerSkillId: string | undefined;
     for (const [skillId, tools] of mockRegisteredTools.entries()) {
       for (const tool of tools) {
-        if (tool.name === name) ownerSkillId = skillId;
+        if (tool.name === name) {
+          ownerSkillId = skillId;
+        }
       }
     }
     return ownerSkillId === undefined

package/src/__tests__/skill-projection.benchmark.test.ts

@@ -175,15 +175,20 @@ mock.module("../tools/registry.js", () => ({
     skillId: string,
     tools: Array<{ name: string; [k: string]: unknown }>,
   ) => {
-    for (const t of tools) benchmarkRegistry.set(t.name, { tool: t, skillId });
+    for (const t of tools) {
+      benchmarkRegistry.set(t.name, { tool: t, skillId });
+    }
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
     for (const [name, entry] of benchmarkRegistry) {
-      if (entry.skillId === skillId) benchmarkRegistry.delete(name);
+      if (entry.skillId === skillId) {
+        benchmarkRegistry.delete(name);
+      }
     }
   },
   getTool: (name: string) => benchmarkRegistry.get(name)?.tool,
+  resolveTool: (name: string) => benchmarkRegistry.get(name)?.tool,
   getToolOwner: (name: string) => {
     const entry = benchmarkRegistry.get(name);
     return entry ? { kind: "skill" as const, id: entry.skillId } : undefined;

package/src/__tests__/subagent-detail.test.ts

@@ -19,6 +19,7 @@ function msg(role: string, content: unknown[]): MessageRow {
     createdAt: Date.now(),
     metadata: null,
     clientMessageId: null,
+    finalized: 1,
   };
 }
 

package/src/__tests__/summarize-boundary.test.ts

@@ -13,6 +13,7 @@ function row(id: string, role: string, content: string): MessageRow {
     createdAt: 0,
     metadata: null,
     clientMessageId: null,
+    finalized: 1,
   };
 }
 

package/src/__tests__/tool-approval-handler.test.ts

@@ -32,6 +32,7 @@ const fakeTool = {
 
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => (name === "bash" ? fakeTool : undefined),
+  resolveTool: (name: string) => (name === "bash" ? fakeTool : undefined),
   getAllTools: () => [fakeTool],
 }));
 

package/src/__tests__/tool-execution-pipeline.benchmark.test.ts

@@ -52,6 +52,7 @@ mock.module("../config/skills.js", () => ({
 
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => localRegistry.get(name),
+  resolveTool: (name: string) => localRegistry.get(name),
   getAllTools: () => Array.from(localRegistry.values()),
   registerTool: (tool: import("../tools/types.js").Tool) => {
     localRegistry.set(tool.name, tool);