@vellumai/assistant 0.8.1 → 0.8.3

package/src/__tests__/voice-session-bridge.test.ts

@@ -1183,6 +1183,204 @@ describe("voice-session-bridge", () => {
     expect(handleSecretCalls[0].delivery).toBe("store");
   });
 
+  test("forcePromptSideEffects does not leak when persistUserMessage fails", async () => {
+    const conversation = createConversation(
+      "voice bridge forcePromptSideEffects leak test",
+    );
+
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("simulated persistence failure");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setTrustContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setTurnInterfaceContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: () => {},
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & { forcePromptSideEffects: boolean };
+
+    injectDeps(() => session);
+
+    // Non-guardian voice would normally set forcePromptSideEffects = true.
+    // The setup must fail before that assignment happens so the flag stays
+    // false and cannot leak into subsequent non-voice turns.
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe("simulated persistence failure");
+    expect(session.forcePromptSideEffects).toBe(false);
+  });
+
+  test("turn state does not leak when persistUserMessage fails", async () => {
+    const conversation = createConversation(
+      "voice bridge turn state leak test",
+    );
+
+    const lastSetterValue: Record<string, unknown> = {};
+    const recordLast =
+      (name: string) =>
+      (value: unknown): void => {
+        lastSetterValue[name] = value;
+      };
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("simulated persistence failure");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: recordLast("setChannelCapabilities"),
+      setAssistantId: recordLast("setAssistantId"),
+      setTrustContext: recordLast("setTrustContext"),
+      setCommandIntent: recordLast("setCommandIntent"),
+      setTurnChannelContext: recordLast("setTurnChannelContext"),
+      setTurnInterfaceContext: recordLast("setTurnInterfaceContext"),
+      setVoiceCallControlPrompt: recordLast("setVoiceCallControlPrompt"),
+      updateClient: () => {},
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & {
+      forcePromptSideEffects: boolean;
+      callSessionId?: string;
+    };
+    session.callSessionId = "session-leak-test-precondition";
+
+    injectDeps(() => session);
+
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        voiceSessionId: "session-leak-test",
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe("simulated persistence failure");
+    expect(lastSetterValue.setChannelCapabilities).toBeNull();
+    expect(lastSetterValue.setTrustContext).toBeNull();
+    expect(lastSetterValue.setCommandIntent).toBeNull();
+    expect(lastSetterValue.setAssistantId).toBe("self");
+    expect(lastSetterValue.setVoiceCallControlPrompt).toBeNull();
+    expect(session.callSessionId).toBeUndefined();
+    expect(session.forcePromptSideEffects).toBe(false);
+  });
+
+  test("cleanup on early persistUserMessage throw does not detach prior client sender", async () => {
+    const conversation = createConversation(
+      "voice bridge sender detach guard test",
+    );
+
+    const updateClientCalls: Array<{
+      callback: unknown;
+      replace: boolean | undefined;
+    }> = [];
+
+    const session = {
+      isProcessing: () => false,
+      forcePromptSideEffects: false,
+      callSessionId: undefined as string | undefined,
+      persistUserMessage: async () => {
+        throw new Error("persist failed before bridge installed callback");
+      },
+      memoryPolicy: {
+        scopeId: "default",
+        includeDefaultFallback: false,
+      },
+      setChannelCapabilities: () => {},
+      setAssistantId: () => {},
+      setTrustContext: () => {},
+      setCommandIntent: () => {},
+      setTurnChannelContext: () => {},
+      setTurnInterfaceContext: () => {},
+      setVoiceCallControlPrompt: () => {},
+      updateClient: (callback: unknown, replace?: boolean) => {
+        updateClientCalls.push({ callback, replace });
+      },
+      ensureActorScopedHistory: async () => {},
+      runAgentLoop: async () => {},
+      handleConfirmationResponse: () => {},
+      abort: () => {},
+    } as unknown as Conversation & {
+      forcePromptSideEffects: boolean;
+      callSessionId?: string;
+    };
+
+    injectDeps(() => session);
+
+    let caught: Error | null = null;
+    try {
+      await startVoiceTurn({
+        conversationId: conversation.id,
+        voiceSessionId: "session-sender-detach-test",
+        content: "Hello",
+        isInbound: true,
+        trustContext: {
+          sourceChannel: "phone",
+          trustClass: "trusted_contact",
+        },
+        onTextDelta: () => {},
+        onComplete: () => {},
+        onError: () => {},
+      });
+    } catch (err) {
+      caught = err as Error;
+    }
+
+    expect(caught?.message).toBe(
+      "persist failed before bridge installed callback",
+    );
+    // The bridge never reached its `conversation.updateClient(...)` install
+    // site, so cleanup must not touch updateClient — otherwise it would
+    // detach a sender installed by a prior turn on the same conversation.
+    expect(updateClientCalls).toEqual([]);
+  });
+
   test("pre-aborted signal triggers immediate abort", async () => {
     const conversation = createConversation("voice bridge pre-abort test");
     let abortCalled = false;

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -8,18 +8,20 @@ import {
 } from "../providers/search-provider-catalog.js";
 
 /**
- * Parity guard: daemon TS catalog vs `meta/web-search-provider-catalog.json`.
+ * Parity guard: daemon TS catalog vs the two generated JSON copies.
  *
  * The daemon maintains its canonical search-provider catalog in
  * `assistant/src/providers/search-provider-catalog.ts`.
- * `meta/web-search-provider-catalog.json` is generated by
- * `assistant/scripts/sync-web-search-catalog.ts` and is the cross-package
- * artifact consumed by CLI tests + (eventually) the web-side vendored
- * catalog in `vellum-assistant-platform`.
+ * `assistant/scripts/sync-web-search-catalog.ts` writes two byte-identical
+ * artifacts:
+ *   - `meta/web-search-provider-catalog.json` — primary cross-package artifact.
+ *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
+ *     resource bundled into `VellumAssistantShared` (Swift cannot reach
+ *     files outside a target's source directory).
  *
- * This test enforces structural equality between the two so CI fails when
- * someone edits the TS catalog without regenerating the JSON. Mirrors the
- * pattern from `llm-catalog-parity.test.ts`.
+ * These tests enforce structural equality between the TS catalog and the
+ * meta/ copy, plus byte equality between the meta/ copy and the SwiftPM
+ * mirror. CI fails when any of the three drift.
  */
 
 interface JsonCatalogEntry {
@@ -39,9 +41,19 @@ interface JsonCatalog {
   providers: JsonCatalogEntry[];
 }
 
+const META_JSON_PATH = join(
+  process.cwd(),
+  "..",
+  "meta/web-search-provider-catalog.json",
+);
+const SWIFTPM_MIRROR_PATH = join(
+  process.cwd(),
+  "..",
+  "clients/shared/Resources/web-search-provider-catalog.json",
+);
+
 function loadJsonCatalog(): JsonCatalog {
-  const path = join(process.cwd(), "..", "meta/web-search-provider-catalog.json");
-  return JSON.parse(readFileSync(path, "utf-8"));
+  return JSON.parse(readFileSync(META_JSON_PATH, "utf-8"));
 }
 
 function entryToPlain(
@@ -83,4 +95,14 @@ describe("web-search catalog parity (TS canonical vs meta/ JSON)", () => {
       SEARCH_PROVIDER_CATALOG.map((p) => p.id),
     );
   });
+
+  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
+    // The generator writes both files from the same serializer; this guard
+    // catches any case where one copy is regenerated without the other.
+    // Byte equality is required because SwiftPM bundles the resource verbatim
+    // and the meta/ JSON is consumed as a cross-package artifact.
+    const metaBytes = readFileSync(META_JSON_PATH);
+    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
+    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
+  });
 });

