@vellumai/assistant 0.6.4 → 0.6.5

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -20,15 +20,11 @@ mock.module("../security/secure-keys.js", () => ({
 // ---------------------------------------------------------------------------
 function cloneConfig(): AssistantConfig {
   const cfg = structuredClone(DEFAULT_CONFIG);
-  cfg.services.inference.provider = "anthropic";
+  cfg.llm.default.provider = "anthropic";
   cfg.workspaceGit.commitMessageLLM = {
     ...cfg.workspaceGit.commitMessageLLM,
     enabled: true,
-    useConfiguredProvider: true,
-    providerFastModelOverrides: {},
     timeoutMs: 5000,
-    maxTokens: 120,
-    temperature: 0.2,
     maxFilesInPrompt: 30,
     maxDiffBytes: 12000,
     minRemainingTurnBudgetMs: 1000,
@@ -140,17 +136,6 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.reason).toBe("disabled");
   });
 
-  // 2. useConfiguredProvider false
-  test('useConfiguredProvider false → returns deterministic, reason "disabled"', async () => {
-    currentConfig.workspaceGit.commitMessageLLM.useConfiguredProvider = false;
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("disabled");
-  });
-
   // 3. missing API key
   test('missing API key → returns deterministic, reason "missing_provider_api_key"', async () => {
     mockSecureKeys = {};
@@ -221,7 +206,7 @@ describe("ProviderCommitMessageGenerator", () => {
   });
 
   // 6. LLM success
-  test('LLM success → returns LLM message, source "llm", fast model passed', async () => {
+  test('LLM success → returns LLM message, source "llm", callSite passed', async () => {
     const commitMsg = "feat: add new feature";
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
     const gen = getCommitMessageGenerator();
@@ -232,29 +217,13 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.message).toBe(commitMsg);
     expect(result.reason).toBeUndefined();
 
-    // Verify the fast model was passed in the config
+    // Verify the callSite was passed so the provider's RetryProvider routes
+    // through `resolveCallSiteConfig` for model/max_tokens/temperature.
     const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("claude-haiku-4-5-20251001");
-  });
-
-  // 7. fast-model override
-  test("fast-model override → uses override instead of default", async () => {
-    currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
-      anthropic: "claude-sonnet-4-20250514",
+    const options = callArgs[3] as {
+      config: { callSite: string };
     };
-    const commitMsg = "fix: resolve issue";
-    mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("llm");
-    expect(result.message).toBe(commitMsg);
-
-    const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("claude-sonnet-4-20250514");
+    expect(options.config.callSite).toBe("commitMessage");
   });
 
   // 8. LLM timeout
@@ -330,53 +299,16 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.message).toBe("b".repeat(72) + body);
   });
 
-  // 12. Keyless provider (Ollama) without fast model → missing_fast_model (skips API key check)
-  test('Ollama without API key or fast model → returns deterministic, reason "missing_fast_model"', async () => {
-    currentConfig.services.inference.provider = "ollama";
+  // 12. Ollama (keyless provider) — passes the API-key preflight even without
+  // a stored secret, then succeeds because the call-site resolver supplies
+  // the model from `llm.default`/`llm.callSites.commitMessage`.
+  test("Ollama (keyless) — succeeds because call-site resolver supplies the model", async () => {
+    currentConfig.llm.default.provider = "ollama";
     mockSecureKeys = {};
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
     };
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("missing_fast_model");
-    expect(result.reason).not.toBe("missing_provider_api_key");
-    expect(mockSendMessage).not.toHaveBeenCalled();
-  });
-
-  // 13. Unknown provider without fast model default → missing_fast_model, no provider call
-  test('Unknown provider without fast model default → returns deterministic, reason "missing_fast_model"', async () => {
-    (currentConfig.services.inference as Record<string, unknown>).provider =
-      "exotic-provider";
-    mockSecureKeys = { "exotic-provider": "sk-exotic" };
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "exotic-provider",
-    };
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("missing_fast_model");
-    expect(mockSendMessage).not.toHaveBeenCalled();
-  });
-
-  // 14. Fast-model override enables LLM path for provider without built-in default
-  test("fast-model override enables LLM path for provider without built-in default", async () => {
-    currentConfig.services.inference.provider = "ollama";
-    mockSecureKeys = {}; // Ollama is keyless
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "ollama",
-    };
-    currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
-      ollama: "llama3.2:3b",
-    };
     const commitMsg = "fix: local model commit";
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
     const gen = getCommitMessageGenerator();
@@ -385,10 +317,8 @@ describe("ProviderCommitMessageGenerator", () => {
     });
     expect(result.source).toBe("llm");
     expect(result.message).toBe(commitMsg);
-
-    // Verify the override model was passed
     const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("llama3.2:3b");
+    const options = callArgs[3] as { config: { callSite: string } };
+    expect(options.config.callSite).toBe("commitMessage");
   });
 });

