@vellumai/assistant 0.6.4 → 0.6.5

package/src/workspace/provider-commit-message-generator.ts

@@ -14,7 +14,6 @@ export type LLMFallbackReason =
   | "missing_provider_api_key"
   | "breaker_open"
   | "insufficient_budget"
-  | "missing_fast_model"
   | "provider_not_initialized"
   | "timeout"
   | "provider_error"
@@ -40,19 +39,13 @@ Rules:
 - Total output must be under 300 characters
 - If you cannot determine a meaningful message, respond with exactly: FALLBACK`;
 
-const PROVIDER_DEFAULT_FAST_MODELS: Record<string, string> = {
-  anthropic: "claude-haiku-4-5-20251001",
-  openai: "gpt-4o-mini",
-  gemini: "gemini-2.0-flash",
-};
-
 // Providers that can be initialized without an API key (e.g., Ollama runs locally)
 const KEYLESS_PROVIDERS = new Set(["ollama"]);
 
 const deterministicProvider = new DefaultCommitMessageProvider();
 
 function getProviderCandidates(config: ReturnType<typeof getConfig>): string[] {
-  return [config.services.inference.provider];
+  return [config.llm.default.provider];
 }
 
 function buildDeterministicResult(
@@ -118,22 +111,22 @@ export class ProviderCommitMessageGenerator {
     // 3. selected-provider API key preflight (except keyless providers)
     // 4. breaker_open
     // 5. insufficient_budget
-    // 6. missing_fast_model
-    // 7. call provider → timeout / provider_error / invalid_output
+    // 6. call provider → timeout / provider_error / invalid_output
     // ──────────────────────────────────────────────────────────────────
 
     // Step 1: Feature gate
     if (!llmConfig.enabled) {
       return buildDeterministicResult(context, "disabled");
     }
-    if (!llmConfig.useConfiguredProvider) {
-      return buildDeterministicResult(context, "disabled");
-    }
 
-    // Step 2: Resolve configured provider.
-    // If nothing is resolvable, differentiate likely missing-key cases from
-    // true registry/init failures.
-    const resolved = await resolveConfiguredProvider();
+    // Step 2: Resolve configured provider via the commit-message call site,
+    // so model + maxTokens + temperature come from `llm.callSites.commitMessage`
+    // (with `llm.default` as the fallback). Operational fields (`enabled`,
+    // `timeoutMs`, `breaker`, `maxFilesInPrompt`, `maxDiffBytes`,
+    // `minRemainingTurnBudgetMs`) remain on `workspaceGit.commitMessageLLM`
+    // and are read above. If nothing is resolvable, differentiate likely
+    // missing-key cases from true registry/init failures.
+    const resolved = await resolveConfiguredProvider("commitMessage");
     if (!resolved) {
       const candidates = getProviderCandidates(config);
       const hasAnyKeylessCandidate = candidates.some((name) =>
@@ -153,7 +146,7 @@ export class ProviderCommitMessageGenerator {
         return buildDeterministicResult(context, "missing_provider_api_key");
       }
       log.debug(
-        { provider: config.services.inference.provider },
+        { provider: config.llm.default.provider },
         "Provider not initialized; falling back to deterministic",
       );
       return buildDeterministicResult(context, "provider_not_initialized");
@@ -200,23 +193,7 @@ export class ProviderCommitMessageGenerator {
       }
     }
 
-    // Step 5: Fast model preflight — resolve before any provider call
-    const fastModel =
-      llmConfig.providerFastModelOverrides[providerName] ??
-      PROVIDER_DEFAULT_FAST_MODELS[providerName];
-
-    if (!fastModel) {
-      log.debug(
-        {
-          provider: providerName,
-          configuredProvider: config.services.inference.provider,
-        },
-        "No fast model resolvable for provider; falling back to deterministic",
-      );
-      return buildDeterministicResult(context, "missing_fast_model");
-    }
-
-    // Step 6 + 7: Call the provider
+    // Step 5: Call the provider
     try {
       // Build prompt
       const fileList = options.changedFiles
@@ -263,9 +240,13 @@ export class ProviderCommitMessageGenerator {
           {
             signal: ac.signal,
             config: {
-              model: fastModel,
-              max_tokens: llmConfig.maxTokens,
-              temperature: llmConfig.temperature,
+              // `callSite` lets the provider resolve model, max_tokens, and
+              // temperature from `llm.callSites.commitMessage` (with
+              // `llm.default` as the fallback). Operational fields
+              // (`enabled`, `timeoutMs`, `breaker`, `maxFilesInPrompt`,
+              // `maxDiffBytes`, `minRemainingTurnBudgetMs`) remain on
+              // `workspaceGit.commitMessageLLM` and are read above.
+              callSite: "commitMessage",
             },
           },
         );

package/src/__tests__/gmail-archive-fallback.test.ts

@@ -1,193 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-import type { ToolContext } from "../tools/types.js";
-
-const mockBatchModifyMessages =
-  mock<
-    (
-      conn: unknown,
-      ids: string[],
-      opts: Record<string, unknown>,
-    ) => Promise<void>
-  >();
-const mockListMessages = mock<
-  (
-    conn: unknown,
-    query: string,
-    limit: number,
-    pageToken?: string,
-  ) => Promise<{
-    messages?: { id: string }[];
-    nextPageToken?: string | null;
-  }>
->();
-const mockModifyMessage =
-  mock<
-    (
-      conn: unknown,
-      messageId: string,
-      opts: Record<string, unknown>,
-    ) => Promise<void>
-  >();
-const mockResolveOAuthConnection =
-  mock<(provider: string, opts?: unknown) => Promise<unknown>>();
-
-let mockScanStoreReturn: string[] | null = null;
-
-mock.module("../messaging/providers/gmail/client.js", () => ({
-  batchModifyMessages: mockBatchModifyMessages,
-  listMessages: mockListMessages,
-  modifyMessage: mockModifyMessage,
-}));
-
-mock.module("../oauth/connection-resolver.js", () => ({
-  resolveOAuthConnection: mockResolveOAuthConnection,
-}));
-
-mock.module(
-  "../config/bundled-skills/gmail/tools/scan-result-store.js",
-  () => ({
-    getSenderMessageIds: () => mockScanStoreReturn,
-  }),
-);
-
-const { run } =
-  await import("../config/bundled-skills/gmail/tools/gmail-archive.js");
-
-function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
-  return {
-    conversationId: "conv-1",
-    triggeredBySurfaceAction: true,
-    ...overrides,
-  } as ToolContext;
-}
-
-function encodeSenderId(email: string): string {
-  return Buffer.from(email).toString("base64url");
-}
-
-describe("gmail_archive sender ID fallback", () => {
-  afterEach(() => {
-    mockBatchModifyMessages.mockReset();
-    mockListMessages.mockReset();
-    mockModifyMessage.mockReset();
-    mockResolveOAuthConnection.mockReset();
-    mockScanStoreReturn = null;
-  });
-
-  test("falls back to query-based archiving when scan expires", async () => {
-    mockScanStoreReturn = null; // expired scan
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockListMessages.mockResolvedValueOnce({
-      messages: [{ id: "m1" }, { id: "m2" }, { id: "m3" }],
-      nextPageToken: null,
-    });
-    mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-    const senderId = encodeSenderId("spam@example.com");
-    const result = await run(
-      { scan_id: "expired-scan", sender_ids: [senderId] },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Archived 3 message(s)");
-    expect(result.content).toContain("query fallback");
-    expect(mockListMessages.mock.calls[0][1]).toBe(
-      'from:"spam@example.com" in:inbox',
-    );
-  });
-
-  test("returns error when scan returns empty array (sender IDs don't match)", async () => {
-    mockScanStoreReturn = []; // scan valid but no IDs resolved
-
-    const senderId = encodeSenderId("cold@outreach.io");
-    const result = await run(
-      { scan_id: "valid-scan", sender_ids: [senderId] },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("do not match the scan results");
-  });
-
-  test("handles multiple sender IDs in fallback", async () => {
-    mockScanStoreReturn = null;
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockListMessages
-      .mockResolvedValueOnce({
-        messages: [{ id: "m1" }, { id: "m2" }],
-        nextPageToken: null,
-      })
-      .mockResolvedValueOnce({
-        messages: [{ id: "m3" }],
-        nextPageToken: null,
-      });
-    mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-    const senderIds = [
-      encodeSenderId("a@example.com"),
-      encodeSenderId("b@example.com"),
-    ];
-    const result = await run(
-      { scan_id: "expired", sender_ids: senderIds },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Archived 3 message(s)");
-    expect(mockListMessages).toHaveBeenCalledTimes(2);
-  });
-
-  test("reports undecodable sender IDs", async () => {
-    mockScanStoreReturn = null;
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockListMessages.mockResolvedValueOnce({
-      messages: [{ id: "m1" }],
-      nextPageToken: null,
-    });
-    mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-    const validId = encodeSenderId("ok@example.com");
-    const invalidId = "not-valid-base64-@@@";
-    const result = await run(
-      { scan_id: "expired", sender_ids: [validId, invalidId] },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("1 sender ID(s) could not be decoded");
-  });
-
-  test("errors when all sender IDs are undecodable", async () => {
-    mockScanStoreReturn = null;
-
-    // base64url decodes to something without @
-    const noAtId = Buffer.from("noemail").toString("base64url");
-    const result = await run(
-      { scan_id: "expired", sender_ids: [noAtId] },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("could not be decoded");
-  });
-
-  test("returns ok when fallback finds no messages", async () => {
-    mockScanStoreReturn = null;
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockListMessages.mockResolvedValueOnce({
-      messages: [],
-      nextPageToken: null,
-    });
-
-    const senderId = encodeSenderId("gone@example.com");
-    const result = await run(
-      { scan_id: "expired", sender_ids: [senderId] },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("No inbox messages found");
-  });
-});

package/src/__tests__/gmail-archive-gate.test.ts

@@ -1,246 +0,0 @@
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-import {
-  buildTaskRules,
-  clearTaskRunRules,
-  getTaskRunRules,
-  setTaskRunRules,
-} from "../tasks/ephemeral-permissions.js";
-import type { ToolContext } from "../tools/types.js";
-
-const mockBatchModifyMessages =
-  mock<
-    (
-      conn: unknown,
-      ids: string[],
-      opts: Record<string, unknown>,
-    ) => Promise<void>
-  >();
-const mockListMessages =
-  mock<
-    (
-      conn: unknown,
-      query: string,
-      limit: number,
-      pageToken?: string,
-    ) => Promise<{
-      messages?: { id: string }[];
-      nextPageToken?: string | null;
-    }>
-  >();
-const mockModifyMessage =
-  mock<
-    (
-      conn: unknown,
-      messageId: string,
-      opts: Record<string, unknown>,
-    ) => Promise<void>
-  >();
-const mockResolveOAuthConnection =
-  mock<(provider: string, opts?: unknown) => Promise<unknown>>();
-
-mock.module("../messaging/providers/gmail/client.js", () => ({
-  batchModifyMessages: mockBatchModifyMessages,
-  listMessages: mockListMessages,
-  modifyMessage: mockModifyMessage,
-}));
-
-mock.module("../oauth/connection-resolver.js", () => ({
-  resolveOAuthConnection: mockResolveOAuthConnection,
-}));
-
-mock.module("../config/bundled-skills/gmail/tools/scan-result-store.js", () => ({
-  getSenderMessageIds: () => ["msg-a", "msg-b"],
-}));
-
-const { run } = await import(
-  "../config/bundled-skills/gmail/tools/gmail-archive.js"
-);
-
-function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
-  return {
-    conversationId: "conv-1",
-    ...overrides,
-  } as ToolContext;
-}
-
-describe("gmail_archive gate", () => {
-  test("rejects query path when neither surface action nor batch-authorized task", async () => {
-    const result = await run(
-      { query: "in:inbox" },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: false,
-      }),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("surface action");
-  });
-
-  test("rejects batch message_ids path when neither flag set", async () => {
-    const result = await run(
-      { message_ids: ["m1", "m2"] },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: false,
-      }),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("surface action");
-  });
-
-  test("rejects scan_id path when neither flag set", async () => {
-    const result = await run(
-      { scan_id: "scan-1", sender_ids: ["s1"] },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: false,
-      }),
-    );
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("surface action");
-  });
-
-  test("allows query path in a scheduled task run (batchAuthorizedByTask)", async () => {
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockListMessages.mockResolvedValueOnce({
-      messages: [{ id: "m1" }, { id: "m2" }],
-      nextPageToken: null,
-    });
-    mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-    const result = await run(
-      { query: "in:inbox category:promotions" },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: true,
-      }),
-    );
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Archived 2 message(s)");
-  });
-
-  test("allows batch message_ids path in a scheduled task run", async () => {
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-    const result = await run(
-      { message_ids: ["m1", "m2"] },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: true,
-      }),
-    );
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Archived 2 message(s)");
-  });
-
-  describe("batchAuthorizedByTask computed per-tool from required_tools", () => {
-    // Mirrors the computation in daemon/conversation-tool-setup.ts so a
-    // regression in that call site would be caught by this test suite.
-    function computeBatchAuthorizedByTask(
-      taskRunId: string | null | undefined,
-      toolName: string,
-    ): boolean {
-      return (
-        taskRunId != null &&
-        getTaskRunRules(taskRunId).some((r) => r.tool === toolName)
-      );
-    }
-
-    afterEach(() => {
-      clearTaskRunRules("task-run-unrelated");
-      clearTaskRunRules("task-run-with-archive");
-    });
-
-    test("rejects gmail_archive when required_tools does NOT include it", async () => {
-      const taskRunId = "task-run-unrelated";
-      setTaskRunRules(
-        taskRunId,
-        buildTaskRules(taskRunId, ["host_bash"], "/tmp"),
-      );
-
-      const batchAuthorizedByTask = computeBatchAuthorizedByTask(
-        taskRunId,
-        "gmail_archive",
-      );
-      expect(batchAuthorizedByTask).toBe(false);
-
-      const result = await run(
-        { query: "in:inbox" },
-        makeContext({
-          taskRunId,
-          triggeredBySurfaceAction: false,
-          batchAuthorizedByTask,
-        }),
-      );
-      expect(result.isError).toBe(true);
-      expect(result.content).toContain("surface action");
-    });
-
-    test("rejects gmail_archive when required_tools is empty", async () => {
-      const taskRunId = "task-run-unrelated";
-      setTaskRunRules(taskRunId, buildTaskRules(taskRunId, [], "/tmp"));
-
-      const batchAuthorizedByTask = computeBatchAuthorizedByTask(
-        taskRunId,
-        "gmail_archive",
-      );
-      expect(batchAuthorizedByTask).toBe(false);
-
-      const result = await run(
-        { message_ids: ["m1", "m2"] },
-        makeContext({
-          taskRunId,
-          triggeredBySurfaceAction: false,
-          batchAuthorizedByTask,
-        }),
-      );
-      expect(result.isError).toBe(true);
-      expect(result.content).toContain("surface action");
-    });
-
-    test("allows gmail_archive when required_tools DOES include it", async () => {
-      const taskRunId = "task-run-with-archive";
-      setTaskRunRules(
-        taskRunId,
-        buildTaskRules(taskRunId, ["gmail_archive"], "/tmp"),
-      );
-
-      const batchAuthorizedByTask = computeBatchAuthorizedByTask(
-        taskRunId,
-        "gmail_archive",
-      );
-      expect(batchAuthorizedByTask).toBe(true);
-
-      mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-      mockBatchModifyMessages.mockResolvedValueOnce(undefined);
-
-      const result = await run(
-        { message_ids: ["m1", "m2"] },
-        makeContext({
-          taskRunId,
-          triggeredBySurfaceAction: false,
-          batchAuthorizedByTask,
-        }),
-      );
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("Archived 2 message(s)");
-    });
-  });
-
-  test("single message_id path works without either flag (no gate on that path)", async () => {
-    mockResolveOAuthConnection.mockResolvedValueOnce({ id: "gmail-conn" });
-    mockModifyMessage.mockResolvedValueOnce(undefined);
-
-    const result = await run(
-      { message_id: "msg-1" },
-      makeContext({
-        triggeredBySurfaceAction: false,
-        batchAuthorizedByTask: false,
-      }),
-    );
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("Message archived");
-  });
-});

package/src/__tests__/gmail-preferences.test.ts

@@ -1,117 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-// Create a temp workspace dir for each test
-const testWorkspace = join(tmpdir(), `gmail-prefs-test-${Date.now()}`);
-mkdirSync(join(testWorkspace, "data"), { recursive: true });
-
-mock.module("../util/platform.js", () => ({
-  getWorkspaceDir: () => testWorkspace,
-}));
-
-const {
-  loadPreferences,
-  addToBlocklist,
-  addToSafelist,
-  removeFromBlocklist,
-  removeFromSafelist,
-} = await import("../config/bundled-skills/gmail/tools/gmail-preferences.js");
-
-describe("gmail preferences", () => {
-  afterEach(() => {
-    // Clean up the prefs file between tests
-    try {
-      rmSync(join(testWorkspace, "data", "gmail-preferences.json"));
-    } catch {
-      // OK if doesn't exist
-    }
-  });
-
-  test("returns empty lists when no prefs file exists", () => {
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toEqual([]);
-    expect(prefs.safelist).toEqual([]);
-  });
-
-  test("addToBlocklist persists and deduplicates emails", () => {
-    addToBlocklist(["spam@example.com", "junk@test.com"]);
-    addToBlocklist(["spam@example.com", "more@test.com"]);
-
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toContain("spam@example.com");
-    expect(prefs.blocklist).toContain("junk@test.com");
-    expect(prefs.blocklist).toContain("more@test.com");
-    expect(
-      prefs.blocklist.filter((e) => e === "spam@example.com"),
-    ).toHaveLength(1);
-  });
-
-  test("addToSafelist persists and deduplicates emails", () => {
-    addToSafelist(["keep@example.com"]);
-    addToSafelist(["keep@example.com", "also@keep.com"]);
-
-    const prefs = loadPreferences();
-    expect(prefs.safelist).toContain("keep@example.com");
-    expect(prefs.safelist).toContain("also@keep.com");
-    expect(prefs.safelist.filter((e) => e === "keep@example.com")).toHaveLength(
-      1,
-    );
-  });
-
-  test("blocklisting removes from safelist", () => {
-    addToSafelist(["sender@example.com"]);
-    expect(loadPreferences().safelist).toContain("sender@example.com");
-
-    addToBlocklist(["sender@example.com"]);
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toContain("sender@example.com");
-    expect(prefs.safelist).not.toContain("sender@example.com");
-  });
-
-  test("safelisting removes from blocklist", () => {
-    addToBlocklist(["sender@example.com"]);
-    expect(loadPreferences().blocklist).toContain("sender@example.com");
-
-    addToSafelist(["sender@example.com"]);
-    const prefs = loadPreferences();
-    expect(prefs.safelist).toContain("sender@example.com");
-    expect(prefs.blocklist).not.toContain("sender@example.com");
-  });
-
-  test("removeFromBlocklist works", () => {
-    addToBlocklist(["a@test.com", "b@test.com", "c@test.com"]);
-    removeFromBlocklist(["b@test.com"]);
-
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toContain("a@test.com");
-    expect(prefs.blocklist).not.toContain("b@test.com");
-    expect(prefs.blocklist).toContain("c@test.com");
-  });
-
-  test("removeFromSafelist works", () => {
-    addToSafelist(["a@test.com", "b@test.com"]);
-    removeFromSafelist(["a@test.com"]);
-
-    const prefs = loadPreferences();
-    expect(prefs.safelist).not.toContain("a@test.com");
-    expect(prefs.safelist).toContain("b@test.com");
-  });
-
-  test("normalizes emails to lowercase", () => {
-    addToBlocklist(["SPAM@Example.COM"]);
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toContain("spam@example.com");
-  });
-
-  test("handles corrupted prefs file gracefully", () => {
-    writeFileSync(
-      join(testWorkspace, "data", "gmail-preferences.json"),
-      "not json",
-    );
-    const prefs = loadPreferences();
-    expect(prefs.blocklist).toEqual([]);
-    expect(prefs.safelist).toEqual([]);
-  });
-});