@vellumai/assistant 0.6.3 → 0.6.5

package/src/providers/retry.ts

@@ -1,3 +1,5 @@
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { getConfig } from "../config/loader.js";
 import { ProviderError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -7,13 +9,13 @@ import {
   isRetryableNetworkError,
   sleep,
 } from "../util/retry.js";
-import { isModelIntent, resolveModelIntent } from "./model-intents.js";
-import type {
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolDefinition,
+import {
+  isContextOverflowError,
+  type Message,
+  type Provider,
+  type ProviderResponse,
+  type SendMessageOptions,
+  type ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("retry");
@@ -26,6 +28,13 @@ const EFFORT_SUPPORTED_PROVIDERS = new Set([
   "fireworks",
 ]);
 
+/**
+ * Providers that consume the `thinking` config. Anthropic uses it directly on
+ * the wire; OpenRouter translates it into its unified `reasoning` parameter so
+ * users can control extended thinking on Anthropic models served via OpenRouter.
+ */
+const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter"]);
+
 /** Patterns that indicate a transient streaming corruption from the SDK. */
 const RETRYABLE_STREAM_PATTERNS = [
   "Unexpected event order",
@@ -54,6 +63,19 @@ function isRetryableProviderMessage(error: unknown): boolean {
 }
 
 function isRetryableError(error: unknown): boolean {
+  // Context overflow is deterministic — retrying the same oversized prompt
+  // will never succeed. Short-circuit before the generic 429/5xx check so
+  // ContextOverflowError (which extends ProviderError and may carry a 429
+  // statusCode on Gemini/Vertex) never triggers exponential backoff.
+  if (isContextOverflowError(error)) return false;
+  // Daemon/user-initiated aborts are never retryable. The catch-site tags
+  // these with `abortReason` exactly when `signal.aborted` was true at the
+  // time of failure, so this short-circuits before any message-based pattern
+  // matches — which matters because transport-level aborts (retryable) and
+  // caller-cancels both surface as "Request was aborted" from the SDK.
+  if (error instanceof ProviderError && error.abortReason !== undefined) {
+    return false;
+  }
   if (error instanceof ProviderError && error.statusCode !== undefined) {
     if (error.statusCode === 429 || error.statusCode >= 500) return true;
   }
@@ -62,6 +84,27 @@ function isRetryableError(error: unknown): boolean {
   return isRetryableNetworkError(error);
 }
 
+/**
+ * Normalize per-call options before handing them to the wrapped provider.
+ *
+ * When `config.callSite` is set, resolves model/maxTokens/effort/speed/
+ * temperature/thinking via `resolveCallSiteConfig` and writes them into
+ * `nextConfig` using the wire-format names that downstream provider clients
+ * consume (`max_tokens` snake-case for the token cap; camelCase for the rest,
+ * which matches the resolver's shape). Per-call explicit overrides on the
+ * original `config` object win over the resolved values, so callers can pin
+ * a model or other parameter for a single request. `contextWindow` and
+ * `provider` are intentionally excluded from the written fields — they are
+ * server-side routing/overflow concerns, not provider request parameters,
+ * and forwarding them would leak unknown fields into provider request bodies
+ * (strict-schema clients like Anthropic reject the request).
+ *
+ * Whether or not `callSite` is set, this function applies per-provider
+ * stripping (`thinking`/`effort`/`speed`) based on the wrapped provider's
+ * name — agent-loop callers that pre-resolve provider/model still need this
+ * stripping so they don't accidentally send Anthropic-only knobs to OpenAI
+ * etc.
+ */
 function normalizeSendMessageOptions(
   providerName: string,
   options?: SendMessageOptions,
@@ -69,37 +112,111 @@ function normalizeSendMessageOptions(
   const config = options?.config;
   if (!config) return options;
 
-  const explicitModel =
-    typeof config.model === "string" && config.model.trim().length > 0
-      ? config.model.trim()
-      : undefined;
-  const intent = isModelIntent(config.modelIntent)
-    ? config.modelIntent
-    : undefined;
-  const hasIntent = config.modelIntent !== undefined;
-
-  const needsThinkingStrip =
-    providerName !== "anthropic" && config.thinking !== undefined;
-  const needsEffortStrip =
-    !EFFORT_SUPPORTED_PROVIDERS.has(providerName) && config.effort !== undefined;
-  const needsSpeedStrip =
-    providerName !== "anthropic" && config.speed !== undefined;
+  const nextConfig: Record<string, unknown> = { ...config };
+
+  if (config.callSite !== undefined) {
+    const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm);
+
+    const explicitModel =
+      typeof config.model === "string" && config.model.trim().length > 0
+        ? config.model.trim()
+        : undefined;
 
+    // Routing key is consumed by the RetryProvider layer and must not leak
+    // downstream.
+    delete nextConfig.callSite;
+
+    // Apply resolved values, letting per-call explicit fields win where set.
+    nextConfig.model = explicitModel ?? resolved.model;
+    if (nextConfig.max_tokens === undefined) {
+      nextConfig.max_tokens = resolved.maxTokens;
+    }
+    if (nextConfig.effort === undefined) {
+      nextConfig.effort = resolved.effort;
+    }
+    if (nextConfig.speed === undefined) {
+      nextConfig.speed = resolved.speed;
+    }
+    // `temperature` defaults to `null` in the LLM schema (meaning "no opinion
+    // — let the provider pick its own default"). Only forward when the
+    // resolved value is an actual number; passing `temperature: null` to
+    // provider clients would either be a wire error or silently override
+    // sensible provider defaults. Mirrors the legacy non-callSite path which
+    // never set `temperature` on `providerConfig`.
+    if (
+      nextConfig.temperature === undefined &&
+      resolved.temperature !== null &&
+      resolved.temperature !== undefined
+    ) {
+      nextConfig.temperature = resolved.temperature;
+    }
+    if (nextConfig.thinking === undefined) {
+      // Convert the schema-shape `{ enabled, streamThinking }` into the
+      // Anthropic wire-format `{ type: "adaptive" }` (or omit when disabled).
+      // Mirrors the non-callSite path in `agent/loop.ts` which sets
+      // `providerConfig.thinking = { type: "adaptive" }` only when enabled.
+      // Without this conversion, `thinking` arrives at `AnthropicProvider`
+      // with a shape the SDK doesn't accept (`ThinkingConfigParam` requires
+      // a `type` discriminator), and OpenRouter's truthy check would treat
+      // a disabled config as enabled.
+      if (resolved.thinking?.enabled === true) {
+        nextConfig.thinking = { type: "adaptive" };
+      }
+    }
+    // Forward OpenRouter-only routing preferences so `OpenRouterProvider` can
+    // translate `openrouter.only` into the wire-format `provider: { only: [...] }`
+    // body field on both the OpenAI-compat and Anthropic-compat endpoints.
+    if (
+      providerName === "openrouter" &&
+      nextConfig.openrouter === undefined &&
+      Array.isArray(resolved.openrouter?.only) &&
+      resolved.openrouter.only.length > 0
+    ) {
+      nextConfig.openrouter = { only: resolved.openrouter.only };
+    }
+    // `contextWindow` and `provider` are server-side concerns, not provider
+    // request parameters: `contextWindow` is consumed by the agent loop's
+    // overflow recovery and the conversation manager directly from
+    // `config.llm.default.contextWindow.*`; `provider` selection is handled
+    // by `CallSiteRoutingProvider` upstream. Forwarding them as per-call
+    // config leaks unknown fields into provider request bodies — Anthropic
+    // (and other strict-schema clients) reject the request with
+    // "Extra inputs are not permitted".
+  }
+
+  // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
+  // signal for its unified reasoning parameter. Strip it for other providers.
   if (
-    !hasIntent &&
-    explicitModel === config.model &&
-    !needsThinkingStrip &&
-    !needsEffortStrip &&
-    !needsSpeedStrip
+    !THINKING_AWARE_PROVIDERS.has(providerName) &&
+    nextConfig.thinking !== undefined
   ) {
-    return options;
+    delete nextConfig.thinking;
   }
 
-  const nextConfig: Record<string, unknown> = { ...config };
-  delete nextConfig.modelIntent;
-
-  // thinking is Anthropic-specific; strip it for other providers
-  if (providerName !== "anthropic" && nextConfig.thinking !== undefined) {
+  // Anthropic (and OpenRouter fronting Anthropic) rejects requests that
+  // combine extended thinking with forced tool use (`tool_choice.type` of
+  // `"tool"` or `"any"`).  Strip thinking when both are present so the
+  // request doesn't fail with a 400 "Thinking may not be enabled when
+  // tool_choice forces tool use."  `tool_choice: { type: "auto" }` is
+  // compatible with thinking and left untouched.
+  //
+  // For OpenRouter, only strip when routing to an `anthropic/*` model —
+  // non-Anthropic reasoning models (e.g. xAI Grok) translate `thinking`
+  // into OpenRouter's `reasoning` parameter via `buildExtraCreateParams`
+  // and may support reasoning with forced tool_choice.
+  const isThinkingForcedToolConflict = (() => {
+    if (nextConfig.thinking == null) return false;
+    const tc = nextConfig.tool_choice as Record<string, unknown> | undefined;
+    if (tc == null || (tc.type !== "tool" && tc.type !== "any")) return false;
+    if (providerName === "anthropic") return true;
+    if (providerName === "openrouter") {
+      const model =
+        typeof nextConfig.model === "string" ? nextConfig.model : "";
+      return model.startsWith("anthropic/");
+    }
+    return false;
+  })();
+  if (isThinkingForcedToolConflict) {
     delete nextConfig.thinking;
   }
 
@@ -116,12 +233,10 @@ function normalizeSendMessageOptions(
     delete nextConfig.speed;
   }
 
-  if (explicitModel) {
-    nextConfig.model = explicitModel;
-  } else if (intent) {
-    nextConfig.model = resolveModelIntent(providerName, intent);
-  } else {
-    delete nextConfig.model;
+  // `openrouter.only` is OpenRouter-specific routing; strip for other
+  // providers so strict-schema clients don't see an unknown field.
+  if (providerName !== "openrouter" && nextConfig.openrouter !== undefined) {
+    delete nextConfig.openrouter;
   }
 
   return {
@@ -130,9 +245,21 @@ function normalizeSendMessageOptions(
   };
 }
 
+/**
+ * `RetryProvider` sets `retriesExhausted = true` on the final thrown error
+ * when the retry loop burned through all attempts against a retryable error
+ * (transient network, 5xx, provider-overloaded, mid-stream corruption).
+ * Consumers can read it via `(err as { retriesExhausted?: boolean })` to
+ * suppress Sentry captures for user-network-flap noise — the retry loop
+ * already did its job, and no engineering action would change the outcome.
+ */
 export class RetryProvider implements Provider {
   public readonly name: string;
 
+  get tokenEstimationProvider(): string | undefined {
+    return this.inner.tokenEstimationProvider;
+  }
+
   constructor(private readonly inner: Provider) {
     this.name = inner.name;
   }
@@ -144,6 +271,7 @@ export class RetryProvider implements Provider {
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     let lastError: unknown;
+    let didRetry = false;
 
     const normalizedOptions = normalizeSendMessageOptions(this.name, options);
 
@@ -191,14 +319,32 @@ export class RetryProvider implements Provider {
             },
             "Retrying after transient error",
           );
+          didRetry = true;
           await sleep(delay);
           continue;
         }
 
+        // If we exhausted retries on a retryable error, tag the error so
+        // downstream consumers (Sentry capture, etc.) can recognize that the
+        // retry loop already tried its best. The catch-site logic above only
+        // stops retrying when either (a) retries are exhausted, or (b) the
+        // error isn't retryable — so we check the retryable predicate here to
+        // distinguish the two cases.
+        if (didRetry && isRetryableError(error) && error instanceof Error) {
+          (error as Error & { retriesExhausted?: boolean }).retriesExhausted =
+            true;
+        }
+
         throw error;
       }
     }
 
+    // Unreachable in practice — the loop body always either returns or throws —
+    // but mark the last error in case execution somehow falls through.
+    if (lastError instanceof Error && isRetryableError(lastError)) {
+      (lastError as Error & { retriesExhausted?: boolean }).retriesExhausted =
+        true;
+    }
     throw lastError;
   }
 }

package/src/providers/speech-to-text/__tests__/provider-catalog.test.ts

@@ -0,0 +1,251 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getCredentialProvider,
+  getProviderEntry,
+  listCredentialProviderNames,
+  listProviderEntries,
+  listProviderIds,
+  supportsBoundary,
+  supportsDiarization,
+} from "../provider-catalog.js";
+
+// ---------------------------------------------------------------------------
+// Catalog invariants
+// ---------------------------------------------------------------------------
+
+describe("STT provider catalog", () => {
+  // -----------------------------------------------------------------------
+  // Stable IDs
+  // -----------------------------------------------------------------------
+
+  test("listProviderIds returns all known provider IDs", () => {
+    const ids = listProviderIds();
+    expect(ids).toContain("openai-whisper");
+    expect(ids).toContain("deepgram");
+    expect(ids).toContain("google-gemini");
+  });
+
+  test("listProviderIds returns IDs in deterministic insertion order", () => {
+    const first = listProviderIds();
+    const second = listProviderIds();
+    expect(first).toEqual(second);
+  });
+
+  test("every ID returned by listProviderIds has a catalog entry", () => {
+    for (const id of listProviderIds()) {
+      expect(getProviderEntry(id)).toBeDefined();
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Credential provider names
+  // -----------------------------------------------------------------------
+
+  test("listCredentialProviderNames returns deduplicated names", () => {
+    const names = listCredentialProviderNames();
+    const unique = new Set(names);
+    expect(names.length).toBe(unique.size);
+  });
+
+  test("listCredentialProviderNames includes expected providers", () => {
+    const names = listCredentialProviderNames();
+    // openai-whisper maps to "openai", deepgram maps to "deepgram", google-gemini maps to "gemini"
+    expect(names).toContain("openai");
+    expect(names).toContain("deepgram");
+    expect(names).toContain("gemini");
+  });
+
+  test("listCredentialProviderNames returns names in deterministic order", () => {
+    const first = listCredentialProviderNames();
+    const second = listCredentialProviderNames();
+    expect(first).toEqual(second);
+  });
+
+  // -----------------------------------------------------------------------
+  // Entry-level invariants
+  // -----------------------------------------------------------------------
+
+  test("every entry has a non-empty credentialProvider", () => {
+    for (const entry of listProviderEntries()) {
+      expect(entry.credentialProvider.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("every entry has at least one supported boundary", () => {
+    for (const entry of listProviderEntries()) {
+      expect(entry.supportedBoundaries.size).toBeGreaterThan(0);
+    }
+  });
+
+  test("every entry ID matches its catalog key", () => {
+    for (const id of listProviderIds()) {
+      const entry = getProviderEntry(id);
+      expect(entry?.id).toBe(id);
+    }
+  });
+
+  // -----------------------------------------------------------------------
+  // Boundary support
+  // -----------------------------------------------------------------------
+
+  test("supportsBoundary returns true for supported boundaries", () => {
+    expect(supportsBoundary("openai-whisper", "daemon-batch")).toBe(true);
+    expect(supportsBoundary("deepgram", "daemon-batch")).toBe(true);
+    expect(supportsBoundary("google-gemini", "daemon-batch")).toBe(true);
+  });
+
+  test("supportsBoundary returns true for daemon-streaming on streaming-capable providers", () => {
+    expect(supportsBoundary("deepgram", "daemon-streaming")).toBe(true);
+    expect(supportsBoundary("google-gemini", "daemon-streaming")).toBe(true);
+    expect(supportsBoundary("openai-whisper", "daemon-streaming")).toBe(true);
+  });
+
+  test("supportsBoundary returns false for unknown provider IDs", () => {
+    // Cast to bypass type checking for the test
+    expect(supportsBoundary("nonexistent" as never, "daemon-batch")).toBe(
+      false,
+    );
+  });
+
+  // -----------------------------------------------------------------------
+  // Conversation streaming mode
+  // -----------------------------------------------------------------------
+
+  test("conversationStreamingMode is set for all providers", () => {
+    for (const entry of listProviderEntries()) {
+      expect(entry.conversationStreamingMode).toBeDefined();
+      expect(["realtime-ws", "incremental-batch", "none"]).toContain(
+        entry.conversationStreamingMode,
+      );
+    }
+  });
+
+  test("deepgram has realtime-ws conversation streaming mode", () => {
+    const entry = getProviderEntry("deepgram");
+    expect(entry?.conversationStreamingMode).toBe("realtime-ws");
+  });
+
+  test("google-gemini has realtime-ws conversation streaming mode", () => {
+    const entry = getProviderEntry("google-gemini");
+    expect(entry?.conversationStreamingMode).toBe("realtime-ws");
+  });
+
+  test("openai-whisper has incremental-batch conversation streaming mode", () => {
+    const entry = getProviderEntry("openai-whisper");
+    expect(entry?.conversationStreamingMode).toBe("incremental-batch");
+  });
+
+  // -----------------------------------------------------------------------
+  // Telephony routing metadata
+  // -----------------------------------------------------------------------
+
+  test("every entry has telephonyRouting metadata", () => {
+    for (const entry of listProviderEntries()) {
+      expect(entry.telephonyRouting).toBeDefined();
+      expect(["conversation-relay-native", "media-stream-custom"]).toContain(
+        entry.telephonyRouting.strategyKind,
+      );
+    }
+  });
+
+  test("conversation-relay-native entries have twilioNativeMapping", () => {
+    for (const entry of listProviderEntries()) {
+      if (entry.telephonyRouting.strategyKind === "conversation-relay-native") {
+        expect(entry.telephonyRouting.twilioNativeMapping).toBeDefined();
+        expect(
+          entry.telephonyRouting.twilioNativeMapping!.provider.length,
+        ).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test("media-stream-custom entries do not have twilioNativeMapping", () => {
+    for (const entry of listProviderEntries()) {
+      if (entry.telephonyRouting.strategyKind === "media-stream-custom") {
+        expect(entry.telephonyRouting.twilioNativeMapping).toBeUndefined();
+      }
+    }
+  });
+
+  test("deepgram has conversation-relay-native strategy with Deepgram Twilio mapping", () => {
+    const entry = getProviderEntry("deepgram");
+    expect(entry?.telephonyRouting.strategyKind).toBe(
+      "conversation-relay-native",
+    );
+    expect(entry?.telephonyRouting.twilioNativeMapping?.provider).toBe(
+      "Deepgram",
+    );
+    expect(
+      entry?.telephonyRouting.twilioNativeMapping?.defaultSpeechModel,
+    ).toBe("nova-3");
+  });
+
+  test("google-gemini has conversation-relay-native strategy with Google Twilio mapping", () => {
+    const entry = getProviderEntry("google-gemini");
+    expect(entry?.telephonyRouting.strategyKind).toBe(
+      "conversation-relay-native",
+    );
+    expect(entry?.telephonyRouting.twilioNativeMapping?.provider).toBe(
+      "Google",
+    );
+    expect(
+      entry?.telephonyRouting.twilioNativeMapping?.defaultSpeechModel,
+    ).toBeUndefined();
+  });
+
+  test("openai-whisper has media-stream-custom strategy without Twilio mapping", () => {
+    const entry = getProviderEntry("openai-whisper");
+    expect(entry?.telephonyRouting.strategyKind).toBe("media-stream-custom");
+    expect(entry?.telephonyRouting.twilioNativeMapping).toBeUndefined();
+  });
+
+  // -----------------------------------------------------------------------
+  // Credential lookup
+  // -----------------------------------------------------------------------
+
+  test("getCredentialProvider returns correct mapping", () => {
+    expect(getCredentialProvider("openai-whisper")).toBe("openai");
+    expect(getCredentialProvider("deepgram")).toBe("deepgram");
+    expect(getCredentialProvider("google-gemini")).toBe("gemini");
+  });
+
+  test("getCredentialProvider returns undefined for unknown ID", () => {
+    expect(getCredentialProvider("nonexistent" as never)).toBeUndefined();
+  });
+
+  // -----------------------------------------------------------------------
+  // Speaker diarization capability
+  // -----------------------------------------------------------------------
+
+  test("supportsDiarization is set as a boolean for every entry", () => {
+    for (const entry of listProviderEntries()) {
+      expect(typeof entry.supportsDiarization).toBe("boolean");
+    }
+  });
+
+  test("deepgram supportsDiarization is true", () => {
+    const entry = getProviderEntry("deepgram");
+    expect(entry?.supportsDiarization).toBe(true);
+  });
+
+  test("google-gemini supportsDiarization is false", () => {
+    const entry = getProviderEntry("google-gemini");
+    expect(entry?.supportsDiarization).toBe(false);
+  });
+
+  test("openai-whisper supportsDiarization is false", () => {
+    const entry = getProviderEntry("openai-whisper");
+    expect(entry?.supportsDiarization).toBe(false);
+  });
+
+  test("supportsDiarization helper returns expected booleans per provider", () => {
+    expect(supportsDiarization("deepgram")).toBe(true);
+    expect(supportsDiarization("google-gemini")).toBe(false);
+    expect(supportsDiarization("openai-whisper")).toBe(false);
+  });
+
+  test("supportsDiarization helper returns false for unknown provider IDs", () => {
+    expect(supportsDiarization("nonexistent" as never)).toBe(false);
+  });
+});