package/src/__tests__/workspace-migration-057-repair-stale-gemini-model-ids.test.ts

@@ -229,9 +229,6 @@ describe("057-repair-stale-gemini-model-ids migration", () => {
             provider: "openrouter",
             model: "gemini-3-flash",
           },
-          recall: {
-            model: "gemini-3-flash",
-          },
         },
         profiles: {
           custom: {
@@ -248,6 +245,28 @@ describe("057-repair-stale-gemini-model-ids migration", () => {
     expect(readFileSync(configPath(), "utf-8")).toBe(before);
   });
 
+  test("rewrites call-site model when site fragment implies Gemini via stale model even when activeProfile is Ollama", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        activeProfile: "ollamaActive",
+        profiles: {
+          ollamaActive: { provider: "ollama", model: "llama-3.1" },
+        },
+        callSites: {
+          recall: { model: "gemini-3-flash" },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { recall: { model: string } } };
+    };
+    expect(config.llm.callSites.recall.model).toBe("gemini-3-flash-preview");
+  });
+
   test("rewrites call-site/profile blocks without local provider when default is Gemini", () => {
     writeConfig({
       llm: {
@@ -275,6 +294,99 @@ describe("057-repair-stale-gemini-model-ids migration", () => {
     expect(config.llm.profiles.balanced.model).toBe("gemini-3-flash-preview");
   });
 
+  test("rewrites call-site model when site.profile resolves to Gemini despite non-Gemini default", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama-3.1" },
+        profiles: {
+          geminiProfile: {
+            provider: "gemini",
+            model: "gemini-3-flash-preview",
+          },
+        },
+        callSites: {
+          memoryRetrieval: {
+            profile: "geminiProfile",
+            model: "gemini-3-flash",
+          },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { memoryRetrieval: { model: string } } };
+    };
+    expect(config.llm.callSites.memoryRetrieval.model).toBe(
+      "gemini-3.1-flash-lite-preview",
+    );
+  });
+
+  test("rewrites call-site model when activeProfile resolves to Gemini despite non-Gemini default", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama-3.1" },
+        activeProfile: "geminiActive",
+        profiles: {
+          geminiActive: { provider: "gemini", model: "gemini-3-flash-preview" },
+        },
+        callSites: {
+          recall: { model: "gemini-3-flash" },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { recall: { model: string } } };
+    };
+    expect(config.llm.callSites.recall.model).toBe("gemini-3-flash-preview");
+  });
+
+  test("does not rewrite call-site model when local provider override beats Gemini activeProfile", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "gemini", model: "gemini-3-flash-preview" },
+        activeProfile: "geminiActive",
+        profiles: {
+          geminiActive: { provider: "gemini", model: "gemini-3-flash-preview" },
+        },
+        callSites: {
+          recall: { provider: "ollama", model: "gemini-3-flash" },
+        },
+      },
+    });
+    const before = readFileSync(configPath(), "utf-8");
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath(), "utf-8")).toBe(before);
+  });
+
+  test("mainAgent: rewrites when activeProfile is Gemini even if callSites.mainAgent.provider is non-Gemini", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "ollama", model: "llama-3.1" },
+        activeProfile: "geminiActive",
+        profiles: {
+          geminiActive: { provider: "gemini", model: "gemini-3-flash-preview" },
+        },
+        callSites: {
+          mainAgent: { provider: "ollama", model: "gemini-3-flash" },
+        },
+      },
+    });
+
+    repairStaleGeminiModelIdsMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: { mainAgent: { model: string } } };
+    };
+    expect(config.llm.callSites.mainAgent.model).toBe("gemini-3-flash-preview");
+  });
+
   test("no-ops when config.json is missing or invalid", () => {
     repairStaleGeminiModelIdsMigration.run(workspaceDir);
     expect(existsSync(configPath())).toBe(false);

package/src/__tests__/workspace-migration-072-seed-reply-suggestion-callsite.test.ts

@@ -106,6 +106,56 @@ describe("072-seed-reply-suggestion-callsite migration", () => {
     });
   });
 
