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

package/src/daemon/__tests__/inference-profile-notification.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Verifies that the inference-profile-change notification is persisted only
+ * once the model has actually received the turn context carrying the
+ * `model_profile` block — signalled by the first `message_complete` event from
+ * the agent loop — rather than inline before the provider call. A turn that
+ * fails or is cancelled before delivery never emits `message_complete`, so the
+ * notice is re-sent on the next turn instead of being silently suppressed.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ────────────────────────
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({ memory: {} }),
+  loadConfig: () => ({}),
+}));
+
+const setLastNotifiedInferenceProfile = mock(
+  (_conversationId: string, _profileKey: string) => {},
+);
+
+mock.module("../../memory/conversation-crud.js", () => ({
+  deleteMessageById: () => {},
+  getConversation: () => null,
+  getMessageById: () => null,
+  messageMetadataSchema: { safeParse: () => ({ success: false }) },
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  setConversationHistoryStrippedAt: () => {},
+  setLastNotifiedInferenceProfile,
+  updateMessageContent: () => {},
+}));
+
+mock.module("../../memory/llm-request-log-store.js", () => ({
+  backfillMessageIdOnLogs: () => {},
+  buildProviderErrorResponsePayload: () => ({}),
+  recordRequestLog: () => {},
+  setAgentLoopExitReasonOnLatestLog: () => {},
+}));
+
+mock.module("../../memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module("../../memory/memory-v2-activation-log-store.js", () => ({
+  backfillMemoryV2ActivationMessageId: () => {},
+}));
+
+// ── Imports (after mocks) ────────────────────────────────────────────────────
+import type { AgentEvent } from "../../agent/loop.js";
+import type { Message } from "../../providers/types.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  dispatchAgentEvent,
+} from "../conversation-agent-loop-handlers.js";
+
+const CONVERSATION_ID = "conv-profile-notify";
+const PROFILE_KEY = "quality-optimized";
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      provider: { name: "mock-provider" },
+      traceEmitter: { emit: () => {} },
+      currentTurnSurfaces: [],
+      trustContext: undefined,
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "req-profile-notify",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  } as EventHandlerDeps;
+}
+
+function messageCompleteEvent(): Extract<
+  AgentEvent,
+  { type: "message_complete" }
+> {
+  const message: Message = {
+    role: "assistant",
+    content: [{ type: "text", text: "response" }],
+  };
+  return { type: "message_complete", message };
+}
+
+// A reserved assistant row id is the precondition `handleMessageComplete`
+// asserts before finalizing; the row reservation itself is exercised elsewhere.
+function readyState(): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "assistant-row-1";
+  return state;
+}
+
+describe("inference-profile-change notification persistence", () => {
+  test("persists on the first message_complete and clears the pending slot", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledWith(
+      CONVERSATION_ID,
+      PROFILE_KEY,
+    );
+    expect(state.pendingNotifiedInferenceProfile).toBeNull();
+  });
+
+  test("does not persist when the turn carries no profile-change notice", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+
+    await dispatchAgentEvent(state, makeDeps(), messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).not.toHaveBeenCalled();
+  });
+
+  test("persists exactly once across a multi-call turn", async () => {
+    setLastNotifiedInferenceProfile.mockClear();
+    const state = readyState();
+    state.pendingNotifiedInferenceProfile = PROFILE_KEY;
+    const deps = makeDeps();
+
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+    await dispatchAgentEvent(state, deps, messageCompleteEvent());
+
+    expect(setLastNotifiedInferenceProfile).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -51,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,
@@ -95,6 +96,7 @@ function createCollectorDeps(providerName = "anthropic"): {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     } as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   } as EventHandlerDeps;
   return { deps, events };
 }
@@ -257,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");
 
@@ -270,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";
 
@@ -292,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 () => {
@@ -350,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__/web-search-status-text.test.ts

@@ -66,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;
 }
 
@@ -85,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);