@vellumai/assistant 0.6.4 → 0.6.5

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -23,23 +23,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: {
@@ -130,6 +141,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: Record<string, unknown>) => void,

package/src/__tests__/conversation-process-callsite.test.ts

@@ -0,0 +1,306 @@
+/**
+ * Verifies that `callSite` threads from `Conversation.processMessage`
+ * options all the way down to the per-call provider config, and that
+ * user-initiated turns default to `'mainAgent'` when no caller-supplied
+ * `callSite` is set.
+ *
+ * The test mocks `AgentLoop.run()` so it can capture the `callSite` parameter
+ * the conversation passes after `processMessage` runs the slash-resolver and
+ * runtime-injection pipeline. Adapter callers (heartbeat, filing, scheduler)
+ * pass an explicit `callSite` so `RetryProvider` resolves their per-call
+ * config from `llm.callSites.<id>`.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// Use an object wrapper so TypeScript doesn't narrow the captured type to
+// `undefined` based on the initial assignment in the test setup.
+const captured: { callSite?: string } = {};
+
+function clearCaptured(): void {
+  captured.callSite = undefined;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/guardian-action-store.js", () => ({
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+        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: {
+      startupSocketWaitMs: 5000,
+      stopTimeoutMs: 5000,
+      sigkillGracePeriodMs: 2000,
+      titleGenerationMaxTokens: 30,
+      standaloneRecording: true,
+    },
+    services: {
+      inference: {
+        mode: "your-own",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+// Stub workspace-git so the test doesn't run real `git init` / `git add -A`
+// against the workingDir. On GitHub-hosted runners /tmp contains
+// root-owned systemd-private-* directories that return EACCES, and the
+// resulting retry/backoff path takes several seconds — enough to time
+// out this test even though the callSite-threading assertion is unrelated.
+mock.module("../workspace/turn-commit.js", () => ({
+  commitTurnChanges: async () => {},
+}));
+
+mock.module("../workspace/git-service.js", () => ({
+  getWorkspaceGitService: () => ({
+    ensureInitialized: async () => {},
+    commitIfDirty: async () => ({ committed: false }),
+  }),
+}));
+
+let mockDbMessages: Array<{ id: string; role: string; content: string }> = [];
+let mockConversation: Record<string, unknown> | null = null;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => mockDbMessages,
+  getConversation: () => mockConversation,
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: "new-msg" }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+  getMessageById: () => null,
+  getLastUserTimestampBefore: () => 0,
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    injectedText: "",
+    semanticHits: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes.
+// The 6th positional parameter is `callSite` (see assistant/src/agent/loop.ts).
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    async run(
+      messages: Message[],
+      onEvent: (event: Record<string, unknown>) => void,
+      _signal?: AbortSignal,
+      _requestId?: string,
+      _onCheckpoint?: unknown,
+      callSite?: string,
+    ): Promise<Message[]> {
+      captured.callSite = callSite;
+      onEvent({
+        type: "usage",
+        inputTokens: 0,
+        outputTokens: 0,
+        model: "mock",
+        providerDurationMs: 0,
+      });
+      return [
+        ...messages,
+        { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      ];
+    }
+  },
+}));
+
+mock.module("../context/window-manager.js", () => ({
+  ContextWindowManager: class {
+    constructor() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+  createCanonicalGuardianRequest: () => ({
+    id: "mock-cg-id",
+    code: "MOCK",
+    status: "pending",
+  }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: "mock-cgd-id" }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => "MOCK-CODE",
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [{ type: "text", text: "hi" }],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    4096,
+    () => {},
+    "/tmp",
+  );
+}
+
+describe("processMessage callSite threading", () => {
+  test("threads options.callSite='heartbeatAgent' down to agentLoop.run()", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    await conversation.processMessage(
+      "Heartbeat tick",
+      [],
+      () => {},
+      undefined, // requestId
+      undefined, // activeSurfaceId
+      undefined, // currentPage
+      { callSite: "heartbeatAgent" },
+    );
+
+    expect(captured.callSite).toBe("heartbeatAgent");
+  });
+
+  test("defaults to 'mainAgent' when not supplied", async () => {
+    mockConversation = {
+      id: "conv-1",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    await conversation.processMessage("Plain user message", [], () => {});
+
+    expect(captured.callSite).toBe("mainAgent");
+  });
+});

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -26,23 +26,34 @@ mock.module("../config/loader.js", () => ({
     daemon: {
       titleGenerationMaxTokens: 30,
     },
-
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    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",
+    
+    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 },
     services: {
@@ -250,6 +261,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,

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

@@ -55,23 +55,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 },
     timeouts: { permissionTimeoutSec: 1 },
@@ -330,6 +341,9 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
@@ -1309,18 +1323,18 @@ describe("Batched drain correctness fixes", () => {
       (m) => m.role === "user" && m.content.includes("surface action response"),
     );
     expect(surfaceUserRowsAfterRun2).toHaveLength(1);
-    expect(eventsSurface.filter((e) => e.type === "message_dequeued")).toHaveLength(
-      1,
-    );
+    expect(
+      eventsSurface.filter((e) => e.type === "message_dequeued"),
+    ).toHaveLength(1);
 
     // Complete the surface-action run; drain pulls the regular passthrough
     // as its own separate run.
     resolveRun(1);
     await waitForPendingRun(3);
     expect(pendingRuns.length).toBe(3);
-    expect(eventsRegular.filter((e) => e.type === "message_dequeued")).toHaveLength(
-      1,
-    );
+    expect(
+      eventsRegular.filter((e) => e.type === "message_dequeued"),
+    ).toHaveLength(1);
 
     // Total runs = 3: msg-1, surface-action, regular — NOT 2 (would mean
     // they were batched).
@@ -1390,9 +1404,9 @@ describe("Batched drain correctness fixes", () => {
     const contents = userRowsAfter.map((r) => r.content).join("||");
     expect(contents).toContain("msg-2");
     expect(contents).not.toContain("msg-4");
-    expect(
-      events4.filter((e) => e.type === "message_dequeued"),
-    ).toHaveLength(0);
+    expect(events4.filter((e) => e.type === "message_dequeued")).toHaveLength(
+      0,
+    );
   });
 
   test("failed tail persist uses last-successful requestId", async () => {
@@ -1452,7 +1466,8 @@ describe("Batched drain correctness fixes", () => {
     // (last SUCCESSFUL persist), not the mid's. We check via currentRequestId
     // on the conversation which drainBatch assigns after the loop.
     expect(
-      (conversation as unknown as { currentRequestId?: string }).currentRequestId,
+      (conversation as unknown as { currentRequestId?: string })
+        .currentRequestId,
     ).toBe("req-tail");
 
     // Cleanup: resolve the batched run.

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -49,11 +49,39 @@ mock.module("../config/loader.js", () => ({
     rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
     services: {
       inference: {
         mode: "your-own",
         provider: "anthropic",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-7",
       },
       "image-generation": {
         mode: "your-own",

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -26,17 +26,45 @@ mock.module("../daemon/conversation-slash.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    model: "claude-opus-4-6",
+    model: "claude-opus-4-7",
     provider: "anthropic",
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
     services: {
       inference: {
         mode: "your-own",
         provider: "anthropic",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-7",
       },
       "image-generation": {
         mode: "your-own",
@@ -347,7 +375,7 @@ describe("handleSendMessage slash command interception", () => {
       inputTokens: 1000,
       outputTokens: 500,
       estimatedCost: 0.05,
-      model: "claude-opus-4-6",
+      model: "claude-opus-4-7",
       provider: "anthropic",
       maxInputTokens: 200000,
     });