@vellumai/assistant 0.8.5 → 0.8.6

package/src/providers/openai/__tests__/chat-completions-provider-reasoning.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { OpenAIChatCompletionsProvider } from "../chat-completions-provider.js";
+import {
+  OpenAIChatCompletionsProvider,
+  type OpenAIChatCompletionsProviderOptions,
+} from "../chat-completions-provider.js";
 
 type ReasoningDetail = {
   type?: string;
@@ -32,23 +35,35 @@ function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
   };
 }
 
-function stubProvider(chunks: MockChunk[]): {
+function stubProvider(
+  chunks: MockChunk[],
+  options?: OpenAIChatCompletionsProviderOptions,
+): {
   provider: OpenAIChatCompletionsProvider;
   events: Array<{ type: string; thinking?: string; text?: string }>;
+  requests: unknown[];
 } {
-  const provider = new OpenAIChatCompletionsProvider("test-key", "test-model");
+  const provider = new OpenAIChatCompletionsProvider(
+    "test-key",
+    "test-model",
+    options,
+  );
+  const requests: unknown[] = [];
   // Swap the SDK client for a stub whose chat.completions.create returns our
   // canned async iterable.
   (provider as unknown as { client: unknown }).client = {
     chat: {
       completions: {
-        create: async () => makeStream(chunks),
+        create: async (params: unknown) => {
+          requests.push(params);
+          return makeStream(chunks);
+        },
       },
     },
   };
   const events: Array<{ type: string; thinking?: string; text?: string }> = [];
   (provider as unknown as { __events: typeof events }).__events = events;
-  return { provider, events };
+  return { provider, events, requests };
 }
 
 async function runStream(
@@ -232,4 +247,141 @@ describe("OpenAIChatCompletionsProvider reasoning parsing", () => {
     expect(deltas.map((d) => d.thinking)).toEqual(["it ", "worked", "!"]);
     expect(thinking).toBe("it worked!");
   });
+
+  test("round-trips prior assistant thinking as reasoning_content when field is set", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "continued" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 4, completion_tokens: 2 },
+        },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "first question" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "hidden chain state", signature: "" },
+          { type: "text", text: "first answer" },
+        ],
+      },
+      { role: "user", content: [{ type: "text", text: "follow up" }] },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning_content?: string;
+      }>;
+    };
+    const assistantMsg = params.messages.find((m) => m.role === "assistant");
+    expect(assistantMsg).toEqual({
+      role: "assistant",
+      content: "first answer",
+      reasoning_content: "hidden chain state",
+    });
+  });
+
+  test("uses reasoning field for OpenRouter-style round-trip", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { assistantReasoningField: "reasoning" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "visible summary", signature: "" },
+          { type: "text", text: "answer" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        reasoning?: string;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].reasoning).toBe("visible summary");
+    expect(params.messages[0].reasoning_content).toBeUndefined();
+  });
+
+  test("drops thinking blocks when assistantReasoningField is unset", async () => {
+    const { provider, requests } = stubProvider([
+      {
+        choices: [{ delta: { content: "reply" }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 2, completion_tokens: 1 },
+      },
+    ]);
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "should be dropped", signature: "" },
+          { type: "text", text: "visible" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        content: string | null;
+        reasoning?: string;
+        reasoning_content?: string;
+      }>;
+    };
+    const assistantMsg = params.messages[0];
+    expect(assistantMsg.content).toBe("visible");
+    expect(assistantMsg.reasoning).toBeUndefined();
+    expect(assistantMsg.reasoning_content).toBeUndefined();
+  });
+
+  test("skips Anthropic-originated thinking blocks (with signatures)", async () => {
+    const { provider, requests } = stubProvider(
+      [
+        {
+          choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+          usage: { prompt_tokens: 2, completion_tokens: 1 },
+        },
+      ],
+      { assistantReasoningField: "reasoning_content" },
+    );
+
+    await provider.sendMessage([
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "thinking",
+            thinking: "anthropic thinking",
+            signature: "sig-abc",
+          },
+          { type: "thinking", thinking: "deepseek thinking", signature: "" },
+          { type: "text", text: "answer" },
+        ],
+      },
+    ]);
+
+    const params = requests[0] as {
+      messages: Array<{
+        role: string;
+        reasoning_content?: string;
+      }>;
+    };
+    expect(params.messages[0].reasoning_content).toBe("deepseek thinking");
+  });
 });

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

