@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/daemon/__tests__/meet-manifest-loader.test.ts

@@ -163,14 +163,23 @@ describe("loadMeetManifestProxies", () => {
     const capturedRoutes: SkillRoute[] = [];
     const capturedHooks: string[] = [];
 
+    // Capture both the owner (first arg) and the provider (second arg) so
+    // we can assert the meet-join skill id flows through to the registry
+    // call. Ownership lives on the registry, not on the `Tool` object,
+    // so the only place to check it is on this argument.
+    const capturedOwners: Array<{ kind: string; id: string }> = [];
     await loadMeetManifestProxies(supervisor, {
       manifestPath,
-      registerTools: (p) => capturedProviders.push(p),
+      registerTools: (owner, p) => {
+        capturedOwners.push(owner);
+        capturedProviders.push(p);
+      },
       registerRoute: (r) => capturedRoutes.push(r),
       registerShutdown: (name) => capturedHooks.push(name),
     });
 
     expect(capturedProviders).toHaveLength(1);
+    expect(capturedOwners).toEqual([{ kind: "skill", id: "meet-join" }]);
     const tools = capturedProviders[0]!();
     expect(tools).toHaveLength(1);
     const t = tools[0]!;
@@ -178,14 +187,10 @@ describe("loadMeetManifestProxies", () => {
     expect(t.description).toBe("Fixture demo tool");
     expect(t.category).toBe("meet");
     expect(t.defaultRiskLevel).toBe(RiskLevel.Medium);
-    expect(t.executionMode).toBe("proxy");
-    expect(t.origin).toBe("skill");
-    expect(t.ownerSkillId).toBe("meet-join");
-    expect(t.ownerSkillBundled).toBe(true);
-    expect(t.ownerSkillVersionHash).toBe(FIXTURE_MANIFEST.sourceHash);
-    expect(t.input_schema).toEqual(
-      FIXTURE_MANIFEST.tools[0]!.input_schema,
-    );
+    // Ownership now lives on the assistant-side registry's ownersByName map
+    // (recorded by registerSkillTools at the IPC boundary), not on the Tool
+    // object — the daemon-side projection doesn't carry the kind.
+    expect(t.input_schema).toEqual(FIXTURE_MANIFEST.tools[0]!.input_schema);
   });
 
   test("proxy tool execute dispatches through supervisor.dispatchTool and returns the result", async () => {
@@ -196,7 +201,11 @@ describe("loadMeetManifestProxies", () => {
 
     await loadMeetManifestProxies(stub.supervisor, {
       manifestPath,
-      registerTools: (p) => captured.push(p),
+      // Mock signature mirrors `registerExternalTools(owner, provider)` —
+      // ownership is recorded by the registry-side argument, not by the
+      // `Tool` object. This test doesn't care which owner flows through;
+      // the round-trip dispatch behavior is what's under test.
+      registerTools: (_owner, p) => captured.push(p),
       registerRoute: () => undefined,
       registerShutdown: () => undefined,
     });
@@ -238,7 +247,11 @@ describe("loadMeetManifestProxies", () => {
 
     await loadMeetManifestProxies(stub.supervisor, {
       manifestPath,
-      registerTools: (p) => captured.push(p),
+      // Mock signature mirrors `registerExternalTools(owner, provider)` —
+      // ownership is recorded by the registry-side argument, not by the
+      // `Tool` object. This test doesn't care which owner flows through;
+      // the round-trip dispatch behavior is what's under test.
+      registerTools: (_owner, p) => captured.push(p),
       registerRoute: () => undefined,
       registerShutdown: () => undefined,
     });
@@ -415,7 +428,7 @@ describe("loadMeetManifestProxies", () => {
     await expect(
       loadMeetManifestProxies(stub.supervisor, {
         manifestPath,
-        registerTools: (p) => {
+        registerTools: (_owner, p) => {
           providerInvoked = true;
           p();
         },

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

@@ -42,6 +42,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../memory/llm-request-log-store.js", () => ({
@@ -50,6 +51,7 @@ mock.module("../../memory/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } from "../../tools/network/web-search-error.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -94,6 +96,7 @@ function createCollectorDeps(providerName = "anthropic"): {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
   return { deps, events };
 }
@@ -256,9 +259,7 @@ describe("native server_tool_complete metadata", () => {
     );
     expect(toolResults).toHaveLength(2);
 
-    const byId = new Map(
-      toolResults.map((r) => [r.toolUseId, r] as const),
-    );
+    const byId = new Map(toolResults.map((r) => [r.toolUseId, r] as const));
     expect(byId.get("tu_a")?.activityMetadata?.webSearch?.query).toBe("alpha");
     expect(byId.get("tu_b")?.activityMetadata?.webSearch?.query).toBe("beta");
 
@@ -269,7 +270,7 @@ describe("native server_tool_complete metadata", () => {
     expect(durB).toBeGreaterThanOrEqual(durA);
   });
 
-  test("forwards provider error codes instead of generic 'Search failed'", async () => {
+  test("maps recoverable error codes to friendly copy, not the raw code", async () => {
     const { deps, events } = createCollectorDeps();
     const toolUseId = "tu_err_code";
 
@@ -291,9 +292,11 @@ describe("native server_tool_complete metadata", () => {
     const toolResultEvent = events.find(
       (e): e is ToolResultEvent => e.type === "tool_result",
     );
-    expect(toolResultEvent?.activityMetadata?.webSearch?.errorMessage).toBe(
-      "max_uses_exceeded",
-    );
+    const errorMessage =
+      toolResultEvent?.activityMetadata?.webSearch?.errorMessage;
+    // The raw provider code is never user-visible.
+    expect(errorMessage).not.toBe("max_uses_exceeded");
+    expect(errorMessage).toContain("web-search limit");
   });
 
   test("does NOT emit activityMetadata for non-Anthropic providers", async () => {
@@ -349,7 +352,7 @@ describe("native server_tool_complete metadata", () => {
       (e): e is ToolResultEvent => e.type === "tool_result",
     );
     const meta = toolResultEvent?.activityMetadata?.webSearch;
-    expect(meta?.errorMessage).toBe("Search failed");
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
     expect(meta?.resultCount).toBe(0);
     expect(meta?.results).toEqual([]);
     expect(toolResultEvent?.isError).toBe(true);

package/src/daemon/__tests__/switch-inference-profile-tool.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ProfileEntry } from "../../config/schemas/llm.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import { buildSwitchInferenceProfileToolDef } from "../switch-inference-profile-tool.js";
+
+function getProfileEnum(toolDef: ToolDefinition): string[] {
+  const schema = toolDef.input_schema as {
+    properties: { profile: { enum: string[] } };
+  };
+  return schema.properties.profile.enum;
+}
+
+const balanced: ProfileEntry = {
+  provider: "anthropic",
+  model: "claude-sonnet-4-6",
+  label: "Balanced",
+  description: "Good balance of quality, cost, and speed",
+  source: "managed",
+};
+
+const quality: ProfileEntry = {
+  provider: "anthropic",
+  model: "claude-opus-4-6",
+  label: "Quality",
+  description: "Best results with the most capable model",
+  source: "managed",
+};
+
+const speed: ProfileEntry = {
+  provider: "anthropic",
+  model: "claude-haiku-4-5",
+  label: "Speed",
+  description: "Fastest responses at lower cost",
+  source: "managed",
+};
+
+const auto: ProfileEntry = {
+  label: "Auto",
+  description: "Automatically routes each query to the best profile",
+  source: "managed",
+};
+
+describe("buildSwitchInferenceProfileToolDef", () => {
+  test("excludes the 'auto' profile from available switch targets", () => {
+    const profiles = { auto, balanced, "quality-optimized": quality, "cost-optimized": speed };
+    const toolDef = buildSwitchInferenceProfileToolDef(profiles, "auto");
+
+    expect(toolDef).not.toBeNull();
+    const enumValues = getProfileEnum(toolDef!);
+    expect(enumValues).not.toContain("auto");
+    expect(enumValues).toContain("balanced");
+    expect(enumValues).toContain("quality-optimized");
+    expect(enumValues).toContain("cost-optimized");
+  });
+
+  test("returns null when only 'auto' and one real profile exist", () => {
+    const profiles = { auto, balanced };
+    const toolDef = buildSwitchInferenceProfileToolDef(profiles, "auto");
+
+    expect(toolDef).toBeNull();
+  });
+
+  test("excludes disabled profiles alongside 'auto'", () => {
+    const disabled: ProfileEntry = { ...balanced, status: "disabled" };
+    const profiles = { auto, balanced: disabled, "quality-optimized": quality, "cost-optimized": speed };
+    const toolDef = buildSwitchInferenceProfileToolDef(profiles, "auto");
+
+    expect(toolDef).not.toBeNull();
+    const enumValues = getProfileEnum(toolDef!);
+    expect(enumValues).not.toContain("auto");
+    expect(enumValues).not.toContain("balanced");
+    expect(enumValues).toContain("quality-optimized");
+    expect(enumValues).toContain("cost-optimized");
+  });
+
+  test("shows 'Auto (starting on Balanced)' as the current profile label", () => {
+    const profiles = { auto, balanced, "quality-optimized": quality, "cost-optimized": speed };
+    const toolDef = buildSwitchInferenceProfileToolDef(profiles, "auto");
+
+    expect(toolDef).not.toBeNull();
+    expect(toolDef!.description).toContain("Auto (starting on Balanced)");
+  });
+
+  test("works with BYOK custom profiles", () => {
+    const customBalanced: ProfileEntry = {
+      ...balanced,
+      provider_connection: "anthropic-personal",
+      label: "Balanced",
+      source: "user",
+    };
+    const customQuality: ProfileEntry = {
+      ...quality,
+      provider_connection: "anthropic-personal",
+      label: "Quality",
+      source: "user",
+    };
+    const profiles = { auto, "custom-balanced": customBalanced, "custom-quality-optimized": customQuality };
+    const toolDef = buildSwitchInferenceProfileToolDef(profiles, "auto");
+
+    expect(toolDef).not.toBeNull();
+    const enumValues = getProfileEnum(toolDef!);
+    expect(enumValues).not.toContain("auto");
+    expect(enumValues).toContain("custom-balanced");
+    expect(enumValues).toContain("custom-quality-optimized");
+  });
+});

package/src/daemon/__tests__/web-search-status-text.test.ts

@@ -40,6 +40,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   updateMessageContent: () => {},
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../../memory/llm-request-log-store.js", () => ({
@@ -65,8 +66,8 @@ import type { ServerMessage } from "../message-protocol.js";
 interface ActivityStateCapture {
   phase: string;
   reason: string;
-  scope: string;
-  reqId: string;
+  anchor?: string;
+  requestId?: string;
   statusText?: string;
 }
 
@@ -84,11 +85,15 @@ function createCollectorDeps(): {
       emitActivityState: (
         phase: string,
         reason: string,
-        scope: string,
-        reqId: string,
-        statusText?: string,
+        options?: { anchor?: string; requestId?: string; statusText?: string },
       ) => {
-        activityStates.push({ phase, reason, scope, reqId, statusText });
+        activityStates.push({
+          phase,
+          reason,
+          anchor: options?.anchor,
+          requestId: options?.requestId,
+          statusText: options?.statusText,
+        });
       },
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],

package/src/daemon/approval-generators.ts

@@ -108,9 +108,9 @@ export function createApprovalCopyGenerator(): ApprovalCopyGenerator {
 
     const response = await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: prompt }] }],
-      [],
-      APPROVAL_COPY_SYSTEM_PROMPT,
       {
+        tools: [],
+        systemPrompt: APPROVAL_COPY_SYSTEM_PROMPT,
         config: {
           max_tokens: options.maxTokens ?? APPROVAL_COPY_MAX_TOKENS,
           callSite: "approvalCopy",
@@ -169,9 +169,9 @@ export function createApprovalConversationGenerator(): ApprovalConversationGener
 
     const response = await provider.sendMessage(
       [{ role: "user", content: [{ type: "text", text: userPrompt }] }],
-      [APPROVAL_CONVERSATION_TOOL_SCHEMA],
-      APPROVAL_CONVERSATION_SYSTEM_PROMPT,
       {
+        tools: [APPROVAL_CONVERSATION_TOOL_SCHEMA],
+        systemPrompt: APPROVAL_CONVERSATION_SYSTEM_PROMPT,
         config: {
           max_tokens: APPROVAL_CONVERSATION_MAX_TOKENS,
           callSite: "approvalConversation",

package/src/daemon/assistant-attachments.ts

@@ -8,7 +8,7 @@
 import { readFileSync, statSync } from "node:fs";
 import { basename } from "node:path";
 
-import { isPlaceholderSentinelText } from "../providers/anthropic/client.js";
+import { isPlaceholderSentinelText } from "../providers/placeholder-sentinels.js";
 import {
   hostPolicy,
   sandboxPolicy,

package/src/daemon/config-watcher.ts

@@ -178,6 +178,8 @@ export class ConfigWatcher {
    * Start all file watchers. `onConversationEvict` is called when watched
    * files change and conversations need to be evicted for reload.
    * `onIdentityChanged` is called when IDENTITY.md changes on disk.
+   * `onIdentityIntroChanged` is called when SOUL.md changes and identity
+   * intro subscribers should refetch.
    * `onSkillsChanged` is called after skill directory changes evict
    * conversations.
    */
@@ -188,6 +190,7 @@ export class ConfigWatcher {
     onAvatarChanged?: () => void,
     onConfigChanged?: () => void,
     onSkillsChanged?: () => void,
+    onIdentityIntroChanged?: () => void,
   ): void {
     // Reset the stopped flag so a stop()→start() cycle on the same
     // instance resumes hot-reload instead of silently bailing in every
@@ -221,7 +224,10 @@ export class ConfigWatcher {
           );
         }
       },
-      "SOUL.md": () => onConversationEvict(),
+      "SOUL.md": () => {
+        onConversationEvict();
+        onIdentityIntroChanged?.();
+      },
       "IDENTITY.md": () => {
         onConversationEvict();
         onIdentityChanged?.();

package/src/daemon/context-overflow-reducer.ts

@@ -173,7 +173,6 @@ async function applyForcedCompaction(
   const compactionOptions: ContextWindowCompactOptions = {
     force: true,
     minKeepRecentUserTurns: 0,
-    targetInputTokensOverride: config.targetTokens,
   };
 
   const result = await compactFn(messages, signal, compactionOptions);