@vellumai/assistant 0.6.5 → 0.7.0

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

@@ -1,12 +1,9 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import {
   getAnyProviderEnvVar,
   getLlmProviderEnvVar,
   getSearchProviderEnvVar,
-  SEARCH_PROVIDER_ENV_VAR_NAMES,
 } from "../provider-env-vars.js";
 
 describe("getLlmProviderEnvVar", () => {
@@ -82,21 +79,3 @@ describe("getAnyProviderEnvVar", () => {
     expect(getAnyProviderEnvVar("unknown")).toBeUndefined();
   });
 });
-
-describe("SEARCH_PROVIDER_ENV_VAR_NAMES parity with meta/provider-env-vars.json", () => {
-  // The daemon inlines the search-provider env-var map rather than reading
-  // meta/provider-env-vars.json at runtime (compiled binary, no reliable
-  // repo-relative path). This parity check prevents drift: the inline map
-  // must stay in sync with the canonical JSON file consumed by the macOS
-  // client bundle and the CLI cloud-infra flows.
-  test("inline map matches meta/provider-env-vars.json providers", () => {
-    const repoRoot = join(process.cwd(), "..");
-    const metaPath = join(repoRoot, "meta", "provider-env-vars.json");
-    const raw = readFileSync(metaPath, "utf-8");
-    const parsed = JSON.parse(raw) as {
-      version: number;
-      providers: Record<string, string>;
-    };
-    expect(SEARCH_PROVIDER_ENV_VAR_NAMES).toEqual(parsed.providers);
-  });
-});

package/src/providers/__tests__/retry-callsite.test.ts

@@ -179,10 +179,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.effort).toBe("high");
     expect(config.speed).toBe("fast");
     expect(config.temperature).toBe(0.7);
-    // Disabled thinking is omitted entirely so providers fall back to their
-    // default behavior — matches the legacy non-callSite path which only sets
-    // `providerConfig.thinking` when `enabled === true`.
-    expect(config.thinking).toBeUndefined();
+    expect(config.thinking).toEqual({ type: "disabled" });
     // `contextWindow` and `provider` are server-side concerns and must NOT
     // leak into the per-call provider config — Anthropic rejects unknown
     // fields with `{type:"invalid_request_error", message:"contextWindow:
@@ -225,7 +222,7 @@ describe("RetryProvider — callSite resolution", () => {
     expect(config.thinking).toEqual({ type: "adaptive" });
   });
 
