@vellumai/assistant 0.8.5 → 0.8.7

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

@@ -74,7 +74,7 @@ function makeProvider(
 ): Provider {
   return {
     name,
-    async sendMessage(_messages, _tools, _systemPrompt, options) {
+    async sendMessage(_messages: Message[], options?: SendMessageOptions) {
       onCall(options);
       const config = options?.config as Record<string, unknown> | undefined;
       return makeResponse(
@@ -116,7 +116,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -155,7 +155,7 @@ describe("RetryProvider — callSite resolution", () => {
       { forwardUsageAttributionHeaders: true },
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: {
         callSite: "memoryRetrieval",
         overrideProfile: "conversation-profile",
@@ -197,7 +197,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -227,7 +227,7 @@ describe("RetryProvider — callSite resolution", () => {
       { forwardUsageAttributionHeaders: true },
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -256,7 +256,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -288,7 +288,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "heartbeatAgent" },
     });
 
@@ -327,7 +327,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -358,7 +358,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -383,7 +383,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -417,7 +417,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -446,7 +446,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "memoryRetrieval" },
     });
 
@@ -474,7 +474,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -503,7 +503,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -528,7 +528,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent" },
     });
 
@@ -550,7 +550,7 @@ describe("RetryProvider — callSite resolution", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent", model: "explicit-override" },
     });
 
@@ -587,7 +587,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       // Hardcoded per-call temperature — the pattern that caused the PR
       // #29560 bug class. Without the guard this would forward to Anthropic
       // and 400.
@@ -619,7 +619,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "recall", temperature: 0 },
     });
 
@@ -645,7 +645,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent", temperature: 1 },
     });
 
@@ -674,7 +674,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent", temperature: 0.7 },
     });
 
@@ -700,7 +700,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent", temperature: 0.7 },
     });
 
@@ -730,7 +730,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { callSite: "mainAgent", temperature: 0.7 },
     });
 
