@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/providers/anthropic/client.ts

@@ -786,11 +786,6 @@ export class AnthropicProvider implements Provider {
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
-  /** See {@link Provider.supportsNativeWebSearch}. */
-  get supportsNativeWebSearch(): boolean {
-    return this.useNativeWebSearch;
-  }
-
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

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

@@ -43,9 +43,6 @@ import type {
 
 export class CallSiteRoutingProvider implements Provider {
   public readonly tokenEstimationProvider?: string;
-  // Forward native web-search capability so it survives the wrapper chain
-  // (callers like the advisor consult gate on it). Fixed at construction.
-  public readonly supportsNativeWebSearch?: boolean;
 
   // Per-call async context that tracks which provider is currently executing.
   // Using AsyncLocalStorage instead of a plain instance field means concurrent
@@ -97,7 +94,6 @@ export class CallSiteRoutingProvider implements Provider {
     ) => Promise<Provider | null>,
   ) {
     this.tokenEstimationProvider = defaultProvider.tokenEstimationProvider;
-    this.supportsNativeWebSearch = defaultProvider.supportsNativeWebSearch;
     if (defaultProvider.countInputTokens) {
       this.countInputTokens =
         defaultProvider.countInputTokens.bind(defaultProvider);

package/src/providers/model-catalog.ts

@@ -760,22 +760,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         maxEffort: "max",
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
-      {
-        id: "accounts/fireworks/models/deepseek-v4-flash",
-        displayName: "DeepSeek V4 Flash",
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 0.14,
-          outputPer1mTokens: 0.28,
-          cacheReadPer1mTokens: 0.03,
-        },
-      },
     ],
     defaultModel: "accounts/fireworks/models/kimi-k2p5",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",

package/src/providers/openai/__tests__/api-error-detail.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+
+import OpenAI from "openai";
+
+import { extractApiErrorDetail } from "../chat-completions-provider.js";
+
+/**
+ * Construct a real `OpenAI.APIError` so production code paths that use
+ * `instanceof OpenAI.APIError` and SDK-defined getters keep matching.
+ */
+function buildApiError(
+  status: number,
+  body: unknown,
+  headers?: Headers,
+): InstanceType<typeof OpenAI.APIError> {
+  return new OpenAI.APIError(
+    status,
+    body as Record<string, unknown>,
+    undefined,
+    headers ?? new Headers(),
+  );
+}
+
+describe("extractApiErrorDetail", () => {
+  test("serializes a structured body so logs show the upstream error", () => {
+    // This is the canonical OpenRouter shape that motivated the helper:
+    // the SDK's `error.message` collapses to "400 Provider returned error"
+    // and the real detail lives nested under `error.metadata.raw`.
+    const err = buildApiError(400, {
+      error: {
+        code: 400,
+        message: "Provider returned error",
+        metadata: {
+          raw: "messages.4: tool_use_id must reference a prior tool_use block",
+          provider_name: "Anthropic",
+        },
+      },
+    });
+    const { detail, requestId } = extractApiErrorDetail(err);
+    expect(detail).toContain("Provider returned error");
+    expect(detail).toContain("tool_use_id must reference a prior tool_use");
+    expect(detail).toContain("Anthropic");
+    expect(requestId).toBeUndefined();
+  });
+
+  test("surfaces the upstream request id when present in headers", () => {
+    const headers = new Headers({ "x-request-id": "req_abc123" });
+    const err = buildApiError(
+      400,
+      { error: { message: "Provider returned error" } },
+      headers,
+    );
+    const { requestId } = extractApiErrorDetail(err);
+    expect(requestId).toBe("req_abc123");
+  });
+
+  test("falls back to x-openrouter-request-id when x-request-id is absent", () => {
+    const headers = new Headers({
+      "x-openrouter-request-id": "gen-or-xyz",
+    });
+    const err = buildApiError(
+      400,
+      { error: { message: "Provider returned error" } },
+      headers,
+    );
+    const { requestId } = extractApiErrorDetail(err);
+    expect(requestId).toBe("gen-or-xyz");
+  });
+
+  test("returns empty detail when the body is missing", () => {
+    // The SDK constructs an APIError even when the upstream response had
+    // no JSON body (e.g. network-layer 5xx). The helper must degrade
+    // gracefully rather than emit `undefined` or `null` strings.
+    const err = buildApiError(500, undefined);
+    const { detail, requestId } = extractApiErrorDetail(err);
+    expect(detail).toBe("");
+    expect(requestId).toBeUndefined();
+  });
+
+  test("returns empty detail when the body serializes to an empty object", () => {
+    // `{}` carries zero signal and just adds noise to log lines.
+    const err = buildApiError(429, {});
+    const { detail } = extractApiErrorDetail(err);
+    expect(detail).toBe("");
+  });
+
+  test("truncates very long bodies with an ellipsis", () => {
+    const huge = "X".repeat(5000);
+    const err = buildApiError(400, { error: { message: huge } });
+    const { detail } = extractApiErrorDetail(err);
+    // Cap is 2000 chars; the helper appends a single-char ellipsis when truncating.
+    expect(detail.length).toBeLessThanOrEqual(2001);
+    expect(detail.endsWith("…")).toBe(true);
+  });
+
+  test("preserves string bodies verbatim (no double-encoding)", () => {
+    // Some providers return a non-JSON body (HTML error page, plain text).
+    // The SDK stores it on `error.error` as a string in that case.
+    const err = buildApiError(502, "upstream timeout");
+    const { detail } = extractApiErrorDetail(err);
+    expect(detail).toBe("upstream timeout");
+  });
+
+  test("returns empty detail when JSON.stringify throws (cyclic body)", () => {
+    // Pathological body — should not propagate the TypeError to callers.
+    // OpenAI's `APIError` constructor itself JSON.stringifies the body to
+    // build its own `.message`, so we can't get to this branch via the SDK
+    // constructor; build a structural stand-in instead.
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+    const stub = {
+      status: 400,
+      message: "synthetic",
+      headers: new Headers(),
+      error: cyclic,
+    } as unknown as InstanceType<typeof OpenAI.APIError>;
+    const { detail } = extractApiErrorDetail(stub);
+    expect(detail).toBe("");
+  });
+});

package/src/providers/openai/chat-completions-provider.ts

@@ -22,11 +22,6 @@ import {
   isUnparseableToolArgs,
   wrapUnparseableToolArgs,
 } from "../unparseable-tool-args.js";
-import {
-  captureRawErrorBodyFetch,
-  formatNormalizedOpenAIAPIError,
-  normalizeOpenAIAPIError,
-} from "./api-error-normalization.js";
 import {
   coerceObjectParamsToJsonString,
   decodeCoercedObjectArgs,
@@ -48,7 +43,6 @@ import {
  */
 export function detectOpenAICompatibleContextOverflow(
   error: InstanceType<typeof OpenAI.APIError>,
-  extraMessage?: string,
 ): { actualTokens?: number; maxTokens?: number } | null {
   // OpenAI-compatible providers use 400 (most) or 413 (rarer payload-too-large).
   const status = error.status;
@@ -59,9 +53,7 @@ export function detectOpenAICompatibleContextOverflow(
     /context_length_exceeded|context_window_exceeded|input_too_long|prompt_too_long/i.test(
       code,
     );
-  // Include the normalized upstream message: the SDK's `error.message` is often
-  // generic ("400 Provider returned error") while the real signal is in the body.
-  const message = `${error.message ?? ""} ${extraMessage ?? ""}`;
+  const message = error.message ?? "";
   const messageMatches =
     /context.?length.?exceeded|context.?window.?exceeded|prompt.?is.?too.?long|prompt_too_long|input.?too.?long|too.?many.?(?:input.?)?tokens|maximum.?context/i.test(
       message,
@@ -71,6 +63,53 @@ export function detectOpenAICompatibleContextOverflow(
   return extractOverflowTokensFromMessage(message);
 }
 
+/**
+ * Build the human-readable error string surfaced from an
+ * `OpenAI.APIError`. The SDK's `error.message` is typically a one-line
+ * summary like `"400 Provider returned error"` — useless when the
+ * upstream is OpenRouter (which wraps the real downstream error on
+ * `error.error.metadata.raw`) or any provider that returns nested
+ * structured details.
+ *
+ * Returns `{ detail, requestId }` where `detail` includes the JSON body
+ * (truncated) and `requestId` is the upstream correlation header when
+ * present. Callers fold these into the thrown `ProviderError` so log
+ * lines actually identify the failure without re-running the request.
+ *
+ * Exported for tests.
+ */
+export function extractApiErrorDetail(
+  error: InstanceType<typeof OpenAI.APIError>,
+): { detail: string; requestId: string | undefined } {
+  const body = (error as { error?: unknown }).error;
+  let detail = "";
+  if (body !== undefined && body !== null) {
+    try {
+      const serialized = typeof body === "string" ? body : JSON.stringify(body);
+      if (serialized && serialized !== "{}") {
+        detail =
+          serialized.length > MAX_API_ERROR_DETAIL_CHARS
+            ? `${serialized.slice(0, MAX_API_ERROR_DETAIL_CHARS)}…`
+            : serialized;
+      }
+    } catch {
+      // Body had a cycle or threw on toJSON — fall through with empty detail.
+    }
+  }
+  const requestId = readHeader(error.headers, [
+    "x-request-id",
+    "x-openrouter-request-id",
+    "openai-request-id",
+    "x-amzn-requestid",
+  ]);
+  return { detail, requestId };
+}
+
+/** Cap on the inline-rendered body to keep log lines readable while still
+ *  surfacing the meaningful upstream payload. Tuned to comfortably hold
+ *  OpenRouter's `error.metadata.raw` strings, which are typically <1KB. */
+const MAX_API_ERROR_DETAIL_CHARS = 2000;
+
 const VISION_NOT_SUPPORTED_PATTERNS = [
   /no endpoints found that support image input/i,
   /does not support image/i,
@@ -82,9 +121,8 @@ const VISION_NOT_SUPPORTED_PATTERNS = [
 
 export function detectVisionNotSupported(
   error: InstanceType<typeof OpenAI.APIError>,
-  extraMessage?: string,
 ): boolean {
-  const haystack = `${error.message} ${extraMessage ?? ""} ${JSON.stringify((error as { error?: unknown }).error ?? "")}`;
+  const haystack = `${error.message} ${JSON.stringify((error as { error?: unknown }).error ?? "")}`;
   return VISION_NOT_SUPPORTED_PATTERNS.some((re) => re.test(haystack));
 }
 
@@ -108,6 +146,34 @@ export function detectVisionNotSupported(
  */
 export const EMPTY_ASSISTANT_TURN_PLACEHOLDER = PLACEHOLDER_EMPTY_TURN.slice(1);
 
+/**
+ * Read the first matching header from an SDK error's headers object,
+ * tolerating both Map-like (`Headers.get()`) and plain-object shapes.
+ * Mirrors the shape-tolerance already in `extractRetryAfterMs`.
+ */
+function readHeader(
+  headers: unknown,
+  names: readonly string[],
+): string | undefined {
+  if (!headers) return undefined;
+  const getter =
+    typeof (headers as { get?: unknown }).get === "function"
+      ? (headers as { get(name: string): string | null }).get.bind(headers)
+      : undefined;
+  for (const name of names) {
+    let value: string | null | undefined;
+    if (getter) {
+      value = getter(name);
+    } else if (typeof headers === "object") {
+      const record = headers as Record<string, unknown>;
+      const raw = record[name] ?? record[name.toLowerCase()];
+      value = typeof raw === "string" ? raw : undefined;
+    }
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return undefined;
+}
+
 export interface OpenAIChatCompletionsProviderOptions {
   baseURL?: string;
   providerName?: string;
@@ -276,8 +342,6 @@ export class OpenAIChatCompletionsProvider implements Provider {
       apiKey,
       baseURL: options.baseURL,
       timeout: sdkTimeoutMs,
-      // Capture the raw non-2xx body before the SDK parses (and drops) it.
-      fetch: captureRawErrorBodyFetch,
     });
     this.model = model;
     this.extraCreateParams = options.extraCreateParams ?? {};
@@ -699,16 +763,11 @@ export class OpenAIChatCompletionsProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
-        const normalized = normalizeOpenAIAPIError(error);
-        const formattedMessage = formatNormalizedOpenAIAPIError(
-          this.providerLabel,
-          error.status,
-          normalized,
-        );
-        const overflow = detectOpenAICompatibleContextOverflow(
-          error,
-          normalized.message,
-        );
+        const { detail, requestId } = extractApiErrorDetail(error);
+        const detailSuffix = detail ? ` ${detail}` : "";
+        const requestIdSuffix = requestId ? ` [request_id=${requestId}]` : "";
+        const formattedMessage = `${this.providerLabel} API error (${error.status}): ${error.message}${detailSuffix}${requestIdSuffix}`;
+        const overflow = detectOpenAICompatibleContextOverflow(error);
         if (overflow) {
           throw new ContextOverflowError(formattedMessage, this.name, {
             actualTokens: overflow.actualTokens,
@@ -717,7 +776,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
             cause: error,
           });
         }
-        if (detectVisionNotSupported(error, normalized.message)) {
+        if (detectVisionNotSupported(error)) {
           const model = modelOverride ?? this.model;
           throw new ProviderError(
             `This model (${model}) doesn't support image input. Remove the image or switch to a vision-capable model.`,
@@ -730,23 +789,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
         const errorOptions: {
           retryAfterMs?: number;
           abortReason?: unknown;
-          apiErrorCode?: string;
-          apiErrorType?: string;
-          apiErrorParam?: string;
-          requestId?: string;
-          rawBody?: string;
         } = {};
         if (retryAfterMs !== undefined)
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
-        if (normalized.apiErrorCode)
-          errorOptions.apiErrorCode = normalized.apiErrorCode;
-        if (normalized.apiErrorType)
-          errorOptions.apiErrorType = normalized.apiErrorType;
-        if (normalized.apiErrorParam)
-          errorOptions.apiErrorParam = normalized.apiErrorParam;
-        if (normalized.requestId) errorOptions.requestId = normalized.requestId;
-        if (normalized.rawBody) errorOptions.rawBody = normalized.rawBody;
         throw new ProviderError(
           formattedMessage,
           this.name,

package/src/providers/openai/responses-provider.ts

@@ -16,11 +16,6 @@ import type {
 } from "../types.js";
 import { ContextOverflowError } from "../types.js";
 import { wrapUnparseableToolArgs } from "../unparseable-tool-args.js";
-import {
-  captureRawErrorBodyFetch,
-  formatNormalizedOpenAIAPIError,
-  normalizeOpenAIAPIError,
-} from "./api-error-normalization.js";
 import { detectOpenAICompatibleContextOverflow } from "./chat-completions-provider.js";
 
 const log = getLogger("openai-responses");
@@ -153,6 +148,7 @@ export class OpenAIResponsesProvider implements Provider {
   private streamTimeoutMs: number;
   private useNativeWebSearch: boolean;
   private codexSubscription: boolean;
+  private lastCodexErrorBody: string | undefined;
 
   constructor(
     apiKey: string,
@@ -172,18 +168,32 @@ export class OpenAIResponsesProvider implements Provider {
         ? "https://chatgpt.com/backend-api/codex"
         : options.baseURL,
       timeout: sdkTimeoutMs,
-      // Capture the raw non-2xx body before the SDK parses (and drops) it.
-      fetch: captureRawErrorBodyFetch,
+      ...(this.codexSubscription
+        ? {
+            fetch: async (url: RequestInfo | URL, init?: RequestInit) => {
+              const res = await globalThis.fetch(url, init);
+              if (!res.ok) {
+                const body = await res.text();
+                this.lastCodexErrorBody = body;
+                log.warn(
+                  { status: res.status, body, url: String(url) },
+                  "Codex endpoint raw error response",
+                );
+                return new Response(body, {
+                  status: res.status,
+                  statusText: res.statusText,
+                  headers: res.headers,
+                });
+              }
+              return res;
+            },
+          }
+        : {}),
     });
     this.model = model;
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
-  /** See {@link Provider.supportsNativeWebSearch}. */
-  get supportsNativeWebSearch(): boolean {
-    return this.useNativeWebSearch;
-  }
-
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,
@@ -500,57 +510,43 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
-        const normalized = normalizeOpenAIAPIError(error);
-        if (this.codexSubscription) {
-          log.warn(
+        const overflow = detectOpenAICompatibleContextOverflow(error);
+        if (overflow) {
+          throw new ContextOverflowError(
+            `${this.providerLabel} API error (${error.status}): ${error.message}`,
+            this.name,
             {
-              status: error.status,
-              message: normalized.message,
-              requestId: normalized.requestId,
+              actualTokens: overflow.actualTokens,
+              maxTokens: overflow.maxTokens,
+              statusCode: error.status,
+              cause: error,
             },
-            "Codex endpoint raw error response",
           );
         }
-        const formattedMessage = formatNormalizedOpenAIAPIError(
-          this.providerLabel,
-          error.status,
-          normalized,
-        );
-        const overflow = detectOpenAICompatibleContextOverflow(
-          error,
-          normalized.message,
-        );
-        if (overflow) {
-          throw new ContextOverflowError(formattedMessage, this.name, {
-            actualTokens: overflow.actualTokens,
-            maxTokens: overflow.maxTokens,
-            statusCode: error.status,
-            cause: error,
-          });
-        }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
           retryAfterMs?: number;
           abortReason?: unknown;
-          apiErrorCode?: string;
-          apiErrorType?: string;
-          apiErrorParam?: string;
-          requestId?: string;
-          rawBody?: string;
         } = {};
         if (retryAfterMs !== undefined)
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
-        if (normalized.apiErrorCode)
-          errorOptions.apiErrorCode = normalized.apiErrorCode;
-        if (normalized.apiErrorType)
-          errorOptions.apiErrorType = normalized.apiErrorType;
-        if (normalized.apiErrorParam)
-          errorOptions.apiErrorParam = normalized.apiErrorParam;
-        if (normalized.requestId) errorOptions.requestId = normalized.requestId;
-        if (normalized.rawBody) errorOptions.rawBody = normalized.rawBody;
+        let errorDetail = error.message;
+        if (this.lastCodexErrorBody) {
+          try {
+            const parsed = JSON.parse(this.lastCodexErrorBody);
+            if (parsed.detail) errorDetail = parsed.detail;
+          } catch {
+            errorDetail = this.lastCodexErrorBody.slice(0, 200);
+          }
+          this.lastCodexErrorBody = undefined;
+        }
+        const extras = [error.code, error.type, error.param]
+          .filter(Boolean)
+          .join(", ");
+        const extraSuffix = extras ? ` [${extras}]` : "";
         throw new ProviderError(
-          formattedMessage,
+          `${this.providerLabel} API error (${error.status}): ${errorDetail}${extraSuffix}`,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,

package/src/providers/openrouter/client.ts

@@ -140,11 +140,6 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
     return isAnthropicModel(this.defaultModel) ? "anthropic" : this.name;
   }
 
-  /** See {@link Provider.supportsNativeWebSearch}. Set per model at construction. */
-  get supportsNativeWebSearch(): boolean {
-    return this.useNativeWebSearch;
-  }
-
   override async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/provider-send-message.ts

@@ -43,9 +43,6 @@ let lazyInitPromise: Promise<void> | null = null;
 export class CallSiteConfiguredProvider implements Provider {
   public readonly name: string;
   public readonly tokenEstimationProvider?: string;
-  // Forward native web-search capability so it survives the wrapper chain
-  // (callers like the advisor consult gate on it). Fixed at construction.
-  public readonly supportsNativeWebSearch?: boolean;
 
   constructor(
     private readonly inner: Provider,
@@ -55,7 +52,6 @@ export class CallSiteConfiguredProvider implements Provider {
   ) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
-    this.supportsNativeWebSearch = inner.supportsNativeWebSearch;
   }
 
   sendMessage(

package/src/providers/ratelimit.ts

@@ -23,10 +23,6 @@ export class RateLimitProvider implements Provider {
     return this.inner.tokenEstimationProvider;
   }
 
-  get supportsNativeWebSearch(): boolean | undefined {
-    return this.inner.supportsNativeWebSearch;
-  }
-
   private requestTimestamps: number[];
 
   // Forward the optional token-counting endpoint so the capability survives

package/src/providers/retry.ts

@@ -618,10 +618,6 @@ export class RetryProvider implements Provider {
     return this.inner.tokenEstimationProvider;
   }
 
-  get supportsNativeWebSearch(): boolean | undefined {
-    return this.inner.supportsNativeWebSearch;
-  }
-
   // Forward the optional token-counting endpoint so the capability survives
   // the wrapper chain (callers gate on its presence). Bound straight to the
   // inner provider — count_tokens is a cheap separate endpoint and its caller

package/src/providers/types.ts

@@ -265,15 +265,6 @@ export interface Provider {
    * Falls back to `name` when unset.
    */
   tokenEstimationProvider?: string;
-  /**
-   * True when this provider instance was constructed to run web search
-   * server-side (provider-native). The native search only activates when a
-   * `web_search`-named tool is passed in the request, so callers that want to
-   * enable web search on a one-shot completion (e.g. the advisor consult) check
-   * this first — passing the tool to a non-native instance would surface an
-   * unexecutable client tool call. Absent/false on providers without it.
-   */
-  supportsNativeWebSearch?: boolean;
   sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/usage-tracking.ts

@@ -18,9 +18,6 @@ const log = getLogger("provider-usage-tracking");
 export class UsageTrackingProvider implements Provider {
   public readonly name: string;
   public readonly tokenEstimationProvider?: string;
-  // Forward native web-search capability so it survives the wrapper chain
-  // (callers like the advisor consult gate on it). Fixed at construction.
-  public readonly supportsNativeWebSearch?: boolean;
   // Forward the optional token-counting endpoint so the capability survives
   // the wrapper chain. Bound straight to the inner provider — count_tokens is
   // not billed, so there's no usage to track.
@@ -29,7 +26,6 @@ export class UsageTrackingProvider implements Provider {
   constructor(private readonly inner: Provider) {
     this.name = inner.name;
     this.tokenEstimationProvider = inner.tokenEstimationProvider;
-    this.supportsNativeWebSearch = inner.supportsNativeWebSearch;
     if (inner.countInputTokens) {
       this.countInputTokens = inner.countInputTokens.bind(inner);
     }