@vellumai/assistant 0.6.4 → 0.6.5

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

@@ -58,9 +58,9 @@ describe("Workspace top-level context — injection", () => {
 });
 
 describe("applyRuntimeInjections — workspace top-level context", () => {
-  test("injects workspace context when provided", () => {
+  test("injects workspace context when provided", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       workspaceTopLevelContext: sampleContext,
     });
 
@@ -70,9 +70,9 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     expect((result[0].content[1] as { text: string }).text).toBe("Hello");
   });
 
-  test("does not inject when workspace context is null", () => {
+  test("does not inject when workspace context is null", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       workspaceTopLevelContext: null,
     });
 
@@ -80,9 +80,9 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
     expect(result[0].content).toHaveLength(1);
   });
 
-  test("workspace context appears before active surface context in content", () => {
+  test("workspace context appears before active surface context in content", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
       workspaceTopLevelContext: sampleContext,
     });
@@ -100,9 +100,9 @@ describe("applyRuntimeInjections — workspace top-level context", () => {
 });
 
 describe("applyRuntimeInjections — minimal mode skips workspace blocks", () => {
-  test("minimal mode skips workspace top-level context", () => {
+  test("minimal mode skips workspace top-level context", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       workspaceTopLevelContext: sampleContext,
       mode: "minimal",
     });
@@ -112,9 +112,9 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
     expect((result[0].content[0] as { text: string }).text).toBe("Hello");
   });
 
-  test("minimal mode skips active surface context", () => {
+  test("minimal mode skips active surface context", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
       mode: "minimal",
     });
@@ -124,9 +124,9 @@ describe("applyRuntimeInjections — minimal mode skips workspace blocks", () =>
     expect((result[0].content[0] as { text: string }).text).toBe("Hello");
   });
 
-  test("full mode (default) still includes workspace blocks", () => {
+  test("full mode (default) still includes workspace blocks", async () => {
     const messages: Message[] = [userMsg("Hello")];
-    const result = applyRuntimeInjections(messages, {
+    const { messages: result } = await applyRuntimeInjections(messages, {
       workspaceTopLevelContext: sampleContext,
       activeSurface: { surfaceId: "sf_1", html: "<div>test</div>" },
     });

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

@@ -10,12 +10,7 @@ import type {
   ToolUseContent,
 } from "../providers/types.js";
 import type { Tool } from "../tools/types.js";
-import {
-  assertBrowserToolsAbsent,
-  assertBrowserToolsPresent,
-  BROWSER_TOOL_NAMES,
-  buildSkillLoadHistory,
-} from "./test-support/browser-skill-harness.js";
+import { buildSkillLoadHistory } from "./test-support/browser-skill-harness.js";
 
 // ---------------------------------------------------------------------------
 // Mock state — controlled by tests
@@ -1652,71 +1647,6 @@ describe("slash preactivation through session processing", () => {
 // Bundled skill pipeline integration tests
 // ---------------------------------------------------------------------------
 
-const GMAIL_TOOL_NAMES = [
-  "gmail_search",
-  "gmail_list_messages",
-  "gmail_get_message",
-  "gmail_mark_read",
-  "gmail_draft",
-  "gmail_archive",
-  "gmail_label",
-  "gmail_trash",
-  "gmail_send",
-  "gmail_unsubscribe",
-] as const;
-
-describe("bundled skill: gmail", () => {
-  let sessionState: Map<string, string>;
-
-  beforeEach(() => {
-    mockCatalog = [];
-    mockManifests = {};
-    mockRegisteredTools = new Map();
-    mockUnregisteredSkillIds = [];
-    mockSkillRefCount = new Map();
-    mockSkillRefCount = new Map();
-    mockVersionHashes = {};
-    mockVersionHashErrors = new Set();
-    sessionState = new Map<string, string>();
-  });
-
-  test("gmail skill activation via loaded_skill marker registers all 11 tools in allowedToolNames", () => {
-    mockCatalog = [makeSkill("gmail", "/path/to/bundled-skills/gmail")];
-    mockManifests = { gmail: makeManifest([...GMAIL_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...skillLoadMessages('<loaded_skill id="gmail" />'),
-    ];
-
-    const result = projectSkillTools(history, {
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toEqual([]);
-    expect(result.allowedToolNames).toEqual(new Set(GMAIL_TOOL_NAMES));
-  });
-
-  test("gmail tools are NOT available when gmail skill is not in active context", () => {
-    mockCatalog = [makeSkill("gmail", "/path/to/bundled-skills/gmail")];
-    mockManifests = { gmail: makeManifest([...GMAIL_TOOL_NAMES]) };
-
-    // No loaded_skill marker for gmail in history
-    const history: Message[] = [
-      { role: "user", content: [{ type: "text", text: "Hello" }] },
-    ];
-
-    const result = projectSkillTools(history, {
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toHaveLength(0);
-    expect(result.allowedToolNames.size).toBe(0);
-    for (const name of GMAIL_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(name)).toBe(false);
-    }
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Bundled skill: app-builder
 // ---------------------------------------------------------------------------
@@ -1812,10 +1742,10 @@ describe("bundled skill: app-builder", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Bundled skill: browser
+// Browser skill: CLI-only projection
 // ---------------------------------------------------------------------------
 
-describe("bundled skill: browser", () => {
+describe("bundled skill: browser — CLI-only projection", () => {
   let sessionState: Map<string, string>;
 
   beforeEach(() => {
@@ -1829,28 +1759,16 @@ describe("bundled skill: browser", () => {
     sessionState = new Map<string, string>();
   });
 
-  test("browser skill activation via loaded_skill marker registers all browser tools in allowedToolNames", () => {
-    mockCatalog = [makeSkill("browser", "/path/to/bundled-skills/browser")];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...buildSkillLoadHistory("browser", "v1:testhash"),
+  test("browser skill loads without projecting any skill tools", () => {
+    mockCatalog = [
+      makeSkill("vellum-browser-use", "/path/to/skills/vellum-browser-use"),
     ];
-
-    const result = projectSkillTools(history, {
-      previouslyActiveSkillIds: sessionState,
-    });
-
-    expect(result.toolDefinitions).toEqual([]);
-    expect(result.allowedToolNames).toEqual(new Set(BROWSER_TOOL_NAMES));
-  });
-
-  test("browser tools are NOT available when browser skill is not in active context", () => {
-    mockCatalog = [makeSkill("browser", "/path/to/bundled-skills/browser")];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
+    // Browser skill has no TOOLS.json manifest — operations are
+    // dispatched via `assistant browser` CLI commands.
+    mockManifests = {};
 
     const history: Message[] = [
-      { role: "user", content: [{ type: "text", text: "Hello" }] },
+      ...buildSkillLoadHistory("vellum-browser-use", "v1:testhash"),
     ];
 
     const result = projectSkillTools(history, {
@@ -1859,29 +1777,6 @@ describe("bundled skill: browser", () => {
 
     expect(result.toolDefinitions).toHaveLength(0);
     expect(result.allowedToolNames.size).toBe(0);
-    for (const name of BROWSER_TOOL_NAMES) {
-      expect(result.allowedToolNames.has(name)).toBe(false);
-    }
-  });
-
-  test("browser skill tools have skill origin metadata", () => {
-    mockCatalog = [makeSkill("browser", "/path/to/bundled-skills/browser")];
-    mockManifests = { browser: makeManifest([...BROWSER_TOOL_NAMES]) };
-
-    const history: Message[] = [
-      ...buildSkillLoadHistory("browser", "v1:testhash"),
-    ];
-
-    projectSkillTools(history, { previouslyActiveSkillIds: sessionState });
-
-    const tools = mockRegisteredTools.get("browser");
-    expect(tools).toBeDefined();
-    expect(tools!.length).toBe(BROWSER_TOOL_NAMES.length);
-
-    for (const tool of tools!) {
-      expect(tool.origin).toBe("skill");
-      expect(tool.ownerSkillId).toBe("browser");
-    }
   });
 });
 
@@ -2581,10 +2476,10 @@ describe("includes metadata does not auto-activate child skill tools", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Browser skill migration harness — validates shared test helpers
+// Skill load harness — validates shared test helpers
 // ---------------------------------------------------------------------------
 
-describe("browser skill migration harness", () => {
+describe("skill load harness", () => {
   test("buildSkillLoadHistory creates valid skill_load history", () => {
     const history = buildSkillLoadHistory("browser", "v1:abc123");
     expect(history).toHaveLength(2);
@@ -2609,33 +2504,4 @@ describe("browser skill migration harness", () => {
     const id2 = (h2[0].content[0] as { id: string }).id;
     expect(id1).not.toBe(id2);
   });
-
-  test("BROWSER_TOOL_NAMES contains all browser tools", () => {
-    expect(BROWSER_TOOL_NAMES).toHaveLength(17);
-    expect(BROWSER_TOOL_NAMES).toContain("browser_navigate");
-    expect(BROWSER_TOOL_NAMES).toContain("browser_attach");
-    expect(BROWSER_TOOL_NAMES).toContain("browser_detach");
-    expect(BROWSER_TOOL_NAMES).toContain("browser_fill_credential");
-    expect(BROWSER_TOOL_NAMES).toContain("browser_status");
-  });
-
-  test("assertBrowserToolsPresent passes when all tools present", () => {
-    expect(() =>
-      assertBrowserToolsPresent([...BROWSER_TOOL_NAMES, "extra_tool"]),
-    ).not.toThrow();
-  });
-
-  test("assertBrowserToolsPresent fails when tool missing", () => {
-    expect(() => assertBrowserToolsPresent(["browser_navigate"])).toThrow();
-  });
-
-  test("assertBrowserToolsAbsent passes when no browser tools present", () => {
-    expect(() =>
-      assertBrowserToolsAbsent(["file_read", "web_search"]),
-    ).not.toThrow();
-  });
-
-  test("assertBrowserToolsAbsent fails when browser tool present", () => {
-    expect(() => assertBrowserToolsAbsent(["browser_navigate"])).toThrow();
-  });
 });

package/src/__tests__/conversation-slash-queue.test.ts

@@ -30,23 +30,34 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts: 3,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "truncate",
+    
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
       },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     daemon: {
@@ -196,6 +207,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
@@ -282,9 +296,10 @@ function makeConversation(): Conversation {
   // Bypass real workspace git init: with "/tmp" as the workspace dir, a real
   // ensureInitialized() walks all of /tmp and can exceed the 2s waitForPendingRun
   // budget on CI where parallel tests churn /tmp subdirectories.
-  (conversation as ConversationWithWorkspaceDeps).getWorkspaceGitService = () => ({
-    ensureInitialized: async () => {},
-  });
+  (conversation as ConversationWithWorkspaceDeps).getWorkspaceGitService =
+    () => ({
+      ensureInitialized: async () => {},
+    });
   return conversation;
 }
 

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -30,23 +30,34 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
-      overflowRecovery: {
-        enabled: true,
-        safetyMarginRatio: 0.05,
-        maxAttempts: 3,
-        interactiveLatestTurnCompression: "summarize",
-        nonInteractiveLatestTurnCompression: "truncate",
+    
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
       },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     daemon: {
@@ -207,6 +218,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,

package/src/__tests__/conversation-speed-override.test.ts

@@ -57,17 +57,33 @@ let mockConfigSpeed: "standard" | "fast" = "fast";
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    speed: mockConfigSpeed,
-    effort: "high",
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "high" as const,
+        speed: mockConfigSpeed,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
@@ -195,6 +211,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,