@vellumai/assistant 0.4.44 → 0.4.45

package/src/__tests__/cross-provider-web-search.test.ts

@@ -0,0 +1,353 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ContentBlock, Message } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function userMsg(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+/** A conversation with web search blocks in history (as Anthropic would produce). */
+function webSearchConversation(): Message[] {
+  return [
+    userMsg("Search for something"),
+    {
+      role: "assistant",
+      content: [
+        {
+          type: "server_tool_use",
+          id: "stu_abc123",
+          name: "web_search",
+          input: { query: "test query" },
+        } satisfies ContentBlock,
+        {
+          type: "text",
+          text: "Here are the results.",
+        } satisfies ContentBlock,
+      ],
+    },
+    {
+      role: "user",
+      content: [
+        {
+          type: "web_search_tool_result",
+          tool_use_id: "stu_abc123",
+          content: [
+            {
+              type: "web_search_result",
+              url: "https://example.com",
+              title: "Example",
+              encrypted_content: "enc_abc",
+            },
+          ],
+        } satisfies ContentBlock,
+      ],
+    },
+    userMsg("Thanks, now do something else"),
+  ];
+}
+
+/** A message containing only a web_search_tool_result block (edge case). */
+function webSearchResultOnlyMessage(): Message[] {
+  return [
+    userMsg("Search for something"),
+    {
+      role: "assistant",
+      content: [
+        {
+          type: "server_tool_use",
+          id: "stu_only",
+          name: "web_search",
+          input: { query: "lonely query" },
+        } satisfies ContentBlock,
+      ],
+    },
+    {
+      role: "user",
+      content: [
+        {
+          type: "web_search_tool_result",
+          tool_use_id: "stu_only",
+          content: [
+            {
+              type: "web_search_result",
+              url: "https://example.com",
+              title: "Example",
+              encrypted_content: "enc_xyz",
+            },
+          ],
+        } satisfies ContentBlock,
+      ],
+    },
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Mock OpenAI SDK
+// ---------------------------------------------------------------------------
+
+let lastOpenAIParams: Record<string, unknown> | null = null;
+
+mock.module("openai", () => {
+  class FakeAPIError extends Error {
+    status: number;
+    headers: Record<string, string>;
+    constructor(status: number, message: string) {
+      super(message);
+      this.status = status;
+      this.headers = {};
+      this.name = "APIError";
+    }
+  }
+
+  return {
+    default: class MockOpenAI {
+      static APIError = FakeAPIError;
+      constructor(_args: Record<string, unknown>) {}
+      chat = {
+        completions: {
+          create: (params: Record<string, unknown>) => {
+            lastOpenAIParams = JSON.parse(JSON.stringify(params));
+            return (async function* () {
+              yield {
+                choices: [
+                  {
+                    delta: { content: "OK" },
+                    finish_reason: "stop",
+                  },
+                ],
+                usage: { prompt_tokens: 10, completion_tokens: 5 },
+                model: "gpt-4o",
+              };
+            })();
+          },
+        },
+      };
+    },
+  };
+});
+
+// ---------------------------------------------------------------------------
+// Mock Gemini SDK
+// ---------------------------------------------------------------------------
+
+let lastGeminiParams: Record<string, unknown> | null = null;
+
+mock.module("@google/genai", () => {
+  class FakeApiError extends Error {
+    status: number;
+    constructor(status: number, message: string) {
+      super(message);
+      this.status = status;
+      this.name = "ApiError";
+    }
+  }
+
+  return {
+    ApiError: FakeApiError,
+    GoogleGenAI: class MockGoogleGenAI {
+      constructor(_args: Record<string, unknown>) {}
+      models = {
+        generateContentStream: (params: Record<string, unknown>) => {
+          lastGeminiParams = JSON.parse(JSON.stringify(params));
+          return (async function* () {
+            yield {
+              text: "OK",
+              candidates: [{ finishReason: "STOP" }],
+              usageMetadata: {
+                promptTokenCount: 10,
+                candidatesTokenCount: 5,
+              },
+              modelVersion: "gemini-2.0-flash",
+            };
+          })();
+        },
+      };
+    },
+  };
+});
+
+// Import providers after mocking
+import { GeminiProvider } from "../providers/gemini/client.js";
+import { OpenAIProvider } from "../providers/openai/client.js";
+
+// ---------------------------------------------------------------------------
+// OpenAI provider tests
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — OpenAI", () => {
+  beforeEach(() => {
+    lastOpenAIParams = null;
+  });
+
+  test("degrades server_tool_use in assistant message to text placeholder", async () => {
+    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const messages = lastOpenAIParams!.messages as Array<{
+      role: string;
+      content: unknown;
+    }>;
+
+    const assistantMsg = messages.find((m) => m.role === "assistant");
+    expect(assistantMsg).toBeDefined();
+    expect(assistantMsg!.content).toContain("[Web search: web_search]");
+    expect(assistantMsg!.content).toContain("Here are the results.");
+  });
+
+  test("degrades web_search_tool_result in user message to text placeholder", async () => {
+    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const messages = lastOpenAIParams!.messages as Array<{
+      role: string;
+      content: unknown;
+    }>;
+
+    const userMsgs = messages.filter((m) => m.role === "user");
+    const hasWebSearchResult = userMsgs.some((m) => {
+      if (typeof m.content === "string") return false;
+      if (Array.isArray(m.content)) {
+        return (m.content as Array<{ type: string; text?: string }>).some(
+          (part) =>
+            part.type === "text" && part.text === "[Web search results]",
+        );
+      }
+      return false;
+    });
+    expect(hasWebSearchResult).toBe(true);
+  });
+
+  test("handles message containing only web_search_tool_result", async () => {
+    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchResultOnlyMessage());
+
+    const messages = lastOpenAIParams!.messages as Array<{
+      role: string;
+      content: unknown;
+    }>;
+
+    const assistantMsg = messages.find((m) => m.role === "assistant");
+    expect(assistantMsg).toBeDefined();
+    expect(assistantMsg!.content).toContain("[Web search: web_search]");
+
+    const userMsgs = messages.filter((m) => m.role === "user");
+    const hasWebSearchResult = userMsgs.some((m) => {
+      if (typeof m.content === "string") return false;
+      if (Array.isArray(m.content)) {
+        return (m.content as Array<{ type: string; text?: string }>).some(
+          (part) =>
+            part.type === "text" && part.text === "[Web search results]",
+        );
+      }
+      return false;
+    });
+    expect(hasWebSearchResult).toBe(true);
+  });
+
+  test("does not produce tool_calls for server_tool_use blocks", async () => {
+    const provider = new OpenAIProvider("sk-test", "gpt-4o");
+    await provider.sendMessage(webSearchConversation());
+
+    const messages = lastOpenAIParams!.messages as Array<{
+      role: string;
+      tool_calls?: unknown[];
+    }>;
+
+    const assistantMsg = messages.find((m) => m.role === "assistant");
+    expect(assistantMsg).toBeDefined();
+    expect(assistantMsg!.tool_calls).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Gemini provider tests
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — Gemini", () => {
+  beforeEach(() => {
+    lastGeminiParams = null;
+  });
+
+  test("degrades server_tool_use in model message to text placeholder", async () => {
+    const provider = new GeminiProvider("key-test", "gemini-2.0-flash");
+    await provider.sendMessage(webSearchConversation());
+
+    const contents = lastGeminiParams!.contents as Array<{
+      role: string;
+      parts: Array<{ text?: string; functionCall?: unknown }>;
+    }>;
+
+    const modelContent = contents.find((c) => c.role === "model");
+    expect(modelContent).toBeDefined();
+
+    const webSearchPart = modelContent!.parts.find(
+      (p) => p.text === "[Web search: web_search]",
+    );
+    expect(webSearchPart).toBeDefined();
+
+    const textPart = modelContent!.parts.find(
+      (p) => p.text === "Here are the results.",
+    );
+    expect(textPart).toBeDefined();
+  });
+
+  test("degrades web_search_tool_result in user message to text placeholder", async () => {
+    const provider = new GeminiProvider("key-test", "gemini-2.0-flash");
+    await provider.sendMessage(webSearchConversation());
+
+    const contents = lastGeminiParams!.contents as Array<{
+      role: string;
+      parts: Array<{ text?: string }>;
+    }>;
+
+    const userContents = contents.filter((c) => c.role === "user");
+    const hasWebSearchResult = userContents.some((c) =>
+      c.parts.some((p) => p.text === "[Web search results]"),
+    );
+    expect(hasWebSearchResult).toBe(true);
+  });
+
+  test("handles message containing only web_search_tool_result", async () => {
+    const provider = new GeminiProvider("key-test", "gemini-2.0-flash");
+    await provider.sendMessage(webSearchResultOnlyMessage());
+
+    const contents = lastGeminiParams!.contents as Array<{
+      role: string;
+      parts: Array<{ text?: string; functionCall?: unknown }>;
+    }>;
+
+    const modelContent = contents.find((c) => c.role === "model");
+    expect(modelContent).toBeDefined();
+    const webSearchPart = modelContent!.parts.find(
+      (p) => p.text === "[Web search: web_search]",
+    );
+    expect(webSearchPart).toBeDefined();
+
+    const userContents = contents.filter((c) => c.role === "user");
+    const hasWebSearchResult = userContents.some((c) =>
+      c.parts.some((p) => p.text === "[Web search results]"),
+    );
+    expect(hasWebSearchResult).toBe(true);
+  });
+
+  test("does not produce functionCall parts for server_tool_use blocks", async () => {
+    const provider = new GeminiProvider("key-test", "gemini-2.0-flash");
+    await provider.sendMessage(webSearchConversation());
+
+    const contents = lastGeminiParams!.contents as Array<{
+      role: string;
+      parts: Array<{ text?: string; functionCall?: unknown }>;
+    }>;
+
+    const modelContent = contents.find((c) => c.role === "model");
+    expect(modelContent).toBeDefined();
+    const functionCallParts = modelContent!.parts.filter(
+      (p) => p.functionCall !== undefined,
+    );
+    expect(functionCallParts).toHaveLength(0);
+  });
+});

package/src/__tests__/daemon-assistant-events.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests that daemon IPC outbound messages are mirrored into the
+ * Tests that daemon outbound messages are mirrored into the
  * assistant-events hub as AssistantEvent objects.
  *
  * Tests:
@@ -10,7 +10,6 @@ import { describe, expect, mock, test } from "bun:test";
 
 // ── Platform mock (must happen before imports that read it) ─────────────────
 mock.module("../util/platform.js", () => ({
-  getSocketPath: () => "/tmp/test-daemon-events.sock",
   getSessionTokenPath: () => "/tmp/test-token",
   getRootDir: () => "/tmp/test",
   getDataDir: () => "/tmp/test",
@@ -85,7 +84,7 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_ipc" }, (e) => {
+    hub.subscribe({ assistantId: "ast_test" }, (e) => {
       received.push(e);
     });
 
@@ -94,11 +93,11 @@ describe("daemon send → one mirrored assistant event", () => {
       sessionId: "sess_a",
       text: "hello",
     };
-    const event = buildAssistantEvent("ast_ipc", msg, "sess_a");
+    const event = buildAssistantEvent("ast_test", msg, "sess_a");
     await hub.publish(event);
 
     expect(received).toHaveLength(1);
-    expect(received[0].assistantId).toBe("ast_ipc");
+    expect(received[0].assistantId).toBe("ast_test");
     expect(received[0].sessionId).toBe("sess_a");
     expect(received[0].message.type).toBe("assistant_text_delta");
   });
@@ -107,12 +106,12 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_ipc" }, (e) => {
+    hub.subscribe({ assistantId: "ast_test" }, (e) => {
       received.push(e);
     });
 
     const msg: ServerMessage = { type: "pong" }; // no sessionId field
-    const event = buildAssistantEvent("ast_ipc", msg, "sess_explicit");
+    const event = buildAssistantEvent("ast_test", msg, "sess_explicit");
 
     await hub.publish(event);
 

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -28,7 +28,7 @@ describe("schedule_syntax column migration", () => {
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
+        cron_expression TEXT,
         schedule_syntax TEXT NOT NULL DEFAULT 'cron',
         timezone TEXT,
         message TEXT NOT NULL,
@@ -37,6 +37,10 @@ describe("schedule_syntax column migration", () => {
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
         created_by TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'execute',
+        routing_intent TEXT NOT NULL DEFAULT 'all_channels',
+        routing_hints_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       )
@@ -80,7 +84,7 @@ describe("schedule_syntax column migration", () => {
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
+        cron_expression TEXT,
         timezone TEXT,
         message TEXT NOT NULL,
         next_run_at INTEGER NOT NULL,
@@ -88,6 +92,10 @@ describe("schedule_syntax column migration", () => {
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
         created_by TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'execute',
+        routing_intent TEXT NOT NULL DEFAULT 'all_channels',
+        routing_hints_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       )
@@ -125,7 +133,7 @@ describe("schedule_syntax column migration", () => {
         id TEXT PRIMARY KEY,
         name TEXT NOT NULL,
         enabled INTEGER NOT NULL DEFAULT 1,
-        cron_expression TEXT NOT NULL,
+        cron_expression TEXT,
         timezone TEXT,
         message TEXT NOT NULL,
         next_run_at INTEGER NOT NULL,
@@ -133,6 +141,10 @@ describe("schedule_syntax column migration", () => {
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
         created_by TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'execute',
+        routing_intent TEXT NOT NULL DEFAULT 'all_channels',
+        routing_hints_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       )

package/src/__tests__/delete-managed-skill-tool.test.ts

@@ -24,13 +24,9 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { DeleteManagedSkillTool } from "../tools/skills/delete-managed.js";
+import { executeDeleteManagedSkill } from "../tools/skills/delete-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
-const tool = new (DeleteManagedSkillTool as any)() as InstanceType<
-  typeof DeleteManagedSkillTool
->;
-
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -69,7 +65,7 @@ describe("delete_managed_skill tool", () => {
     createSkill("doomed");
     createSkill("survivor");
 
-    const result = await tool.execute(
+    const result = await executeDeleteManagedSkill(
       {
         skill_id: "doomed",
       },
@@ -93,7 +89,7 @@ describe("delete_managed_skill tool", () => {
   });
 
   test("returns error for non-existent skill", async () => {
-    const result = await tool.execute(
+    const result = await executeDeleteManagedSkill(
       {
         skill_id: "ghost",
       },
@@ -105,13 +101,13 @@ describe("delete_managed_skill tool", () => {
   });
 
   test("rejects missing skill_id", async () => {
-    const result = await tool.execute({}, makeContext());
+    const result = await executeDeleteManagedSkill({}, makeContext());
     expect(result.isError).toBe(true);
     expect(result.content).toContain("skill_id is required");
   });
 
   test("rejects invalid skill_id", async () => {
-    const result = await tool.execute(
+    const result = await executeDeleteManagedSkill(
       {
         skill_id: "../escape",
       },

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -26,7 +26,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),