@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/__tests__/llm-context-normalization.test.ts

@@ -1827,109 +1827,4 @@ describe("normalizeLlmContextPayloads", () => {
       },
     ]);
   });
-
-  describe("provider error response payloads", () => {
-    test("extracts a structured error from a rejected call's response payload", () => {
-      const normalized = normalizeLlmContextPayloads({
-        createdAt: 1_742_400_000_000,
-        requestPayload: {
-          model: "accounts/fireworks/models/glm-5p2",
-          messages: [{ role: "user", content: "hello" }],
-        },
-        responsePayload: {
-          error: {
-            name: "ProviderError",
-            message:
-              "This model doesn't support image input. Remove the image or switch to a vision-capable model.",
-            code: "PROVIDER_ERROR",
-            provider: "fireworks",
-            statusCode: 400,
-          },
-        },
-      });
-
-      expect(normalized.error).toEqual({
-        name: "ProviderError",
-        message:
-          "This model doesn't support image input. Remove the image or switch to a vision-capable model.",
-        code: "PROVIDER_ERROR",
-        provider: "fireworks",
-        statusCode: 400,
-      });
-      // No response sections are produced for an error payload.
-      expect(normalized.responseSections).toBeUndefined();
-    });
-
-    test("preserves a normalized request alongside the error", () => {
-      const normalized = normalizeLlmContextPayloads({
-        createdAt: 1_742_400_000_000,
-        requestPayload: {
-          model: "gpt-4.1",
-          tool_choice: "auto",
-          messages: [{ role: "user", content: "hi" }],
-        },
-        responsePayload: { error: { message: "boom" } },
-      });
-
-      expect(normalized.error).toEqual({ message: "boom" });
-      // The request side still normalizes so the Prompt tab keeps working.
-      expect(normalized.requestSections?.length).toBeGreaterThan(0);
-      expect(normalized.summary?.provider).toBe("openai");
-    });
-
-    test("carries statusCode 0 and retryAfterMs through", () => {
-      const normalized = normalizeLlmContextPayloads({
-        createdAt: 1_742_400_000_000,
-        requestPayload: null,
-        responsePayload: {
-          error: {
-            name: "ProviderError",
-            message: "rate limited",
-            provider: "anthropic",
-            statusCode: 0,
-            retryAfterMs: 1500,
-          },
-        },
-      });
-
-      expect(normalized.error).toEqual({
-        name: "ProviderError",
-        message: "rate limited",
-        provider: "anthropic",
-        statusCode: 0,
-        retryAfterMs: 1500,
-      });
-    });
-
-    test("does not treat a successful response with no error as failed", () => {
-      const normalized = normalizeLlmContextPayloads({
-        createdAt: 1_742_400_000_000,
-        requestPayload: {
-          model: "gpt-4.1",
-          messages: [{ role: "user", content: "hi" }],
-        },
-        responsePayload: {
-          model: "gpt-4.1",
-          choices: [
-            {
-              finish_reason: "stop",
-              message: { role: "assistant", content: "hello" },
-            },
-          ],
-        },
-      });
-
-      expect(normalized.error).toBeUndefined();
-    });
-
-    test("ignores an empty error object with no identifying fields", () => {
-      const normalized = normalizeLlmContextPayloads({
-        createdAt: 1_742_400_000_000,
-        requestPayload: null,
-        responsePayload: { error: {} },
-      });
-
-      expect(normalized.error).toBeUndefined();
-    });
-  });
 });

package/src/__tests__/llm-request-log-error-payload.test.ts

@@ -25,15 +25,18 @@
 import { describe, expect, test } from "bun:test";
 
 import { buildProviderErrorResponsePayload } from "../memory/llm-request-log-store.js";
-import { AssistantError, ErrorCode, ProviderError } from "../util/errors.js";
+import {
+  AssistantError,
+  ErrorCode,
+  ProviderError,
+} from "../util/errors.js";
 