@@ -54,6 +54,81 @@ 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;
+
+/**
+ * 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;
@@ -75,6 +150,10 @@ export interface OpenAIChatCompletionsProviderOptions {
    *  blocks. MiniMax and similar providers embed reasoning inside XML-style
    *  tags in the regular content field rather than using `reasoning_content`. */
   parseThinkTags?: boolean;
+  /** Wire field used to replay prior assistant thinking on multi-turn requests.
+   *  DeepSeek/Fireworks use `"reasoning_content"`; OpenRouter uses `"reasoning"`.
+   *  When unset, thinking blocks are dropped from outbound assistant messages. */
+  assistantReasoningField?: "reasoning" | "reasoning_content";
 }
 
 /** Wire-level reasoning_effort values. The OpenAI SDK type doesn't include
@@ -146,6 +225,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private maxReasoningEffort: "high" | "xhigh" | "max";
   private requestHeaders: Record<string, string>;
   private parseThinkTags: boolean;
+  private assistantReasoningField:
+    | "reasoning"
+    | "reasoning_content"
+    | undefined;
 
   constructor(
     apiKey: string,
@@ -168,6 +251,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     this.maxReasoningEffort = options.maxReasoningEffort ?? "xhigh";
     this.requestHeaders = options.requestHeaders ?? {};
     this.parseThinkTags = options.parseThinkTags ?? false;
+    this.assistantReasoningField = options.assistantReasoningField;
   }
 
   async sendMessage(
@@ -524,18 +608,18 @@ export class OpenAIChatCompletionsProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
+        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(
-            `${this.providerLabel} API error (${error.status}): ${error.message}`,
-            this.name,
-            {
-              actualTokens: overflow.actualTokens,
-              maxTokens: overflow.maxTokens,
-              statusCode: error.status,
-              cause: error,
-            },
-          );
+          throw new ContextOverflowError(formattedMessage, this.name, {
+            actualTokens: overflow.actualTokens,
+            maxTokens: overflow.maxTokens,
+            statusCode: error.status,
+            cause: error,
+          });
         }
         const retryAfterMs = extractRetryAfterMs(error.headers);
         const errorOptions: {
@@ -546,7 +630,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           errorOptions.retryAfterMs = retryAfterMs;
         if (abortReason) errorOptions.abortReason = abortReason;
         throw new ProviderError(
-          `${this.providerLabel} API error (${error.status}): ${error.message}`,
+          formattedMessage,
           this.name,
           error.status,
           Object.keys(errorOptions).length > 0 ? errorOptions : undefined,
@@ -661,6 +745,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
     msg: Message,
   ): OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam {
     const textParts: string[] = [];
+    const reasoningParts: string[] = [];
     const toolCalls: OpenAI.Chat.Completions.ChatCompletionMessageToolCall[] =
       [];
 
@@ -669,6 +754,10 @@ export class OpenAIChatCompletionsProvider implements Provider {
         case "text":
           textParts.push(block.text);
           break;
+        case "thinking":
+          // Anthropic thinking blocks carry signatures — skip those.
+          if (!block.signature) reasoningParts.push(block.thinking);
+          break;
         case "tool_use":
           toolCalls.push({
             id: block.id,
@@ -685,7 +774,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
         case "web_search_tool_result":
           textParts.push("[Web search results]");
           break;
-        // thinking, redacted_thinking, image — not applicable for OpenAI assistant messages
+        // redacted_thinking, image — not applicable for OpenAI assistant messages
       }
     }
 
@@ -695,6 +784,15 @@ export class OpenAIChatCompletionsProvider implements Provider {
         content: textParts.length > 0 ? textParts.join("") : null,
       };
 
+    if (reasoningParts.length > 0 && this.assistantReasoningField) {
+      (
+        result as OpenAI.Chat.Completions.ChatCompletionAssistantMessageParam & {
+          reasoning?: string;
+          reasoning_content?: string;
+        }
+      )[this.assistantReasoningField] = reasoningParts.join("");
+    }
+
     if (toolCalls.length > 0) {
       result.tool_calls = toolCalls;
     }

package/src/providers/openai/codex-models.ts

@@ -8,7 +8,9 @@
  * resolution of an "Any active OpenAI connection" profile.
  */
 export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
+  "gpt-5.5",
   "gpt-5.4",
+  "gpt-5.4-mini",
   "gpt-5.3-codex",
 ]);
 

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

@@ -26,7 +26,7 @@ export interface OpenAIResponsesProviderOptions {
   streamTimeoutMs?: number;
   useNativeWebSearch?: boolean;
   /** When true, target the Codex subscription endpoint and strip fields it
-   *  rejects (`max_output_tokens`, `reasoning`, `text`, `tools`). */
+   *  rejects (`max_output_tokens`). */
   codexSubscription?: boolean;
 }
 