package/src/__tests__/provider-env-vars-scope.test.ts

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+/**
+ * Scope guard for `meta/provider-env-vars.json`.
+ *
+ * Since the LLM-provider env-var map moved into `PROVIDER_CATALOG` (see
+ * `assistant/src/providers/model-catalog.ts` and the `getLlmProviderEnvVar`
+ * helper in `assistant/src/providers/provider-env-vars.ts`), this JSON file
+ * must contain only **search-provider** env vars. Any LLM entries sneaking
+ * back in here would reintroduce the duplicated source of truth this
+ * refactor removed.
+ */
+
+interface ProviderEnvVarsRegistry {
+  version: number;
+  providers: Record<string, string>;
+}
+
+function loadRegistry(): ProviderEnvVarsRegistry {
+  const repoRoot = join(process.cwd(), "..");
+  const path = join(repoRoot, "meta", "provider-env-vars.json");
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+
+describe("provider-env-vars.json scope", () => {
+  test("schema is version 2", () => {
+    const json = loadRegistry();
+    expect(json.version).toBe(2);
+  });
+
+  test("providers map contains exactly brave and perplexity", () => {
+    const json = loadRegistry();
+    const keys = Object.keys(json.providers).sort();
+    expect(keys).toEqual(["brave", "perplexity"]);
+  });
+
+  test("no LLM-provider entries leak into the search-provider registry", () => {
+    const json = loadRegistry();
+    const llmProviderIds = [
+      "anthropic",
+      "openai",
+      "gemini",
+      "fireworks",
+      "openrouter",
+    ];
+    for (const id of llmProviderIds) {
+      expect(json.providers[id]).toBeUndefined();
+    }
+  });
+});

package/src/__tests__/provider-error-scenarios.test.ts

@@ -109,11 +109,12 @@ mock.module("../util/retry.js", () => {
 
 import { RetryProvider } from "../providers/retry.js";
 import { createStreamTimeout } from "../providers/stream-timeout.js";
-import type {
-  Message,
-  Provider,
-  ProviderEvent,
-  ProviderResponse,
+import {
+  ContextOverflowError,
+  type Message,
+  type Provider,
+  type ProviderEvent,
+  type ProviderResponse,
 } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 import { DEFAULT_MAX_RETRIES } from "../util/retry.js";
@@ -217,6 +218,47 @@ describe("RetryProvider — rate limit backoff", () => {
     }
   });
 
+  test("tags final error with retriesExhausted=true after retry loop gives up (JARVIS-513)", async () => {
+    // Transient socket flap from Bun's native fetch: wrapped in a
+    // ProviderError but still network-retryable via message pattern match.
+    const inner = makeFailing(
+      new ProviderError(
+        "Anthropic request failed: The socket connection was closed unexpectedly",
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    try {
+      await provider.sendMessage(MESSAGES);
+      expect(true).toBe(false);
+    } catch (err) {
+      const flag = (err as Error & { retriesExhausted?: boolean })
+        .retriesExhausted;
+      expect(flag).toBe(true);
+      // Retry loop should have used all attempts before surrendering.
+      expect(inner.calls).toBe(DEFAULT_MAX_RETRIES + 1);
+    }
+  });
+
+  test("does NOT tag retriesExhausted on non-retryable errors (no retry was attempted)", async () => {
+    // ProviderError without statusCode and without a retryable pattern: the
+    // retry loop short-circuits on the first attempt. No "exhaustion"
+    // occurred, so the marker must stay unset.
+    const inner = makeFailing(new ProviderError("model not found", "test"));
+    const provider = new RetryProvider(inner);
+
+    try {
+      await provider.sendMessage(MESSAGES);
+      expect(true).toBe(false);
+    } catch (err) {
+      const flag = (err as Error & { retriesExhausted?: boolean })
+        .retriesExhausted;
+      expect(flag).toBeUndefined();
+      expect(inner.calls).toBe(1);
+    }
+  });
+
   test("uses retryAfterMs from ProviderError when present", async () => {
     const error = new ProviderError("rate limited", "anthropic", 429, {
       retryAfterMs: 30_000,
@@ -277,6 +319,58 @@ describe("RetryProvider — rate limit backoff", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// RetryProvider — ContextOverflowError short-circuit
+// ---------------------------------------------------------------------------
+
+describe("RetryProvider — ContextOverflowError short-circuit", () => {
+  test("does NOT retry ContextOverflowError even when statusCode is 429", async () => {
+    // Gemini/Vertex can surface context overflow as a 429 RESOURCE_EXHAUSTED.
+    // Retrying is deterministic waste — the oversized prompt won't shrink.
+    const error = new ContextOverflowError("prompt too long", "gemini", {
+      statusCode: 429,
+      actualTokens: 250_000,
+      maxTokens: 200_000,
+    });
+    const inner = makeFailing(error);
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBeInstanceOf(
+      ContextOverflowError,
+    );
+    // 1 call, no retries — must short-circuit before the 429 retry branch.
+    expect(inner.calls).toBe(1);
+  });
+
+  test("does NOT retry ContextOverflowError with default statusCode 400", async () => {
+    // Anthropic / OpenAI-compatible providers surface overflow as 400. Same
+    // deterministic-failure rule: never retry.
+    const error = new ContextOverflowError("prompt is too long", "anthropic");
+    const inner = makeFailing(error);
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toBeInstanceOf(
+      ContextOverflowError,
+    );
+    expect(inner.calls).toBe(1);
+  });
+
+  test("still retries a plain ProviderError with statusCode 429 (non-overflow)", async () => {
+    // Rate-limit 429s that are NOT overflow must continue to retry — this is
+    // the regression guard for the short-circuit's scope.
+    const inner = makeFailing(
+      new ProviderError("rate limited", "anthropic", 429),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "rate limited",
+    );
+    // 1 initial + DEFAULT_MAX_RETRIES retries
+    expect(inner.calls).toBe(DEFAULT_MAX_RETRIES + 1);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // RetryProvider — server error retries
 // ---------------------------------------------------------------------------
@@ -447,6 +541,41 @@ describe("RetryProvider — network error retries", () => {
     );
     expect(inner.calls).toBe(1);
   });
+
+  test("does NOT retry a ProviderError tagged with abortReason", async () => {
+    // Defensive: if any future retryable pattern matches an error carrying
+    // a daemon/user-initiated abortReason, the abortReason guard in
+    // providers/retry.ts:isRetryableError must still short-circuit it.
+    const inner = makeFailing(
+      new ProviderError(
+        "Anthropic request failed: socket closed unexpectedly",
+        "anthropic",
+        undefined,
+        { abortReason: { kind: "user_cancel", source: "test" } },
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "socket closed",
+    );
+    expect(inner.calls).toBe(1);
+  });
+
+  test("does NOT retry 'Anthropic stream timed out' (inner streamTimeoutMs fired)", async () => {
+    const inner = makeFailing(
+      new ProviderError(
+        "Anthropic API error: Anthropic stream timed out after 1800s (inner streamTimeoutMs)",
+        "anthropic",
+      ),
+    );
+    const provider = new RetryProvider(inner);
+
+    await expect(provider.sendMessage(MESSAGES)).rejects.toThrow(
+      "stream timed out",
+    );
+    expect(inner.calls).toBe(1);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -611,7 +740,7 @@ describe("RetryProvider — streaming response handling", () => {
         callCount++;
         if (callCount <= 1) {
           throw new ProviderError(
-            'Anthropic API error (undefined): {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
+            'Anthropic API error: {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
             "anthropic",
             undefined,
           );

package/src/__tests__/provider-managed-proxy-integration.test.ts

@@ -65,7 +65,7 @@ import {
 function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
   return {
     services: {
-      inference: { mode: "your-own", provider, model },
+      inference: { mode: "your-own" },
       "image-generation": {
         mode: "your-own",
         provider: "gemini",
@@ -73,6 +73,7 @@ function makeProvidersConfig(provider: string, model: string): ProvidersConfig {
       },
       "web-search": { mode: "your-own", provider: "inference-provider-native" },
     },
+    llm: { default: { provider, model } },
   };
 }
 
@@ -90,7 +91,7 @@ const DIRECT_OR_MANAGED_PROVIDER_KEYS: string[] = [
   "fireworks",
   "openrouter",
 ];
-const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini"];
+const MANAGED_FALLBACK_PROVIDERS: string[] = ["anthropic", "gemini", "openai"];
 
 function enableManagedProxy() {
   mockPlatformBaseUrl = PLATFORM_BASE;
@@ -172,14 +173,18 @@ describe("managed proxy integration — credential precedence", () => {
       },
     );
 
-    test("managed bootstrap registers anthropic and gemini only", async () => {
+    test("managed bootstrap registers anthropic, openai, and gemini", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
-      expect(listProviders()).toEqual(["anthropic", "gemini"]);
+      expect(listProviders()).toEqual(
+        expect.arrayContaining(["anthropic", "openai", "gemini"]),
+      );
+      expect(listProviders()).toHaveLength(3);
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
+      expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["openai", "fireworks", "openrouter"]) {
+      for (const p of ["fireworks", "openrouter"]) {
         expect(getProviderRoutingSource(p)).toBeUndefined();
       }
     });
@@ -205,6 +210,23 @@ describe("managed proxy integration — credential precedence", () => {
       expect(baseURL).toContain("/v1/runtime-proxy/anthropic");
     });
 
+    test("managed openai uses openai proxy path", async () => {
+      enableManagedProxy();
+      mockProviderKeys = {};
+      await initializeProviders(makeProvidersConfig("openai", "gpt-4o"));
+
+      const provider = getProvider("openai");
+
+      // Unwrap RetryProvider → OpenAIResponsesProvider to inspect the OpenAI
+      // SDK client's baseURL.
+      const retryInner = (provider as any).inner;
+      const openaiClient = (retryInner as any).client;
+
+      expect(openaiClient).toBeDefined();
+      const baseURL: string = openaiClient.baseURL;
+      expect(baseURL).toContain("/v1/runtime-proxy/openai");
+    });
+
     test("managed gemini uses gemini proxy path", async () => {
       enableManagedProxy();
       mockProviderKeys = {};
@@ -242,16 +264,18 @@ describe("managed proxy integration — credential precedence", () => {
   });
 
   describe("mixed: some user keys + managed fallback fills gaps", () => {
-    test("user key for anthropic routes direct and managed fallback only fills gemini", async () => {
+    test("user key for anthropic routes direct and managed fallback fills openai and gemini", async () => {
       enableManagedProxy();
       setUserKeysFor("anthropic");
       await initializeProviders(makeProvidersConfig("anthropic", "test-model"));
       const registered = listProviders();
       expect(registered).toContain("anthropic");
       expect(getProviderRoutingSource("anthropic")).toBe("user-key");
+      expect(registered).toContain("openai");
+      expect(getProviderRoutingSource("openai")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
-      for (const p of ["openai", "fireworks", "openrouter"]) {
+      for (const p of ["fireworks", "openrouter"]) {
         expect(registered).not.toContain(p);
         expect(getProviderRoutingSource(p)).toBeUndefined();
       }
@@ -268,6 +292,7 @@ describe("managed proxy integration — credential precedence", () => {
       expect(getProviderRoutingSource("anthropic")).toBe("managed-proxy");
       expect(registered).toContain("gemini");
       expect(getProviderRoutingSource("gemini")).toBe("managed-proxy");
+      // OpenAI has a user key so it's user-key, not managed-proxy
       for (const p of ["fireworks", "openrouter"]) {
         expect(registered).not.toContain(p);
         expect(getProviderRoutingSource(p)).toBeUndefined();
@@ -307,8 +332,8 @@ describe("managed proxy integration — ollama exclusion", () => {
 });
 
 describe("managed proxy integration — constants integrity", () => {
-  test("anthropic and gemini have metadata with managed=true and a proxyPath", () => {
-    for (const provider of ["anthropic", "gemini"]) {
+  test("anthropic, openai, and gemini have metadata with managed=true and a proxyPath", () => {
+    for (const provider of ["anthropic", "openai", "gemini"]) {
       const meta = MANAGED_PROVIDER_META[provider];
       expect(meta).toBeDefined();
       expect(meta.managed).toBe(true);
@@ -329,8 +354,14 @@ describe("managed proxy integration — constants integrity", () => {
     );
   });
 
-  test("openai-compatible providers are not managed proxy capable", () => {
-    for (const provider of ["openai", "fireworks", "openrouter"]) {
+  test("openai routes through openai proxy path", () => {
+    expect(MANAGED_PROVIDER_META.openai.proxyPath).toBe(
+      "/v1/runtime-proxy/openai",
+    );
+  });
+
+  test("fireworks and openrouter are not managed proxy capable", () => {
+    for (const provider of ["fireworks", "openrouter"]) {
       expect(MANAGED_PROVIDER_META[provider].managed).toBe(false);
       expect(MANAGED_PROVIDER_META[provider].proxyPath).toBeUndefined();
     }

package/src/__tests__/provider-registry-ollama.test.ts

@@ -19,8 +19,6 @@ describe("provider registry (ollama)", () => {
       services: {
         inference: {
           mode: "your-own",
-          provider: "ollama",
-          model: "claude-opus-4-6",
         },
         "image-generation": {
           mode: "your-own",
@@ -32,6 +30,7 @@ describe("provider registry (ollama)", () => {
           provider: "inference-provider-native",
         },
       },
+      llm: { default: { provider: "ollama", model: "claude-opus-4-6" } },
     });
 
     const provider = getProvider("ollama");

package/src/__tests__/proxy-approval-callback.test.ts

@@ -328,7 +328,6 @@ describe("createProxyApprovalCallback", () => {
       "/tmp/test-project",
       "allow",
       100,
-      undefined,
     );
   });