@@ -759,7 +759,7 @@ describe("RetryProvider — thinking/temperature conflict guard", () => {
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: {
         callSite: "trustRuleSuggestion",
         temperature: 0.7,
@@ -794,7 +794,7 @@ describe("RetryProvider — no callSite (pre-resolved config passes through)", (
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: { model: "explicit-model", max_tokens: 1234 },
     });
 
@@ -817,7 +817,7 @@ describe("RetryProvider — no callSite (pre-resolved config passes through)", (
       }),
     );
 
-    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
       config: {
         model: "explicit-model",
         usageAttributionHeaders: {

package/src/providers/__tests__/satellite-connection-routing.test.ts

@@ -216,9 +216,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
 
     const response = await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-      [],
-      undefined,
-      { config: { callSite: "replySuggestion" } },
+      { tools: [], config: { callSite: "replySuggestion" } },
     );
 
     // Hard gate #1: connection-resolution hook fired with the right name.
@@ -261,9 +259,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
 
     await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-      [],
-      undefined,
-      { config: { callSite: "memoryRetrieval" } },
+      { tools: [], config: { callSite: "memoryRetrieval" } },
     );
 
     // No connection lookup attempted at all.
@@ -303,9 +299,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
     try {
       await wrapped.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-        [],
-        undefined,
-        { config: { callSite: "memoryRetrieval" } },
+        { tools: [], config: { callSite: "memoryRetrieval" } },
       );
     } catch (err) {
       caught = err;
@@ -346,9 +340,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
     try {
       await wrapped.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-        [],
-        undefined,
-        { config: { callSite: "conversationTitle" } },
+        { tools: [], config: { callSite: "conversationTitle" } },
       );
     } catch (err) {
       caught = err;
@@ -406,9 +398,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
     try {
       await wrapped.sendMessage(
         [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-        [],
-        undefined,
-        { config: { callSite: "replySuggestion" } },
+        { tools: [], config: { callSite: "replySuggestion" } },
       );
     } catch (err) {
       caught = err;
@@ -467,9 +457,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
     // This MUST NOT throw — the resolve failure is contained.
     await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-      [],
-      undefined,
-      { config: { callSite: "replySuggestion" } },
+      { tools: [], config: { callSite: "replySuggestion" } },
     );
 
     // The resolver DID fire (we got past the connection lookup + validation).
@@ -498,9 +486,7 @@ describe("CallSiteRoutingProvider honors provider_connection (satellite gate)",
 
     await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-      [],
-      undefined,
-      {},
+      { tools: [] },
     );
 
     expect(resolveProviderCalls.length).toBe(0);

package/src/providers/anthropic/client.ts

@@ -12,7 +12,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../types.js";
 import {
   ContextOverflowError,
@@ -809,11 +808,9 @@ export class AnthropicProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
-    const { config, onEvent, signal } = options ?? {};
+    const { tools, systemPrompt, config, onEvent, signal } = options ?? {};
     const cacheTtl: "5m" | "1h" =
       ((config as Record<string, unknown> | undefined)?.cacheTtl as
         | "5m"
@@ -827,6 +824,13 @@ export class AnthropicProvider implements Provider {
     const disableTurnStartCache =
       (config as Record<string, unknown> | undefined)?.disableTurnStartCache ===
       true;
+    // When true, the latest user message carries per-turn-volatile content
+    // (e.g. an injected memory block), so the long-TTL anchor must skip it and
+    // land on the most recent stable user message instead. See the breakpoint
+    // block below.
+    const mutableLatestUserMessage =
+      (config as Record<string, unknown> | undefined)
+        ?.mutableLatestUserMessage === true;
     let sentMessages: Anthropic.MessageParam[] | undefined;
     const startedAt = Date.now();
     // Hoisted so the catch block can distinguish our inner stream timeout
@@ -1015,6 +1019,7 @@ export class AnthropicProvider implements Provider {
         output_config,
         cacheTtl: _cacheTtl,
         disableTurnStartCache: _disableTurnStartCache,
+        mutableLatestUserMessage: _mutableLatestUserMessage,
         max_tokens: callerMaxTokens,
         usageAttributionHeaders,
         ...restConfig
@@ -1145,7 +1150,21 @@ export class AnthropicProvider implements Provider {
         }
       };
       const turnStartIdx = findUserTextMsgIdx(msgs.length - 1);
-      if (turnStartIdx >= 0 && !disableTurnStartCache) {
+      // When the latest user message is volatile (`mutableLatestUserMessage`)
+      // and it is itself the turn-start (first-of-turn, no tool-use loop yet),
+      // skip the long-TTL anchor here — it would land on per-turn-varying
+      // content and never hit again. The previous-turn anchor below becomes the
+      // primary stable breakpoint. During tool-use loops (`turnStartIdx <
+      // msgs.length - 1`) the turn-start block is fixed within the turn, so
+      // behavior is unchanged. Independent from `disableTurnStartCache`, which
+      // expresses a different intent (one-shot callers with no future hit).
+      const skipVolatileTurnStartAnchor =
+        mutableLatestUserMessage && turnStartIdx === msgs.length - 1;
+      if (
+        turnStartIdx >= 0 &&
+        !disableTurnStartCache &&
+        !skipVolatileTurnStartAnchor
+      ) {
         applyCacheControlToLastBlock(turnStartIdx);
       }
 

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

@@ -24,7 +24,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import { getDb } from "../memory/db-connection.js";
-import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
+import {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "./connection-model-compat.js";
 import {
   ConnectionResolutionError,
   tryResolveProviderForConnectionName,
@@ -36,7 +39,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "./types.js";
 
 export class CallSiteRoutingProvider implements Provider {
@@ -90,20 +92,13 @@ export class CallSiteRoutingProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const target = await this.selectProvider(options);
     const isRouted = target !== this.defaultProvider;
 
     const doSend = async (): Promise<ProviderResponse> => {
-      const response = await target.sendMessage(
-        messages,
-        tools,
-        systemPrompt,
-        options,
-      );
+      const response = await target.sendMessage(messages, options);
       // Also stamp actualProvider on the response so that handleUsage /
       // llm_call_finished (which read event.actualProvider, not provider.name)
       // attribute the call to the right provider.
@@ -146,25 +141,32 @@ export class CallSiteRoutingProvider implements Provider {
     if (!callSite) return this.defaultProvider;
 
     const overrideProfile = options?.config?.overrideProfile;
+    // Forward the per-conversation mix seed so transport selection picks the
+    // same mix arm as wire-param normalization in `retry.ts` — otherwise a mix
+    // spanning providers could route the transport to a different arm than the
+    // request params.
+    const selectionSeed = options?.config?.selectionSeed;
     const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
       overrideProfile,
+      selectionSeed,
     });
 
     let connectionName = resolved.provider_connection;
 
     // When no connection is set and the provider differs from the default,
-    // auto-resolve to an active connection for the provider (handles the
-    // "Any active X connection" case where the profile set provider but
-    // not provider_connection, and the merge didn't inherit one).
+    // auto-resolve a connection for the provider (handles the case where the
+    // profile set provider but not provider_connection, and the merge didn't
+    // inherit one).
+    let autoResolveCandidates:
+      | import("./inference/auth.js").ProviderConnection[]
+      | undefined;
     if (!connectionName && resolved.provider !== this.defaultProvider.name) {
       try {
-        const candidates = listConnections(getDb(), {
+        autoResolveCandidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = autoResolveCandidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           connectionName = active.name;
@@ -188,6 +190,20 @@ export class CallSiteRoutingProvider implements Provider {
       return this.defaultProvider;
     }
 
+    if (autoResolveCandidates) {
+      const incompatMsg = describeSubscriptionModelIncompatibility(
+        autoResolveCandidates,
+        resolved.model,
+      );
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          "<resolved-callsite>",
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
+    }
+
     throw new ConnectionResolutionError(
       "<resolved-callsite>",
       "missing_connection",

package/src/providers/connection-model-compat.ts

@@ -36,3 +36,26 @@ export function isConnectionCompatibleWithModel(
   if (!model) return true;
   return isCodexSubscriptionModel(model);
 }
+
+/**
+ * When auto-resolution found candidates but none were model-compatible,
+ * return a user-facing explanation if the incompatibility is specifically
+ * due to all candidates being `oauth_subscription` (ChatGPT) connections.
+ *
+ * Returns `null` when the incompatibility has a different cause (callers
+ * should fall through to their existing generic error).
+ */
+export function describeSubscriptionModelIncompatibility(
+  candidates: Pick<ProviderConnection, "auth">[],
+  model: string | undefined,
+): string | null {
+  if (!model || candidates.length === 0) return null;
+  if (candidates.some((c) => isConnectionCompatibleWithModel(c, model))) {
+    return null;
+  }
+  const allSubscription = candidates.every(
+    (c) => c.auth.type === "oauth_subscription",
+  );
+  if (!allSubscription) return null;
+  return `Model "${model}" isn't available through your ChatGPT subscription. Select a supported model or add an OpenAI API key connection.`;
+}

package/src/providers/connection-resolution.ts

@@ -30,7 +30,10 @@
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getDb } from "../memory/db-connection.js";
 import { getLogger } from "../util/logger.js";
-import { isConnectionCompatibleWithModel } from "./connection-model-compat.js";
+import {
+  describeSubscriptionModelIncompatibility,
+  isConnectionCompatibleWithModel,
+} from "./connection-model-compat.js";
 import { getConnection, listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
 import { resolveProviderFromConnection } from "./registry.js";
@@ -52,7 +55,8 @@ export class ConnectionResolutionError extends Error {
       | "lookup_failed"
       | "not_found"
       | "provider_mismatch"
-      | "missing_connection",
+      | "missing_connection"
+      | "model_incompatible",
     message: string,
     public readonly cause?: unknown,
   ) {
@@ -116,12 +120,12 @@ export async function tryResolveProviderForConnectionName(
     // "anthropic-managed" leaked through). Try to find an active connection
     // for the expected provider before giving up.
     let resolved = false;
+    let mismatchCandidates: import("./inference/auth.js").ProviderConnection[] | undefined;
     try {
       const db = getDb();
-      const candidates = listConnections(db, { provider: expectedProvider });
-      const active = candidates.find(
-        (c) =>
-          c.status === "active" && isConnectionCompatibleWithModel(c, model),
+      mismatchCandidates = listConnections(db, { provider: expectedProvider });
+      const active = mismatchCandidates.find((c) =>
+        isConnectionCompatibleWithModel(c, model),
       );
       if (active) {
         log.info(
@@ -130,7 +134,7 @@ export async function tryResolveProviderForConnectionName(
             resolvedConnection: active.name,
             expectedProvider,
           },
-          "Auto-resolved stale provider_connection to matching active connection",
+          "Auto-resolved stale provider_connection to matching connection",
         );
         connection = active;
         resolved = true;
@@ -139,6 +143,16 @@ export async function tryResolveProviderForConnectionName(
       // DB not available — fall through to the original error.
     }
     if (!resolved) {
+      const incompatMsg = mismatchCandidates
+        ? describeSubscriptionModelIncompatibility(mismatchCandidates, model)
+        : null;
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          connectionName,
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
       throw new ConnectionResolutionError(
         connectionName,
         "provider_mismatch",
@@ -146,13 +160,6 @@ export async function tryResolveProviderForConnectionName(
       );
     }
   }
-  if (connection.status === "disabled") {
-    log.debug(
-      { connectionName, provider: connection.provider },
-      "provider_connection is disabled — returning null",
-    );
-    return null;
-  }
   // `resolveProviderFromConnection` reaches into auth resolution (credential
   // reads, managed-proxy context). A transient failure there is a soft
   // miss — log and return null so the caller can treat it the same as
@@ -160,7 +167,7 @@ export async function tryResolveProviderForConnectionName(
   // catch is specifically for in-flight failures that should not take
   // dispatch offline.
   try {
-    return await resolveProviderFromConnection(connection, config);
+    return await resolveProviderFromConnection(connection, config, { model });
   } catch (err) {
     log.warn(
       { err, connectionName },
@@ -196,15 +203,14 @@ export async function resolveDefaultProvider(
     // provider without a connection ("Any active" selection), and the merge
     // cleared or failed to inherit one. Try to find an active connection
     // for the provider before giving up.
+    let autoResolveCandidates: import("./inference/auth.js").ProviderConnection[] | undefined;
     if (resolved.provider) {
       try {
-        const candidates = listConnections(getDb(), {
+        autoResolveCandidates = listConnections(getDb(), {
           provider: resolved.provider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = autoResolveCandidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           log.info(
@@ -218,6 +224,19 @@ export async function resolveDefaultProvider(
       }
     }
     if (!connectionName) {
+      const incompatMsg = autoResolveCandidates
+        ? describeSubscriptionModelIncompatibility(
+            autoResolveCandidates,
+            resolved.model,
+          )
+        : null;
+      if (incompatMsg) {
+        throw new ConnectionResolutionError(
+          "<llm.default>",
+          "model_incompatible",
+          incompatMsg,
+        );
+      }
       throw new ConnectionResolutionError(
         "<llm.default>",
         "missing_connection",

package/src/providers/fireworks/client.ts

@@ -34,6 +34,7 @@ export class FireworksProvider extends OpenAIChatCompletionsProvider {
       // overrides (e.g. DeepSeek V4 → "max") come from
       // {@link resolveMaxReasoningEffort}.
       maxReasoningEffort: "high",
+      assistantReasoningField: "reasoning_content",
     });
   }