-function persisted(err: Error): {
-  error: Record<string, unknown>;
-  rawResponse?: unknown;
-} {
+function persisted(err: Error): { error: Record<string, unknown> } {
   // Round-trip through JSON to assert on the actual stored shape, not the
   // in-memory object reference.
-  return JSON.parse(JSON.stringify(buildProviderErrorResponsePayload(err)));
+  return JSON.parse(
+    JSON.stringify(buildProviderErrorResponsePayload(err)),
+  );
 }
 
 describe("buildProviderErrorResponsePayload", () => {
@@ -57,34 +60,6 @@ describe("buildProviderErrorResponsePayload", () => {
     });
   });
 
-  test("ProviderError serializes upstream provider error metadata when present", () => {
-    const err = new ProviderError(
-      "OpenAI API error (401): Invalid API key provided",
-      "openai",
-      401,
-      {
-        apiErrorCode: "invalid_api_key",
-        apiErrorType: "invalid_request_error",
-        apiErrorParam: "api_key",
-        requestId: "req_abc123",
-      },
-    );
-    const got = persisted(err);
-    expect(got).toEqual({
-      error: {
-        name: "ProviderError",
-        message: "OpenAI API error (401): Invalid API key provided",
-        code: ErrorCode.PROVIDER_ERROR,
-        provider: "openai",
-        statusCode: 401,
-        apiErrorCode: "invalid_api_key",
-        apiErrorType: "invalid_request_error",
-        apiErrorParam: "api_key",
-        requestId: "req_abc123",
-      },
-    });
-  });
-
   test("ProviderError without optional metadata omits statusCode + retryAfterMs", () => {
     const err = new ProviderError(
       "Gemini API error: surprise internal state",
@@ -152,43 +127,6 @@ describe("buildProviderErrorResponsePayload", () => {
     });
   });
 
-  test("captured JSON rawBody is attached as a parsed rawResponse sibling", () => {
-    // So the inspector's Raw tab can render the actual upstream provider JSON
-    // (like a successful row) instead of only the extracted error fields.
-    const err = new ProviderError(
-      "Together AI API error (400): Model 'MiniMax-M3' is not supported.",
-      "together",
-      400,
-      {
-        apiErrorCode: "model_not_supported",
-        rawBody: JSON.stringify({
-          detail: "Model 'MiniMax-M3' is not supported.",
-        }),
-      },
-    );
-    const got = persisted(err);
-    expect(got.error.apiErrorCode).toBe("model_not_supported");
-    expect(got.rawResponse).toEqual({
-      detail: "Model 'MiniMax-M3' is not supported.",
-    });
-  });
-
-  test("non-JSON rawBody (HTML/text error page) is kept verbatim as a string", () => {
-    const err = new ProviderError("Bad gateway", "openai", 400, {
-      rawBody: "<html><body>upstream timeout</body></html>",
-    });
-    const got = persisted(err);
-    expect(got.rawResponse).toBe("<html><body>upstream timeout</body></html>");
-  });
-
-  test("no captured rawBody omits the rawResponse sibling entirely", () => {
-    const err = new ProviderError("rate limited", "anthropic", 429, {
-      retryAfterMs: 1500,
-    });
-    const got = persisted(err);
-    expect("rawResponse" in got).toBe(false);
-  });
-
   test("ProviderError with statusCode 0 is still recorded (not coerced to undefined)", () => {
     // Defensive: `if (err.statusCode !== undefined)` correctly admits 0.
     // A raw `if (err.statusCode)` would drop it, so the test guards against

package/src/__tests__/llm-usage-store.test.ts

@@ -779,31 +779,6 @@ describe("getUsageDayBuckets", () => {
     expect(buckets[0].totalEstimatedCostUsd).toBeCloseTo(0.05);
     expect(buckets[0].eventCount).toBe(2);
   });
-
-  test("collapses many events within a sub-bucket span without losing totals", () => {
-    // The read path pre-aggregates events into 15-minute UTC buckets in SQL
-    // before local-time bucketing. Many events inside one such window must
-    // still sum exactly, and events split across the 15-minute boundary but
-    // within the same local day must land in the same day bucket.
-    const windowStart = utcMs(2025, 3, 1, 10); // 10:00:00 UTC
-    for (let i = 0; i < 50; i++) {
-      // Spread across ~16 minutes so the events straddle a 15-minute boundary.
-      insertEventAt(windowStart + i * 20_000, {
-        inputTokens: 2,
-        outputTokens: 1,
-      });
-    }
-
-    const buckets = getUsageDayBuckets({
-      from: utcMs(2025, 3, 1),
-      to: utcMs(2025, 3, 2),
-    });
-    expect(buckets).toHaveLength(1);
-    expect(buckets[0].date).toBe("2025-03-01");
-    expect(buckets[0].totalInputTokens).toBe(100);
-    expect(buckets[0].totalOutputTokens).toBe(50);
-    expect(buckets[0].eventCount).toBe(50);
-  });
 });
 
 describe("getUsageDayBuckets — timezone-aware", () => {

package/src/__tests__/mcp-health-check.test.ts

@@ -58,8 +58,7 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
 }));
 
 mock.module("../mcp/mcp-oauth-provider.js", () => ({
-  hasMcpOAuthTokens: async () => false,
-  deleteMcpOAuthCredentials: async () => ({ ok: true, failedKeys: [] }),
+  deleteMcpOAuthCredentials: async () => {},
 }));
 
 const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");

package/src/__tests__/media-stream-server-integration.test.ts

@@ -176,22 +176,6 @@ mock.module("../calls/channel-admission-reader.js", () => ({
   getChannelAdmissionPolicy: mockGetChannelAdmissionPolicy,
 }));
 
-// Mock the inbound trust reader. handleStart awaits this and threads the
-// verdict into routeSetup so the media-stream transport enforces the same
-// gateway ACL as ConversationRelay. Tests override mockInboundVerdict.
-let mockInboundVerdict: unknown = null;
-const mockGetInboundTrustVerdict = jest.fn(
-  async (_args?: Record<string, unknown>) => mockInboundVerdict,
-);
-mock.module("../calls/inbound-trust-reader.js", () => ({
-  getInboundTrustVerdict: mockGetInboundTrustVerdict,
-  getPhoneCallerVerdict: (otherPartyNumber: string | undefined) =>
-    mockGetInboundTrustVerdict({
-      channelType: "phone",
-      actorExternalId: otherPartyNumber || undefined,
-    }),
-}));
-
 // Mock the actor trust resolver (used by handleStart to derive trust context)
 mock.module("../runtime/actor-trust-resolver.js", () => ({
   toTrustContext: jest.fn(() => ({
@@ -372,8 +356,6 @@ beforeEach(() => {
   mockGetChannelAdmissionPolicy.mockClear();
   mockAdmissionPolicy = null;
   mockAdmissionGate = null;
-  mockGetInboundTrustVerdict.mockClear();
-  mockInboundVerdict = null;
   // Reset routeSetup to default normal_call
   mockRouteSetupResult = {
     outcome: { action: "normal_call" as const, isInbound: true },
@@ -1553,113 +1535,4 @@ describe("media-stream setup outcome scenarios", () => {
       expect(speakSystemPrompt).not.toHaveBeenCalled();
     });
   });
-
-  // ── Gateway trust verdict ──────────────────────────────────────────
-  // handleStart fetches getInboundTrustVerdict for the inbound caller and
-  // threads it into routeSetup, so the media-stream transport enforces the
-  // same gateway ACL as ConversationRelay. routeSetup itself decides
-  // verdict-vs-local; these tests assert the verdict is fetched and passed.
-
-  describe("gateway trust verdict", () => {
-    test("fetches the inbound caller's verdict and threads it into routeSetup", async () => {
-      mockInboundVerdict = {
-        channelType: "phone",
-        actorExternalId: "+14155550000",
-        contactId: "contact-1",
-        channelId: "channel-1",
-        status: "verified",
-        policy: "allow",
-        resolutionFailed: false,
-      };
-
-      const mockWs = createMockWs();
-      mockSessions.set("call-verdict-thread-1", {
-        id: "call-verdict-thread-1",
-        conversationId: "conv-verdict-thread-1",
-        status: "initiated",
-        task: null,
-        startedAt: null,
-        fromNumber: "+14155550000",
-        toNumber: "+15550001111",
-      });
-
-      const session = new MediaStreamCallSession(
-        mockWs.ws,
-        "call-verdict-thread-1",
-      );
-      session.handleMessage(makeStartMessage());
-      await session.whenSetupSettled();
-
-      // Verdict fetched for the inbound caller (from number) on the phone channel.
-      expect(mockGetInboundTrustVerdict).toHaveBeenCalledWith({
-        channelType: "phone",
-        actorExternalId: "+14155550000",
-      });
-      // Verdict threaded into routeSetup.
-      expect(routeSetup).toHaveBeenCalledWith(
-        expect.objectContaining({ verdict: mockInboundVerdict }),
-      );
-    });
-
-    test("a blocked/denied member verdict is enforced (deny) on the media-stream transport", async () => {
-      // The real router returns `deny` for a member verdict whose ACL is
-      // blocked/revoked/deny; the mock reflects that outcome here.
-      mockInboundVerdict = {
-        channelType: "phone",
-        actorExternalId: "+14155550000",
-        contactId: "contact-1",
-        channelId: "channel-1",
-        status: "blocked",
-        policy: "deny",
-        resolutionFailed: false,
-      };
-      mockRouteSetupResult = {
-        outcome: {
-          action: "deny",
-          message:
-            "This number is not authorized to reach the assistant right now.",
-          logReason: "Inbound voice ACL: member blocked",
-        },
-        resolved: {
-          assistantId: "self",
-          isInbound: true,
-          otherPartyNumber: "+14155550000",
-          actorTrust: { trustClass: "unknown", memberRecord: null },
-        },
-      };
-
-      const mockWs = createMockWs();
-      mockSessions.set("call-verdict-deny-1", {
-        id: "call-verdict-deny-1",
-        conversationId: "conv-verdict-deny-1",
-        status: "initiated",
-        task: null,
-        startedAt: null,
-        fromNumber: "+14155550000",
-        toNumber: "+15550001111",
-      });
-
-      const session = new MediaStreamCallSession(
-        mockWs.ws,
-        "call-verdict-deny-1",
-      );
-      session.handleMessage(makeStartMessage());
-      await session.whenSetupSettled();
-
-      // Verdict was passed into routeSetup, which denied the caller.
-      expect(routeSetup).toHaveBeenCalledWith(
-        expect.objectContaining({ verdict: mockInboundVerdict }),
-      );
-      expect(speakSystemPrompt).toHaveBeenCalledWith(
-        expect.anything(),
-        "This number is not authorized to reach the assistant right now.",
-      );
-      expect(updateCallSession).toHaveBeenCalledWith(
-        "call-verdict-deny-1",
-        expect.objectContaining({ status: "failed" }),
-      );
-      expect(registerCallController).not.toHaveBeenCalled();
-      expect(mockStartInitialGreeting).not.toHaveBeenCalled();
-    });
-  });
 });

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -19,8 +19,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // bindings resolve through the mocks.
 const updateMessageMetadataMock = mock((_id: string, _updates: unknown) => {});
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   updateMessageMetadata: updateMessageMetadataMock,
 }));
 

package/src/__tests__/messaging-send-tool.test.ts

@@ -79,8 +79,6 @@ const getBindingByChannelChatMock = mock(
 );
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   addMessage: addMessageMock,
   getConversation: getConversationMock,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),

package/src/__tests__/migration-import-from-url.test.ts

@@ -421,8 +421,8 @@ describe("handleMigrationImport — JSON {url} body", () => {
 describe("handleMigrationImport — no-swap path omits newer-migration warning", () => {
   test("credentials-only bundle does not inherit live-DB migration warnings", async () => {
     // Seed the live workspace DB with a step:* checkpoint that's NOT
-    // in the known step list. validateMigrationState treats this as a
-    // "newer version" and would otherwise push a warning into the report. With
+    // in the registry. validateMigrationState treats this as a "newer
+    // version" and would otherwise push a warning into the report. With
     // the gate in appendNewerMigrationWarningsIfAny the warning must be
     // suppressed when the import didn't modify the workspace.
     const dbDir = join(testWorkspaceRoot, "data", "db");

package/src/__tests__/mtime-cache.test.ts

@@ -7,7 +7,7 @@
  * cache miss (changed mtime → re-import), plugin deletion (eviction),
  * and hook collection across multiple plugins.
  */
-import { mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, utimesSync,writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -19,8 +19,8 @@ import {
   test,
 } from "bun:test";
 
-import { _inspectHookCacheForTests } from "../hooks/hook-loader.js";
 import {
+  _inspectHookCacheForTests,
   _inspectToolCacheForTests,
   getCachedUserTools,
   getUserHooksFor,
@@ -62,15 +62,7 @@ function writeHook(dir: string, hookName: string, body: string): void {
 function writeInstallMeta(dir: string, installedAt: string): void {
   writeFileSync(
     join(dir, "install-meta.json"),
-    JSON.stringify(
-      {
-        name: "test",
-        installedAt,
-        source: { kind: "github", owner: "test", repo: "test", ref: "main" },
-      },
-      null,
-      2,
-    ),
+    JSON.stringify({ name: "test", installedAt, source: { kind: "github", owner: "test", repo: "test", ref: "main" } }, null, 2),
   );
 }
 
@@ -80,20 +72,6 @@ function writeTool(dir: string, toolName: string, body: string): void {
   writeFileSync(join(toolsDir, `${toolName}.ts`), body);
 }
 
-/** The standalone workspace hooks directory (`<workspace>/hooks/`). */
-const WORKSPACE_HOOKS_DIR = join(ROOT, "hooks");
-
-function ensureWorkspaceHooksDir(): void {
-  rmSync(WORKSPACE_HOOKS_DIR, { recursive: true, force: true });
-  mkdirSync(WORKSPACE_HOOKS_DIR, { recursive: true });
-}
-
-/** Write a standalone hook file directly under `<workspace>/hooks/`. */
-function writeWorkspaceHook(hookName: string, body: string): void {
-  mkdirSync(WORKSPACE_HOOKS_DIR, { recursive: true });
-  writeFileSync(join(WORKSPACE_HOOKS_DIR, `${hookName}.ts`), body);
-}
-
 /**
  * Bump a file's mtime forward by ~2 seconds so the mtime cache detects a
  * change. Using utimesSync avoids race conditions with filesystem mtime
@@ -119,7 +97,6 @@ beforeAll(() => {
 
 beforeEach(() => {
   ensurePluginsDir();
-  ensureWorkspaceHooksDir();
   resetPluginCacheForTests();
 });
 
@@ -361,9 +338,7 @@ describe("plugin mtime cache (per-surface)", () => {
     expect(hooks).toHaveLength(2);
 
     // beta was installed earlier (Jan 1) so it should come first.
-    const results = hooks.map((fn) =>
-      (fn as unknown as () => { tag: string })(),
-    );
+    const results = hooks.map((fn) => (fn as unknown as () => { tag: string })());
     expect(results[0]!.tag).toBe("beta");
     expect(results[1]!.tag).toBe("alpha");
   });
@@ -393,124 +368,8 @@ describe("plugin mtime cache (per-surface)", () => {
     const hooks = await getUserHooksFor("user-prompt-submit");
     expect(hooks).toHaveLength(2);
 
-    const results = hooks.map((fn) =>
-      (fn as unknown as () => { tag: string })(),
-    );
+    const results = hooks.map((fn) => (fn as unknown as () => { tag: string })());
     expect(results[0]!.tag).toBe("dated");
     expect(results[1]!.tag).toBe("undated");
   });
 });
-
-describe("workspace hooks (<workspace>/hooks/)", () => {
-  test("getUserHooksFor loads a standalone workspace hook", async () => {
-    writeWorkspaceHook(
-      "user-prompt-submit",
-      `export default () => ({ ws: 1 });`,
-    );
-
-    await populateCacheAtBoot();
-
-    const hooks = await getUserHooksFor("user-prompt-submit");
-    expect(hooks).toHaveLength(1);
-  });
-
-  test("workspace hooks load even when no plugins directory exists", async () => {
-    rmSync(PLUGINS_DIR, { recursive: true, force: true });
-    writeWorkspaceHook("post-tool-use", `export default () => ({ ws: 1 });`);
-
-    await populateCacheAtBoot();
-
-    const hooks = await getUserHooksFor("post-tool-use");
-    expect(hooks).toHaveLength(1);
-    expect(getCachedUserTools()).toHaveLength(0);
-  });
-
-  // NB: each test below uses a distinct hook event name so the workspace
-  // hook file path is unique. Bun caches dynamic import() by URL and does not
-  // bust on content change, so reusing `<workspace>/hooks/<name>.ts` across
-  // tests would return a stale module (the existing plugin tests dodge this
-  // by using a fresh plugin directory per test).
-  test("plugin hooks run before the workspace hook for the same event", async () => {
-    const dir = freshPluginDir("ordering-plugin");
-    writePackageJson(dir, { ...SIMPLE_PKG, name: "ordering-plugin" });
-    writeHook(
-      dir,
-      "pre-model-call",
-      `export default () => ({ tag: "plugin" });`,
-    );
-    writeWorkspaceHook(
-      "pre-model-call",
-      `export default () => ({ tag: "workspace" });`,
-    );
-
-    await populateCacheAtBoot();
-
-    const hooks = await getUserHooksFor("pre-model-call");
-    expect(hooks).toHaveLength(2);
-    const results = hooks.map((fn) =>
-      (fn as unknown as () => { tag: string })(),
-    );
-    expect(results[0]!.tag).toBe("plugin");
-    expect(results[1]!.tag).toBe("workspace");
-  });
-
-  test("editing a workspace hook file triggers re-import", async () => {
-    const hookFile = join(WORKSPACE_HOOKS_DIR, "post-model-call.ts");
-    writeWorkspaceHook("post-model-call", `export default () => ({ v: 1 });`);
-
-    await populateCacheAtBoot();
-
-    const before = _inspectHookCacheForTests().find((c) =>
-      c.key.startsWith("__workspace__/"),
-    );
-    expect(before).toBeDefined();
-
-    touchFile(hookFile);
-    await getUserHooksFor("post-model-call");
-
-    const after = _inspectHookCacheForTests().find((c) =>
-      c.key.startsWith("__workspace__/"),
-    );
-    expect(after?.sourceMtime).not.toBe(before?.sourceMtime);
-  });
-
-  test("deleting a workspace hook file evicts it on next read", async () => {
-    const hookFile = join(WORKSPACE_HOOKS_DIR, "stop.ts");
-    writeWorkspaceHook("stop", `export default () => ({ v: 1 });`);
-
-    await populateCacheAtBoot();
-    expect(await getUserHooksFor("stop")).toHaveLength(1);
-
-    rmSync(hookFile, { force: true });
-
-    const hooks = await getUserHooksFor("stop");
-    expect(hooks).toHaveLength(0);
-  });
-
-  test("a newly added workspace hook is picked up without restart", async () => {
-    await populateCacheAtBoot();
-    expect(await getUserHooksFor("post-compact")).toHaveLength(0);
-
-    writeWorkspaceHook("post-compact", `export default () => ({ v: 1 });`);
-
-    expect(await getUserHooksFor("post-compact")).toHaveLength(1);
-  });
-
-  test("a workspace init hook runs once at boot", async () => {
-    // The init hook writes a sentinel file so we can observe it ran exactly
-    // once during populateCacheAtBoot.
-    const sentinel = join(ROOT, "ws-init-ran.txt");
-    rmSync(sentinel, { force: true });
-    writeWorkspaceHook(
-      "init",
-      `import { appendFileSync } from "node:fs";
-       export default () => { appendFileSync(${JSON.stringify(sentinel)}, "x"); };`,
-    );
-
-    await populateCacheAtBoot();
-
-    const { readFileSync: rf, existsSync: ex } = await import("node:fs");
-    expect(ex(sentinel)).toBe(true);
-    expect(rf(sentinel, "utf8")).toBe("x");
-  });
-});

package/src/__tests__/native-web-search.test.ts

@@ -95,8 +95,6 @@ mock.module("../config/loader.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: () => null,
   updateMessageContent: () => {},