@vellumai/assistant 0.4.54 → 0.4.56

package/src/__tests__/provider-fail-open-selection.test.ts

@@ -29,6 +29,7 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
+import type { ProvidersConfig } from "../providers/registry.js";
 import {
   getFailoverProvider,
   getProviderRoutingSource,
@@ -44,22 +45,30 @@ import { ProviderNotConfiguredError } from "../util/errors.js";
  * available provider in the provider order.
  */
 
+function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
+  return {
+    services: {
+      inference: { mode: "your-own", provider, model },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-2.5-flash-image",
+      },
+      "web-search": { mode: "your-own", provider: "anthropic-native" },
+    },
+  };
+}
+
 /** Initialize registry with anthropic + openai for most tests. */
 async function setupTwoProviders() {
   mockProviderKeys = { anthropic: "test-key", openai: "test-key" };
-  await initializeProviders({
-    provider: "anthropic",
-    model: "test-model",
-  });
+  await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
 }
 
 /** Initialize registry with no providers (empty keys, non-registerable primary). */
 async function setupNoProviders() {
   mockProviderKeys = {};
-  await initializeProviders({
-    provider: "gemini",
-    model: "test-model",
-  });
+  await initializeProviders(makeProvidersConfig("gemini", "test-model"));
 }
 
 describe("resolveProviderSelection", () => {
@@ -186,10 +195,7 @@ describe("managed proxy fallback", () => {
     enableManagedProxy();
     try {
       mockProviderKeys = { anthropic: "test-key" };
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       expect(registered).toEqual(["anthropic", "gemini"]);
     } finally {
@@ -201,10 +207,7 @@ describe("managed proxy fallback", () => {
     enableManagedProxy();
     try {
       mockProviderKeys = { anthropic: "test-key", openai: "user-openai-key" };
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("openai");
       expect(registered).toContain("anthropic");
@@ -219,10 +222,7 @@ describe("managed proxy fallback", () => {
   test("managed fallback not activated when proxy context is disabled", async () => {
     disableManagedProxy();
     mockProviderKeys = { anthropic: "test-key" };
-    await initializeProviders({
-      provider: "anthropic",
-      model: "test-model",
-    });
+    await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
     const registered = listProviders();
     // Anthropic is registered via user-key, not managed proxy.
     expect(registered).toContain("anthropic");
@@ -238,10 +238,7 @@ describe("managed proxy fallback", () => {
     enableManagedProxy();
     try {
       mockProviderKeys = { anthropic: "test-key" };
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const selection = resolveProviderSelection("anthropic", [
         "openai",
         "gemini",
@@ -260,10 +257,7 @@ describe("managed proxy fallback", () => {
     try {
       // No anthropic key, no gemini key — only managed providers available
       mockProviderKeys = {};
-      await initializeProviders({
-        provider: "openai",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("openai", "test-model"));
       const selection = resolveProviderSelection("openai", [
         "gemini",
         "anthropic",

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -54,6 +54,7 @@ mock.module("../security/secure-keys.js", () => ({
   },
 }));
 
+import type { ProvidersConfig } from "../providers/registry.js";
 import {
   getProvider,
   getProviderRoutingSource,
@@ -61,6 +62,20 @@ import {
   listProviders,
 } from "../providers/registry.js";
 
+function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
+  return {
+    services: {
+      inference: { mode: "your-own", provider, model },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-2.5-flash-image",
+      },
+      "web-search": { mode: "your-own", provider: "anthropic-native" },
+    },
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -114,10 +129,7 @@ describe("managed proxy integration — credential precedence", () => {
       async (provider: string) => {
         enableManagedProxy();
         setUserKeysFor(provider);
-        await initializeProviders({
-          provider,
-          model: "test-model",
-        });
+        await initializeProviders(makeProvidersConfig(provider, "test-model"));
         expect(listProviders()).toContain(provider);
         expect(getProviderRoutingSource(provider)).toBe("user-key");
       },
@@ -126,10 +138,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("all five configured providers route via user-key when user keys exist", async () => {
       enableManagedProxy();
       setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       for (const p of DIRECT_OR_MANAGED_PROVIDER_KEYS) {
         expect(registered).toContain(p);
@@ -140,10 +149,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("user keys still route via user-key when managed context is disabled", async () => {
       disableManagedProxy();
       setUserKeysFor(...DIRECT_OR_MANAGED_PROVIDER_KEYS);
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       for (const p of DIRECT_OR_MANAGED_PROVIDER_KEYS) {
         expect(registered).toContain(p);
@@ -158,10 +164,9 @@ describe("managed proxy integration — credential precedence", () => {
       async (provider: string) => {
         enableManagedProxy();
         mockProviderKeys = {};
-        await initializeProviders({
-          provider: "anthropic",
-          model: "test-model",
-        });
+        await initializeProviders(
+          makeProvidersConfig("anthropic", "test-model"),
+        );
         expect(listProviders()).toContain(provider);
         expect(getProviderRoutingSource(provider)).toBe("managed-proxy");
       },
@@ -170,10 +175,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("managed bootstrap registers anthropic and gemini only", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual(["anthropic", "gemini"]);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
@@ -185,10 +187,9 @@ describe("managed proxy integration — credential precedence", () => {
     test("managed anthropic uses anthropic proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
-      await initializeProviders({
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-      });
+      await initializeProviders(
+        makeProvidersConfig("anthropic", "claude-opus-4-6"),
+      );
 
       const provider = getProvider("anthropic");
 
@@ -208,10 +209,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("managed gemini uses vertex proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
 
       expect(lastGeminiConstructorOpts).toBeDefined();
       const httpOptions = lastGeminiConstructorOpts!.httpOptions as
@@ -229,10 +227,9 @@ describe("managed proxy integration — credential precedence", () => {
       async (provider: string) => {
         disableManagedProxy();
         mockProviderKeys = {};
-        await initializeProviders({
-          provider: "anthropic",
-          model: "test-model",
-        });
+        await initializeProviders(
+          makeProvidersConfig("anthropic", "test-model"),
+        );
         expect(listProviders()).not.toContain(provider);
         expect(getProviderRoutingSource(provider)).toBeUndefined();
       },
@@ -241,10 +238,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("registry is empty when no keys and no managed context (non-ollama primary)", async () => {
       disableManagedProxy();
       mockProviderKeys = {};
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       expect(listProviders()).toEqual([]);
     });
   });
@@ -253,10 +247,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("user key for anthropic routes direct and managed fallback only fills gemini", async () => {
       enableManagedProxy();
       setUserKeysFor("anthropic");
-      await initializeProviders({
-        provider: "anthropic",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("anthropic");
       expect(getProviderRoutingSource("anthropic")).toBe("user-key");
@@ -271,10 +262,7 @@ describe("managed proxy integration — credential precedence", () => {
     test("user key for openai routes direct while anthropic and gemini still bootstrap via managed proxy", async () => {
       enableManagedProxy();
       setUserKeysFor("openai");
-      await initializeProviders({
-        provider: "openai",
-        model: "test-model",
-      });
+      await initializeProviders(makeProvidersConfig("openai", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("openai");
       expect(getProviderRoutingSource("openai")).toBe("user-key");
@@ -294,30 +282,21 @@ describe("managed proxy integration — ollama exclusion", () => {
   test("ollama is never registered via managed proxy fallback", async () => {
     enableManagedProxy();
     mockProviderKeys = {};
-    await initializeProviders({
-      provider: "anthropic",
-      model: "test-model",
-    });
+    await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
     expect(listProviders()).not.toContain("ollama");
   });
 
   test("ollama registers only when explicitly configured as provider", async () => {
     enableManagedProxy();
     mockProviderKeys = {};
-    await initializeProviders({
-      provider: "ollama",
-      model: "test-model",
-    });
+    await initializeProviders(makeProvidersConfig("ollama", "test-model"));
     expect(listProviders()).toContain("ollama");
   });
 
   test("ollama registers with explicit API key", async () => {
     enableManagedProxy();
     mockProviderKeys = { ollama: "ollama-key" };
-    await initializeProviders({
-      provider: "anthropic",
-      model: "test-model",
-    });
+    await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
     expect(listProviders()).toContain("ollama");
   });
 

package/src/__tests__/provider-registry-ollama.test.ts

@@ -16,8 +16,19 @@ import {
 describe("provider registry (ollama)", () => {
   test("registers ollama when selected provider has no API key", async () => {
     await initializeProviders({
-      provider: "ollama",
-      model: "claude-opus-4-6",
+      services: {
+        inference: {
+          mode: "your-own",
+          provider: "ollama",
+          model: "claude-opus-4-6",
+        },
+        "image-generation": {
+          mode: "your-own",
+          provider: "gemini",
+          model: "gemini-2.5-flash-image",
+        },
+        "web-search": { mode: "your-own", provider: "anthropic-native" },
+      },
     });
 
     const provider = getProvider("ollama");

package/src/__tests__/proxy-approval-callback.test.ts

@@ -44,8 +44,8 @@ mock.module("../security/redaction.js", () => ({
 // Import after mocks are registered.
 // ---------------------------------------------------------------------------
 
-import type { ToolSetupContext } from "../daemon/session-tool-setup.js";
-import { createProxyApprovalCallback } from "../daemon/session-tool-setup.js";
+import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import { createProxyApprovalCallback } from "../daemon/conversation-tool-setup.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/recording-handler.test.ts

@@ -50,7 +50,7 @@ const mockMessages: Array<{ id: string; role: string; content: string }> = [];
 let mockMessageIdCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationThreadType: () => "default",
+  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -166,7 +166,7 @@ function createCtx(): {
   const sent: Array<{ type: string; [k: string]: unknown }> = [];
 
   const ctx: HandlerContext = {
-    sessions: new Map(),
+    conversations: new Map(),
     sharedRequestTimestamps: [],
     debounceTimers: new DebouncerMap({ defaultDelayMs: 200 }),
     suppressConfigReload: false,
@@ -178,11 +178,11 @@ function createCtx(): {
     broadcast: (msg) => {
       sent.push(msg as { type: string; [k: string]: unknown });
     },
-    clearAllSessions: () => 0,
-    getOrCreateSession: () => {
+    clearAllConversations: () => 0,
+    getOrCreateConversation: () => {
       throw new Error("not implemented");
     },
-    touchSession: noop,
+    touchConversation: noop,
   };
 
   return { ctx, sent };
@@ -352,7 +352,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "started",
     };
 
@@ -379,7 +379,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: `${ALLOWED_RECORDINGS_DIR}/recording.mov`,
       durationMs: 5000,
@@ -395,7 +395,7 @@ describe("handleRecordingStatusCore", () => {
 
     // The message_complete should include attachment info
     const completeMsg = completes[0];
-    expect(completeMsg.sessionId).toBe(conversationId);
+    expect(completeMsg.conversationId).toBe(conversationId);
 
     // Attachment should have been created
     expect(mockAttachments.length).toBe(1);
@@ -421,7 +421,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: `${ALLOWED_RECORDINGS_DIR}/recording.mp4`,
       durationMs: 3000,
@@ -447,7 +447,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: `${ALLOWED_RECORDINGS_DIR}/nonexistent.mov`,
       durationMs: 1000,
@@ -466,7 +466,7 @@ describe("handleRecordingStatusCore", () => {
 
     const completes = sent.filter((m) => m.type === "message_complete");
     expect(completes.length).toBeGreaterThanOrEqual(1);
-    expect(completes[0].sessionId).toBe(conversationId);
+    expect(completes[0].conversationId).toBe(conversationId);
   });
 
   test("handles stopped status with zero-length file — treated as failure", async () => {
@@ -482,7 +482,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: `${ALLOWED_RECORDINGS_DIR}/recording-empty.mov`,
       durationMs: 2000,
@@ -507,7 +507,7 @@ describe("handleRecordingStatusCore", () => {
 
     const completes = sent.filter((m) => m.type === "message_complete");
     expect(completes.length).toBeGreaterThanOrEqual(1);
-    expect(completes[0].sessionId).toBe(conversationId);
+    expect(completes[0].conversationId).toBe(conversationId);
   });
 
   test("successful finalization — attachment created and success message sent", async () => {
@@ -523,7 +523,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: `${ALLOWED_RECORDINGS_DIR}/recording-good.mov`,
       durationMs: 5000,
@@ -560,7 +560,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "stopped",
       filePath: "/tmp/evil.mov",
       durationMs: 5000,
@@ -580,7 +580,7 @@ describe("handleRecordingStatusCore", () => {
 
     const completes = sent.filter((m) => m.type === "message_complete");
     expect(completes.length).toBeGreaterThanOrEqual(1);
-    expect(completes[0].sessionId).toBe(conversationId);
+    expect(completes[0].conversationId).toBe(conversationId);
   });
 
   test("failed finalization — failure status sent and no success message", async () => {
@@ -594,7 +594,7 @@ describe("handleRecordingStatusCore", () => {
     // Client reports failure (writer finalization error)
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "failed",
       error: "Video writer finished with non-completed status 3",
     };
@@ -627,7 +627,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "failed",
       error: "Permission denied",
     };
@@ -654,7 +654,7 @@ describe("handleRecordingStatusCore", () => {
 
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: recordingId!,
+      conversationId: recordingId!,
       status: "failed",
     };
 
@@ -673,7 +673,7 @@ describe("handleRecordingStatusCore", () => {
     // without having started a recording through handleRecordingStart
     const statusMsg: RecordingStatus = {
       type: "recording_status",
-      sessionId: "unknown-recording-id",
+      conversationId: "unknown-recording-id",
       status: "failed",
       error: "Something went wrong",
       attachToConversationId: conversationId,

package/src/__tests__/relay-server.test.ts

@@ -366,7 +366,7 @@ describe("relay-server", () => {
     mockConfig.calls.verification.codeLength = 6;
     mockConfig.calls.callerIdentity.userNumber = undefined;
     setVoiceBridgeDeps({
-      getOrCreateSession: async (conversationId) => {
+      getOrCreateConversation: async (conversationId) => {
         const session = {
           callSessionId: undefined as string | undefined,
           currentRequestId: undefined as string | undefined,
@@ -410,7 +410,7 @@ describe("relay-server", () => {
             _messageId: string,
             onEvent: (event: {
               type: string;
-              sessionId?: string;
+              conversationId?: string;
               text?: string;
             }) => void,
           ) => {
@@ -425,7 +425,7 @@ describe("relay-server", () => {
                 tokens.push(event.text);
                 onEvent({
                   type: "assistant_text_delta",
-                  sessionId: conversationId,
+                  conversationId: conversationId,
                   text: event.text,
                 });
               },
@@ -446,10 +446,13 @@ describe("relay-server", () => {
               );
             }
 
-            onEvent({ type: "message_complete", sessionId: conversationId });
+            onEvent({
+              type: "message_complete",
+              conversationId: conversationId,
+            });
           },
         };
-        return session as unknown as import("../daemon/session.js").Session;
+        return session as unknown as import("../daemon/conversation.js").Conversation;
       },
       resolveAttachments: () => [],
       deriveDefaultStrictSideEffects: () => false,