-  test("omits thinking when resolved config has thinking.enabled: false", async () => {
+  test("converts disabled thinking to Anthropic wire-format `{ type: 'disabled' }`", async () => {
     setLlmConfig({
       default: {
         provider: "anthropic",
@@ -249,7 +246,7 @@ describe("RetryProvider — callSite resolution", () => {
     });
 
     const config = seen?.config as Record<string, unknown>;
-    expect(config.thinking).toBeUndefined();
+    expect(config.thinking).toEqual({ type: "disabled" });
   });
 
   test("does NOT propagate temperature when resolved value is null (schema default)", async () => {

package/src/providers/anthropic/client.ts

@@ -771,22 +771,32 @@ export class AnthropicProvider implements Provider {
           return acc;
         }, []);
 
-      // Post-processing: fix consecutive same-role messages that can arise when
-      // dropping empty messages (e.g. empty assistant followed by empty user).
-      // Remove placeholder assistant messages that ended up adjacent to another
-      // assistant message, since the placeholder is no longer needed.
-      for (let i = formatted.length - 1; i > 0; i--) {
-        if (formatted[i].role !== formatted[i - 1].role) continue;
-        // For consecutive assistant messages, remove whichever one is a
-        // placeholder injected by the reduce above.
-        if (formatted[i].role === "assistant") {
-          const iContent = Array.isArray(formatted[i].content)
-            ? formatted[i].content
-            : [];
-          const prevContent = Array.isArray(formatted[i - 1].content)
-            ? formatted[i - 1].content
-            : [];
-          const isPlaceholder = (c: typeof iContent) => {
+      // Post-processing: merge consecutive same-role messages that violate
+      // Anthropic's strict user/assistant alternation requirement. These can
+      // arise from:
+      //   - Dropping empty messages in the reduce above (placeholder-adjacent)
+      //   - History reconstruction artifacts that bypass repairHistory
+      //
+      // Walk backwards so splice indices stay valid. After a merge+splice
+      // the element that was at i+1 shifts to i, potentially creating a
+      // new adjacent pair — bump i back up to recheck that position.
+      {
+        let i = formatted.length - 1;
+        while (i > 0 && i < formatted.length) {
+          if (formatted[i].role !== formatted[i - 1].role) {
+            i--;
+            continue;
+          }
+
+          const iContent = (
+            Array.isArray(formatted[i].content) ? formatted[i].content : []
+          ) as Anthropic.ContentBlockParam[];
+          const prevContent = (
+            Array.isArray(formatted[i - 1].content)
+              ? formatted[i - 1].content
+              : []
+          ) as Anthropic.ContentBlockParam[];
+          const isPlaceholder = (c: Anthropic.ContentBlockParam[]): boolean => {
             if (
               c.length !== 1 ||
               typeof c[0] === "string" ||
@@ -796,10 +806,50 @@ export class AnthropicProvider implements Provider {
             const text = (c[0] as { text?: string }).text;
             return typeof text === "string" && isPlaceholderSentinelText(text);
           };
+
           if (isPlaceholder(iContent)) {
             formatted.splice(i, 1);
+            // Removed the later element. The new formatted[i] (formerly
+            // i+1) may now be same-role as i-1, so decrement once to
+            // recheck from the correct position.
+            i--;
           } else if (isPlaceholder(prevContent)) {
             formatted.splice(i - 1, 1);
+            // Removed the earlier element — everything shifted down by 1.
+            // The element that was at i is now at i-1. Decrement so the
+            // next iteration compares the new i-1 with i-2 (or exits if
+            // i-1 is 0).
+            i--;
+          } else {
+            // Neither is a placeholder — merge content blocks into the
+            // earlier message and remove the later one. Skip the merge
+            // when either message carries tool_use or tool_result blocks;
+            // those require structural alternation for ensureToolPairing
+            // to inject the correct synthetic results downstream.
+            const hasToolBlock = (c: Anthropic.ContentBlockParam[]): boolean =>
+              c.some(
+                (b) =>
+                  typeof b !== "string" &&
+                  (b.type === "tool_use" || b.type === "tool_result"),
+              );
+            if (!hasToolBlock(prevContent) && !hasToolBlock(iContent)) {
+              formatted[i - 1] = {
+                ...formatted[i - 1],
+                content: [...prevContent, ...iContent],
+              };
+              formatted.splice(i, 1);
+              // Clamp i to the new last index — the splice may have put
+              // us past the end. If there's a new element at i (formerly
+              // i+1), it will be rechecked against the merged i-1.
+              if (i >= formatted.length) {
+                i = formatted.length - 1;
+              }
+            } else {
+              // Can't merge (tool blocks present) — leave for
+              // ensureToolPairing which handles tool_use/tool_result
+              // alternation in its own forward walk.
+              i--;
+            }
           }
         }
       }
@@ -821,8 +871,10 @@ export class AnthropicProvider implements Provider {
         // "xhigh" is an intermediate tier between "high" and "max" supported
         // by newer Anthropic models (e.g. Opus 4.7). The SDK's OutputConfig
         // type doesn't yet include it, so we widen to the internal effort
-        // union and cast when building mergedOutputConfig.
-        effort?: "low" | "medium" | "high" | "xhigh" | "max";
+        // union and cast when building mergedOutputConfig. "none" is a
+        // Vellum-wide value meaning "omit the effort param entirely" — we
+        // skip the output_config.effort field in that case.
+        effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
         speed?: "standard" | "fast";
         output_config?: Record<string, unknown>;
       };
@@ -836,7 +888,7 @@ export class AnthropicProvider implements Provider {
       const supportsEffort = !isHaiku;
       const mergedOutputConfig = {
         ...(output_config ?? {}),
-        ...(effort && supportsEffort
+        ...(effort && effort !== "none" && supportsEffort
           ? { effort: effort as Anthropic.OutputConfig["effort"] }
           : {}),
       };

package/src/providers/call-site-routing.ts

@@ -53,14 +53,18 @@ export class CallSiteRoutingProvider implements Provider {
 
   /**
    * Pick the provider to route this call through. The default provider wins
-   * unless the per-call `callSite` resolves to a different provider name and
-   * the registry can produce a Provider for it.
+   * unless the per-call `callSite` (layered with any `overrideProfile`)
+   * resolves to a different provider name and the registry can produce a
+   * Provider for it.
    */
   private selectProvider(options?: SendMessageOptions): Provider {
     const callSite = options?.config?.callSite;
     if (!callSite) return this.defaultProvider;
 
-    const resolved = resolveCallSiteConfig(callSite, getConfig().llm);
+    const overrideProfile = options?.config?.overrideProfile;
+    const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
+      overrideProfile,
+    });
     if (resolved.provider === this.defaultProvider.name) {
       return this.defaultProvider;
     }

package/src/providers/fireworks/client.ts

@@ -19,6 +19,9 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
       providerName: "fireworks",
       providerLabel: "Fireworks",
       streamTimeoutMs: options.streamTimeoutMs,
+      // Fireworks' OpenAI-compatible chat-completions API documents only
+      // low|medium|high for reasoning_effort; sending "xhigh" 4xxs upstream.
+      maxReasoningEffort: "high",
     });
   }
 }

package/src/providers/gemini/client.ts

@@ -27,6 +27,13 @@ import {
 const GEMINI_CONTEXT_OVERFLOW_TOKEN_PATTERNS =
   /token.?count.*exceeds|exceeds.*maximum.*tokens|prompt.?is.?too.?long|too.?many.?(?:input.?)?tokens|input.?too.?long|context.?length.?exceeded/i;
 
+const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
+  "context_engineering_is_the_way_to_go";
+
+export function isGemini3Model(model: string): boolean {
+  return model.startsWith("gemini-3") || model.startsWith("models/gemini-3");
+}
+
 /**
  * Detect Gemini's context-overflow signals on an `ApiError`. Gemini surfaces
  * this condition via its "RESOURCE_EXHAUSTED" category. The Gemini SDK's
@@ -155,9 +162,10 @@ export class GeminiProvider implements Provider {
     const configObj = config as Record<string, unknown> | undefined;
     const maxTokens = configObj?.max_tokens as number | undefined;
     const modelOverride = configObj?.model as string | undefined;
+    const activeModel = modelOverride ?? this.model;
 
     try {
-      const geminiContents = this.toGeminiContents(messages);
+      const geminiContents = this.toGeminiContents(messages, activeModel);
 
       const geminiConfig: genai.GenerateContentConfig = {};
 
@@ -192,15 +200,27 @@ export class GeminiProvider implements Provider {
         id: string;
         name: string;
         args: Record<string, unknown>;
+        thoughtSignature?: string;
       }> = [];
+      const appendFunctionCall = (
+        fc: genai.FunctionCall,
+        thoughtSignature?: string,
+      ) => {
+        functionCalls.push({
+          id: fc.id ?? `call_${crypto.randomUUID()}`,
+          name: fc.name ?? "",
+          args: fc.args ?? {},
+          thoughtSignature,
+        });
+      };
       let finishReason = "unknown";
       let promptTokens = 0;
       let outputTokens = 0;
-      let responseModel = modelOverride ?? this.model;
+      let responseModel = activeModel;
 
       try {
         const stream = await this.client.models.generateContentStream({
-          model: modelOverride ?? this.model,
+          model: activeModel,
           contents: geminiContents,
           config: geminiConfig,
         });
@@ -213,15 +233,24 @@ export class GeminiProvider implements Provider {
             onEvent?.({ type: "text_delta", text: chunkText });
           }
 
-          // Extract function calls
-          const calls = chunk.functionCalls;
-          if (calls) {
-            for (const fc of calls) {
-              functionCalls.push({
-                id: fc.id ?? `call_${crypto.randomUUID()}`,
-                name: fc.name ?? "",
-                args: fc.args ?? {},
-              });
+          // Extract function calls. Candidate parts carry provider metadata
+          // that the SDK's convenience getter omits, so prefer them when present.
+          const functionCallParts =
+            chunk.candidates?.[0]?.content?.parts?.filter(
+              (part) => part.functionCall,
+            ) ?? [];
+          if (functionCallParts.length > 0) {
+            for (const part of functionCallParts) {
+              const fc = part.functionCall;
+              if (!fc) continue;
+              appendFunctionCall(fc, part.thoughtSignature);
+            }
+          } else {
+            const calls = chunk.functionCalls;
+            if (calls) {
+              for (const fc of calls) {
+                appendFunctionCall(fc);
+              }
             }
           }
 
@@ -250,16 +279,22 @@ export class GeminiProvider implements Provider {
         content.push({ type: "text", text: fullText });
       }
       for (const fc of functionCalls) {
-        content.push({
+        const block: ContentBlock = {
           type: "tool_use",
           id: fc.id,
           name: fc.name,
           input: fc.args,
-        });
+        };
+        if (fc.thoughtSignature) {
+          block.providerMetadata = {
+            gemini: { thoughtSignature: fc.thoughtSignature },
+          };
+        }
+        content.push(block);
       }
 
       const rawRequest = {
-        model: modelOverride ?? this.model,
+        model: activeModel,
         contents: geminiContents,
         config: geminiConfig,
       };
@@ -322,7 +357,10 @@ export class GeminiProvider implements Provider {
   }
 
   /** Convert neutral messages to Gemini Content[] format. */
-  private toGeminiContents(messages: Message[]): genai.Content[] {
+  private toGeminiContents(
+    messages: Message[],
+    model: string,
+  ): genai.Content[] {
     const result: genai.Content[] = [];
 
     // Build a map from tool_use id → function name so tool_result blocks
@@ -341,6 +379,8 @@ export class GeminiProvider implements Provider {
       const { parts, toolResultImageParts } = this.toGeminiParts(
         msg.content,
         toolCallNames,
+        model,
+        role,
       );
       if (parts.length > 0) {
         result.push({ role, parts });
@@ -360,6 +400,8 @@ export class GeminiProvider implements Provider {
   private toGeminiParts(
     blocks: ContentBlock[],
     toolCallNames: Map<string, string>,
+    model: string,
+    role: "model" | "user",
   ): { parts: genai.Part[]; toolResultImageParts: genai.Part[] } {
     const parts: genai.Part[] = [];
     const toolResultImageParts: genai.Part[] = [];
@@ -393,12 +435,20 @@ export class GeminiProvider implements Provider {
           }
           break;
         case "tool_use":
-          parts.push({
-            functionCall: {
-              name: block.name,
-              args: block.input,
-            },
-          });
+          {
+            const functionCallPart: genai.Part = {
+              functionCall: {
+                name: block.name,
+                args: block.input,
+              },
+            };
+            const thoughtSignature =
+              block.providerMetadata?.gemini?.thoughtSignature;
+            if (thoughtSignature) {
+              functionCallPart.thoughtSignature = thoughtSignature;
+            }
+            parts.push(functionCallPart);
+          }
           break;
         case "tool_result": {
           let outputText = block.content;
@@ -443,9 +493,33 @@ export class GeminiProvider implements Provider {
       }
     }
 
+    if (role === "model") {
+      this.addGemini3UnsignedToolCallFallback(parts, model);
+    }
+
     return { parts, toolResultImageParts };
   }
 
+  private addGemini3UnsignedToolCallFallback(
+    parts: genai.Part[],
+    model: string,
+  ): void {
+    if (!isGemini3Model(model)) return;
+
+    const functionCallParts = parts.filter((part) => part.functionCall);
+    if (functionCallParts.length === 0) return;
+
+    const hasRealThoughtSignature = functionCallParts.some((part) =>
+      Boolean(part.thoughtSignature),
+    );
+    if (hasRealThoughtSignature) return;
+
+    const firstFunctionCallPart = functionCallParts[0];
+    if (!firstFunctionCallPart) return;
+    firstFunctionCallPart.thoughtSignature =
+      GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE;
+  }
+
   private supportsGeminiInlineFile(mimeType: string): boolean {
     return mimeType === "application/pdf";
   }

package/src/providers/managed-proxy/context.ts

@@ -93,18 +93,6 @@ export async function managedFallbackEnabledFor(
   return await hasManagedProxyPrereqs();
 }
 
-/**
- * Synchronous check for whether managed proxy prerequisites were satisfied
- * the last time `resolveManagedProxyContext()` ran.
- *
- * Returns `false` before the first async resolution or when the API key is
- * missing. Safe for use in synchronous code paths (e.g. system prompt
- * building) that cannot await the credential store.
- */
-export function isManagedProxyEnabledSync(): boolean {
-  return _managedProxyEnabled;
-}
-
 /** @internal Test-only: reset the cached managed-proxy-enabled flag. */
 export function _resetManagedProxyEnabledCache(): void {
   _managedProxyEnabled = false;