@@ -74,6 +74,9 @@ interface ResponsesStreamEvent {
   response?: {
     model?: string;
     status?: string;
+    incomplete_details?: {
+      reason?: "max_output_tokens" | "content_filter";
+    } | null;
     /** Full output items array — preserved as part of rawResponse for the
      *  LLM context normalizer, which uses its presence to detect Responses
      *  API payloads in stored diagnostics. */
@@ -188,24 +191,22 @@ export class OpenAIResponsesProvider implements Provider {
         params.max_output_tokens = maxTokens;
       }
 
-      if (!this.codexSubscription) {
-        const reasoningEffort = effort
-          ? EFFORT_TO_REASONING_EFFORT[effort]
-          : undefined;
-        if (reasoningEffort) {
-          params.reasoning = { effort: reasoningEffort };
-        }
+      const reasoningEffort = effort
+        ? EFFORT_TO_REASONING_EFFORT[effort]
+        : undefined;
+      if (reasoningEffort) {
+        params.reasoning = { effort: reasoningEffort };
+      }
 
-        if (
-          verbosity &&
-          VALID_VERBOSITIES.has(verbosity) &&
-          modelSupportsVerbosity(modelOverride ?? this.model)
-        ) {
-          params.text = { verbosity };
-        }
+      if (
+        verbosity &&
+        VALID_VERBOSITIES.has(verbosity) &&
+        modelSupportsVerbosity(modelOverride ?? this.model)
+      ) {
+        params.text = { verbosity };
       }
 
-      if (tools && tools.length > 0 && !this.codexSubscription) {
+      if (tools && tools.length > 0) {
         if (
           this.useNativeWebSearch &&
           tools.some((t) => t.name === "web_search")
@@ -218,9 +219,9 @@ export class OpenAIResponsesProvider implements Provider {
             parameters: t.input_schema,
             strict: null,
           }));
-          const webSearchTool = {
-            type: "web_search_preview" as const,
-          };
+          const webSearchTool = this.codexSubscription
+            ? { type: "web_search" as const, external_web_access: false }
+            : { type: "web_search_preview" as const };
           params.tools = [...mappedOther, webSearchTool];
         } else {
           params.tools = tools.map((t) => ({
@@ -256,20 +257,26 @@ export class OpenAIResponsesProvider implements Provider {
       let rawFinalResponse: unknown = undefined;
 
       try {
-        // The SDK exposes `client.responses.stream()` — cast through
-        // `unknown` to avoid `any` while the SDK's exported types stabilise.
+        // Use `create()` with `stream: true` instead of the higher-level
+        // `stream()` helper. The `stream()` helper wraps the response in a
+        // `ResponseStream` that runs `maybeParseResponse()` after iteration,
+        // which crashes when the Codex subscription endpoint omits `output`
+        // from the `response.completed` event payload.
         const responsesApi = this.client.responses as unknown as {
-          stream(
+          create(
             p: Record<string, unknown>,
-            o: { signal: AbortSignal; headers?: Record<string, string> },
-          ): AsyncIterable<ResponsesStreamEvent>;
+            o?: { signal?: AbortSignal; headers?: Record<string, string> },
+          ): Promise<AsyncIterable<ResponsesStreamEvent>>;
         };
-        const stream = responsesApi.stream(params, {
-          signal: timeoutSignal,
-          ...(usageAttributionHeaders
-            ? { headers: usageAttributionHeaders }
-            : {}),
-        });
+        const stream = await responsesApi.create(
+          { ...params, stream: true },
+          {
+            signal: timeoutSignal,
+            ...(usageAttributionHeaders
+              ? { headers: usageAttributionHeaders }
+              : {}),
+          },
+        );
 
         for await (const event of stream) {
           switch (event.type) {
@@ -341,7 +348,8 @@ export class OpenAIResponsesProvider implements Provider {
               break;
             }
 
-            case "response.completed": {
+            case "response.completed":
+            case "response.incomplete": {
               const response = event.response;
               if (response) {
                 rawFinalResponse = response;
@@ -356,15 +364,22 @@ export class OpenAIResponsesProvider implements Provider {
                   cachedInputTokens =
                     response.usage.input_tokens_details?.cached_tokens ?? 0;
                 }
-                finishReason = response.status ?? "completed";
+                finishReason =
+                  response.incomplete_details?.reason ??
+                  response.status ??
+                  (event.type === "response.incomplete"
+                    ? "incomplete"
+                    : "completed");
               }
               // Emit server_tool_complete for any web search calls that were started.
-              for (const toolUseId of webSearchCallIds) {
-                onEvent?.({
-                  type: "server_tool_complete",
-                  toolUseId,
-                  isError: false,
-                });
+              if (event.type === "response.completed") {
+                for (const toolUseId of webSearchCallIds) {
+                  onEvent?.({
+                    type: "server_tool_complete",
+                    toolUseId,
+                    isError: false,
+                  });
+                }
               }
               break;
             }
@@ -438,21 +453,6 @@ export class OpenAIResponsesProvider implements Provider {
           ? signal.reason
           : undefined;
       if (error instanceof OpenAI.APIError) {
-        // Temporary diagnostic: log the raw error shape for Codex 400 debugging
-        if (this.codexSubscription) {
-          log.warn(
-            {
-              status: error.status,
-              message: error.message,
-              code: error.code,
-              type: error.type,
-              param: error.param,
-              errorBody: error.error,
-              headers: Object.fromEntries(error.headers?.entries?.() ?? []),
-            },
-            "Codex subscription API error — raw details",
-          );
-        }
         const overflow = detectOpenAICompatibleContextOverflow(error);
         if (overflow) {
           throw new ContextOverflowError(

package/src/providers/openrouter/client.ts

@@ -122,6 +122,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       providerLabel: "OpenRouter",
       streamTimeoutMs: options.streamTimeoutMs,
       requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
+      assistantReasoningField: "reasoning",
     });
     this.openRouterApiKey = apiKey;
     this.defaultModel = model;
@@ -199,17 +200,21 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       ? EFFORT_TO_REASONING_EFFORT[effort]
       : undefined;
     const summaryOverride = extractReasoningSummaryOverride(config);
-    const reasoning: Record<string, unknown> = { enabled: thinkingEnabled };
-    if (mappedEffort) {
-      reasoning.effort = clampReasoningEffort(
-        mappedEffort,
-        this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
-      );
-    }
+    // Only send `reasoning` when explicitly enabling thinking. Omitting the
+    // field lets OpenRouter use the model's natural default, which avoids 400s
+    // from reasoning-only models (e.g. DeepSeek R1) that reject `enabled: false`.
+    const extras: Record<string, unknown> = {};
     if (thinkingEnabled) {
+      const reasoning: Record<string, unknown> = { enabled: true };
+      if (mappedEffort) {
+        reasoning.effort = clampReasoningEffort(
+          mappedEffort,
+          this.resolveMaxReasoningEffort(this.resolveEffectiveModel(options)),
+        );
+      }
       reasoning.summary = summaryOverride ?? "detailed";
+      extras.reasoning = reasoning;
     }
-    const extras: Record<string, unknown> = { reasoning };
     const only = extractOnlyList(config);
     if (only.length > 0) {
       const existingProvider = (config?.provider ?? {}) as Record<

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

@@ -9,7 +9,10 @@ import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.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 { tryResolveProviderForConnectionName } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import { initializeProviders, listProviders } from "./registry.js";
@@ -117,23 +120,29 @@ export async function resolveConfiguredProvider(
 
   // Connection-aware path: every dispatch goes through `provider_connection`.
   // The boot-time backfill ensures every profile has one in production.
-  // When unset (profile set provider with "Any active" connection, test envs
-  // that skip backfill, freshly-installed configs not yet backfilled, or
-  // users who manually cleared the field), try to auto-resolve from the
-  // provider before falling back to null.
+  // When unset (profile set provider without a connection, test envs that
+  // skip backfill, freshly-installed configs not yet backfilled, or users
+  // who manually cleared the field), try to auto-resolve from the provider
+  // before falling back to null.
   if (!connectionName) {
     if (inferenceProvider) {
       try {
         const candidates = listConnections(getDb(), {
           provider: inferenceProvider,
         });
-        const active = candidates.find(
-          (c) =>
-            c.status === "active" &&
-            isConnectionCompatibleWithModel(c, resolved.model),
+        const active = candidates.find((c) =>
+          isConnectionCompatibleWithModel(c, resolved.model),
         );
         if (active) {
           connectionName = active.name;
+        } else {
+          const incompatMsg = describeSubscriptionModelIncompatibility(
+            candidates,
+            resolved.model,
+          );
+          if (incompatMsg) {
+            log.warn({ callSite, inferenceProvider, model: resolved.model }, incompatMsg);
+          }
         }
       } catch {
         // DB not available — fall through to the existing null-return path.