+  test("carries forward customized conversationStarters override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        callSites: {
+          conversationStarters: {
+            model: "claude-opus-4-7",
+            effort: "high",
+            thinking: { enabled: true },
+          },
+        },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "claude-opus-4-7",
+      effort: "high",
+      thinking: { enabled: true },
+    });
+  });
+
+  test("carries forward conversationStarters even on non-Anthropic provider", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+        callSites: {
+          conversationStarters: {
+            model: "gpt-5.4-mini",
+            effort: "low",
+          },
+        },
+      },
+    });
+
+    seedReplySuggestionCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.replySuggestion).toEqual({
+      model: "gpt-5.4-mini",
+      effort: "low",
+    });
+  });
+
   test("skips when replySuggestion already has an explicit override", () => {
     writeConfig({
       llm: {

package/src/__tests__/workspace-migration-073-repair-recall-callsite-empty-profile.test.ts

@@ -0,0 +1,153 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRecallCallsiteEmptyProfileMigration } from "../workspace/migrations/073-repair-recall-callsite-empty-profile.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-073-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("073-repair-recall-callsite-empty-profile migration", () => {
+  test("has correct migration id", () => {
+    expect(repairRecallCallsiteEmptyProfileMigration.id).toBe(
+      "073-repair-recall-callsite-empty-profile",
+    );
+  });
+
+  test("rewrites empty-profile recall to use cheap model on anthropic workspace", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: { "cost-optimized": {} },
+        callSites: { recall: { profile: "cost-optimized" } },
+      },
+    });
+
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.recall).toEqual({
+      model: "claude-haiku-4-5-20251001",
+    });
+  });
+
+  test("preserves existing user-defined recall.model override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+        profiles: { "cost-optimized": {} },
+        callSites: {
+          recall: {
+            profile: "cost-optimized",
+            model: "claude-opus-4-7",
+          },
+        },
+      },
+    });
+
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    // Broken profile pointer is removed, but user's model value is preserved.
+    expect(config.llm.callSites.recall).toEqual({
+      model: "claude-opus-4-7",
+    });
+  });
+
+  test("leaves recall alone when cost-optimized profile has a real model", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: {
+          "cost-optimized": { model: "claude-haiku-4-5-20251001" },
+        },
+        callSites: { recall: { profile: "cost-optimized" } },
+      },
+    });
+
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.recall).toEqual({ profile: "cost-optimized" });
+  });
+
+  test("uses provider-appropriate cheap model for openrouter", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter" },
+        profiles: { "cost-optimized": {} },
+        callSites: { recall: { profile: "cost-optimized" } },
+      },
+    });
+
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.recall).toEqual({
+      model: "anthropic/claude-haiku-4.5",
+    });
+  });
+
+  test("is idempotent — second run is a no-op", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        profiles: { "cost-optimized": {} },
+        callSites: { recall: { profile: "cost-optimized" } },
+      },
+    });
+
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+    const afterFirst = readFileSync(join(workspaceDir, "config.json"), "utf-8");
+    repairRecallCallsiteEmptyProfileMigration.run(workspaceDir);
+    const afterSecond = readFileSync(
+      join(workspaceDir, "config.json"),
+      "utf-8",
+    );
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+});