agent-accelerator 0.5.9 → 0.6.5

package/src/providers/openai-compat.ts

@@ -13,7 +13,7 @@
  * Strictness contract (differs from the old lenient passthrough on purpose):
  * - Requests carry ONLY standard Chat Completions fields (`model`, `messages`,
  *   `tools`, `tool_choice`, `stream`, plus `max_tokens`/
- *   `stop`/`seed` when explicitly set). No `reasoning`, `service_tier`,
+ *   when explicitly set). No `reasoning`, `service_tier`,
  *   `session_id`, `prompt_cache_key`, or other extras: strict endpoints
  *   (groq, ollama, …) fail unknown body properties, so anything unsupported
  *   is warn+drop, never sent.
@@ -60,13 +60,13 @@ import { safeStringify } from "../utils/serialization.ts";
 import { toConciseProviderError, assertModalitiesSupported } from "../utils/errors.ts";
 import { withRetries } from "../utils/retry.ts";
 import { ConfigError, ValidationError } from "../types/errors.ts";
+import { DEFAULT_PROMPTS } from "../prompts/prompts.ts";
 import {
   parseArguments,
   normalizeThinkingParts,
   newToolCallId,
   redactedHeaders,
   readErrorPayload,
-  incompleteStreamError,
   hasUnfinishedToolCall,
   linkStreamAbort,
   withAbortTimer,
@@ -97,6 +97,8 @@ import {
   normalizeStructuredOutput,
   augmentSystemPromptWithStructuredOutput,
   warnIgnoredMediaResolution,
+  warnIgnoredVideoProcessing,
+  warnIgnoredToolMedia,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -130,7 +132,10 @@ interface ChatRequestBody {
   messages: ChatMessage[];
   tools?: Array<Record<string, unknown>>;
   tool_choice?: string | { type: "function"; function: { name: string } };
-  response_format?: { type: "json_schema"; json_schema: { name: string; schema: Record<string, unknown>; strict: boolean; description?: string } };
+  response_format?: {
+    type: "json_schema";
+    json_schema: { name: string; schema: Record<string, unknown>; strict: boolean; description?: string };
+  };
   stream?: boolean;
   [k: string]: unknown;
 }
@@ -231,18 +236,20 @@ function resolveApiKey(
 ): string | undefined {
   const clean = (v: unknown): string | undefined => {
     if (typeof v !== "string") return undefined;
-    const t = v.trim().replace(/^["']|["']$/g, "").trim();
+    const t = v
+      .trim()
+      .replace(/^["']|["']$/g, "")
+      .trim();
     return t || undefined;
   };
   const envPrefix = envPrefixOf(prefix);
-  const key = (
+  const key =
     clean(options?.apiKey) ||
     clean(configuredApiKey) ||
     clean(options?.env?.[`${envPrefix}_API_KEY`]) ||
     clean(options?.env?.[`${envPrefix}_BASE_API_KEY`]) ||
     getApiKey(prefix, undefined, options?.env) ||
-    undefined
-  );
+    undefined;
   if (key) return key;
   if (hasAuthHeader(options?.headers)) return "unused";
   return undefined;
@@ -308,7 +315,8 @@ function warnThinkingDropped(prefix: string, thinking: ThinkingConfig | undefine
     provider: prefix,
     capability: "thinking level",
     requested: `${level} (${modelRef})`,
-    reason: "custom OpenAI-compatible endpoints define no portable reasoning control; levels vary by vendor and strict endpoints reject unknown fields.",
+    reason:
+      "custom OpenAI-compatible endpoints define no portable reasoning control; levels vary by vendor and strict endpoints reject unknown fields.",
     fallback: "the server default (no reasoning payload is sent)",
   });
 }
@@ -325,11 +333,7 @@ function audioFormatFor(mimeType?: string): string {
  * Completions subset has no shape for them, and a provider 400 would only say
  * so confusingly. Images and audio keep flowing natively.
  */
-function assertNoVideoOrFileParts(
-  context: ProviderContext,
-  prefix: string,
-  modelId: string
-): void {
+function assertNoVideoOrFileParts(context: ProviderContext, prefix: string, modelId: string): void {
   let kind: "video" | "file" | undefined;
   for (const msg of context.messages) {
     if (!Array.isArray((msg as { content?: unknown }).content)) continue;
@@ -374,10 +378,7 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<ChatContentPa
       const raw = (part as { audio?: unknown }).audio;
       const mimeType = (part as { mimeType?: string }).mimeType;
       // The OpenAI chat audio shape carries data only — always inline.
-      const norm = await normalizeMediaInput(
-        raw as string | Uint8Array | ArrayBuffer,
-        mimeType
-      );
+      const norm = await normalizeMediaInput(raw as string | Uint8Array | ArrayBuffer, mimeType);
       blocks.push({
         type: "input_audio",
         input_audio: { data: norm.base64Data, format: audioFormatFor(norm.mimeType) },
@@ -404,7 +405,10 @@ function resultToOutput(result: unknown): string {
  * `google` (or untagged legacy). Signatures minted by other providers never
  * leak onto this transport.
  */
-async function fullHistoryMessages(context: ProviderContext): Promise<ChatMessage[]> {
+async function fullHistoryMessages(
+  context: ProviderContext,
+  bridge = DEFAULT_PROMPTS.toolBridge
+): Promise<ChatMessage[]> {
   const pairing = new Map<string, string>();
   for (const m of context.messages) {
     if (m.role === "assistant" && Array.isArray(m.content)) {
@@ -425,13 +429,19 @@ async function fullHistoryMessages(context: ProviderContext): Promise<ChatMessag
     if (m.role === "system") continue;
     if (m.role === "user") {
       if (lastRole === "tool") {
-        messages.push({ role: "assistant", content: "I have processed the tool results." });
+        messages.push({ role: "assistant", content: bridge });
       }
       if (typeof m.content === "string") {
-        if (m.content) { messages.push({ role: "user", content: m.content }); lastRole = "user"; }
+        if (m.content) {
+          messages.push({ role: "user", content: m.content });
+          lastRole = "user";
+        }
       } else {
         const blocks = await contentPartsToBlocks(m.content);
-        if (blocks.length > 0) { messages.push({ role: "user", content: blocks }); lastRole = "user"; }
+        if (blocks.length > 0) {
+          messages.push({ role: "user", content: blocks });
+          lastRole = "user";
+        }
       }
     } else if (m.role === "assistant") {
       if (typeof m.content === "string") {
@@ -527,25 +537,22 @@ function mapUsage(raw?: ChatResponse["usage"]): TokenUsage {
 }
 
 // The Gemini thought signature a proxy put on a tool call, if any; in: parseResponse, out: a string or undefined.
-function extractSignature(rawTc: {
-  extra_content?: { google?: { thought_signature?: string } };
-}): string | undefined {
+function extractSignature(rawTc: { extra_content?: { google?: { thought_signature?: string } } }): string | undefined {
   const sig = rawTc?.extra_content?.google?.thought_signature;
   return typeof sig === "string" && sig ? sig : undefined;
 }
 
 /** Tags a captured compat signature with its issuing provider (`google`). */
-function withCompatSignature(sig: string | undefined): { thoughtSignature?: string; thoughtSignatureProvider?: string } {
+function withCompatSignature(sig: string | undefined): {
+  thoughtSignature?: string;
+  thoughtSignatureProvider?: string;
+} {
   if (!sig) return {};
   return { thoughtSignature: sig, thoughtSignatureProvider: "google" };
 }
 
 // Throws a concise error for an HTTP 200 reply that carries only `error`; in: parseResponse, out: a thrown error.
-function throwResponseError(
-  response: ChatResponse,
-  prefix: string,
-  modelId: string
-): void {
+function throwResponseError(response: ChatResponse, prefix: string, modelId: string): void {
   const message =
     response.error && typeof response.error.message === "string" && response.error.message
       ? response.error.message
@@ -716,13 +723,16 @@ export class OpenAICompatibleChatProvider implements Provider {
         provider: this.prefix,
         capability: "service tier",
         requested: `${options.serviceTier} (${this.prefix}/${modelId})`,
-        reason: "custom OpenAI-compatible endpoints define no service-tier primitive, and strict endpoints reject unknown body properties.",
+        reason:
+          "custom OpenAI-compatible endpoints define no service-tier primitive, and strict endpoints reject unknown body properties.",
         fallback: "standard routing (no service_tier payload is sent)",
       });
     }
     // Strict endpoints reject unknown body fields: implicit caching only.
     resolveCache(this.prefix, options?.cache, ["implicit"], `${this.prefix}/${modelId}`);
     warnIgnoredMediaResolution(this.prefix, context.messages, `${this.prefix}/${modelId}`);
+    warnIgnoredVideoProcessing(this.prefix, context.messages, `${this.prefix}/${modelId}`);
+    warnIgnoredToolMedia(this.prefix, context.messages, `${this.prefix}/${modelId}`);
 
     // Structured outputs: native `response_format` when supported, else
     // emulated via system prompt (strict endpoints would 400 on json_schema
@@ -739,17 +749,22 @@ export class OpenAICompatibleChatProvider implements Provider {
       outputEmulated = true;
       effectiveContext = {
         ...context,
-        systemPrompt: augmentSystemPromptWithStructuredOutput(context.systemPrompt, outputSpec),
+        systemPrompt: augmentSystemPromptWithStructuredOutput(
+          context.systemPrompt,
+          outputSpec,
+          options?.prompts?.structuredOutput
+        ),
       };
       emitProviderWarning({
         provider: this.prefix,
         capability: "structured output",
         requested: `${outputSpec.name} (${this.prefix}/${modelId})`,
-        reason: "the catalog reports structured_output: false for this model, so native response_format is unsupported.",
+        reason:
+          "the catalog reports structured_output: false for this model, so native response_format is unsupported.",
         fallback: "emulated JSON instruction + client validation (no response_format is sent)",
       });
     }
-    const messages = await fullHistoryMessages(effectiveContext);
+    const messages = await fullHistoryMessages(effectiveContext, options?.prompts?.toolBridge);
     const body: ChatRequestBody = {
       model: modelId,
       messages,
@@ -758,10 +773,8 @@ export class OpenAICompatibleChatProvider implements Provider {
     const compatTools = toCompatTools(tools);
     if (compatTools) body.tools = compatTools;
     // Standard Chat Completions generation fields, only when the caller set them.
-    Object.assign(body, mapGenerationParamsToChat(options, this.prefix, `${this.prefix}/${modelId}`));
-    const toolChoice = mapToolChoiceToOpenAI(
-      options?.toolChoice as "auto" | "none" | "required" | { type: "function"; function: { name: string } } | undefined
-    );
+    Object.assign(body, mapGenerationParamsToChat(options));
+    const toolChoice = mapToolChoiceToOpenAI(options?.toolChoice, this.prefix);
     if (toolChoice !== undefined) {
       // Chat Completions nests pinned names under `function`; the canonical
       // mapper emits the flat Responses shape, so normalize here.
@@ -791,7 +804,7 @@ export class OpenAICompatibleChatProvider implements Provider {
       const noStreamOptions =
         (options as { streamOptions?: unknown } | undefined)?.streamOptions === false ||
         getEnv("COMPAT_NO_STREAM_OPTIONS") === "1" ||
-        (options?.env?.["COMPAT_NO_STREAM_OPTIONS"] === "1");
+        options?.env?.["COMPAT_NO_STREAM_OPTIONS"] === "1";
       if (!noStreamOptions) {
         (body as unknown as Record<string, unknown>)["stream_options"] = { include_usage: true };
       }
@@ -807,11 +820,7 @@ export class OpenAICompatibleChatProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): RequestInit {
-    const headers: Record<string, string> = buildSessionHeaders(
-      this.prefix,
-      options?.headers,
-      sessionId
-    );
+    const headers: Record<string, string> = buildSessionHeaders(this.prefix, options?.headers, sessionId);
     // Strict-endpoint opt-out (pi sendSessionAffinityHeaders pattern):
     // `COMPAT_NO_SESSION_HEADERS=1` or per-call `sendSessionHeaders:false`
     // drops affinity headers that trigger CORS preflights / strict 400s.
@@ -844,7 +853,10 @@ export class OpenAICompatibleChatProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): Promise<{ status: number; statusText: string; headers: Record<string, string>; text: string }> {
-    const { signal: effective, cleanup } = combinedSignal(signal, timeoutFor(options as { timeoutMs?: number } | undefined));
+    const { signal: effective, cleanup } = combinedSignal(
+      signal,
+      timeoutFor(options as { timeoutMs?: number } | undefined)
+    );
     try {
       const res = await (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, effective));
       const text = await res.text();
@@ -939,13 +951,10 @@ export class OpenAICompatibleChatProvider implements Provider {
       // Stateless turns never establish chains, but the session store still
       // records the turn so other providers' switch detection keeps working.
       noteProviderTurn(sessionId, this.prefix);
-      return parseResponse(
-        response,
-        this.prefix,
-        clean,
-        Date.now() - startTime,
-        { request: rawRequest, response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response } }
-      );
+      return parseResponse(response, this.prefix, clean, Date.now() - startTime, {
+        request: rawRequest,
+        response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response },
+      });
     };
 
     try {
@@ -1000,9 +1009,13 @@ export class OpenAICompatibleChatProvider implements Provider {
         // Transient failures (429/5xx/network) are retried here, before the
         // first byte; once the stream is live it is never retried.
         const res = await openStreamResponse({
-          fetchOnce: () => withAbortTimer(linked, streamTimeoutMs, () => (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))),
+          fetchOnce: () =>
+            withAbortTimer(linked, streamTimeoutMs, () =>
+              (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))
+            ),
           onHttpError: (r, text) => this.throwIfError(r.status, url, text, clean, headersToRecord(r.headers)),
-          noBodyError: () => toConciseProviderError(new Error("OpenAI-compatible streaming response had no body"), prefix, clean),
+          noBodyError: () =>
+            toConciseProviderError(new Error("OpenAI-compatible streaming response had no body"), prefix, clean),
           retry: retryOptionsFrom(options),
           signal: linked.signal,
           label: { providerId: prefix, modelId: clean },
@@ -1011,7 +1024,11 @@ export class OpenAICompatibleChatProvider implements Provider {
         res.headers.forEach((v, k) => {
           responseHeaders[k] = v;
         });
-        const responseMeta: Record<string, unknown> & { status: number; statusText: string; headers: Record<string, string> } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
+        const responseMeta: Record<string, unknown> & {
+          status: number;
+          statusText: string;
+          headers: Record<string, string>;
+        } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
         eventStream.push({ type: "start", raw: { request: rawRequest } } as never);
 
         let text = "";
@@ -1059,7 +1076,8 @@ export class OpenAICompatibleChatProvider implements Provider {
           if (typeof msg["id"] === "string" && !responseId) {
             responseId = msg["id"] as string;
           }
-          const choice = (Array.isArray(msg["choices"]) ? (msg["choices"] as Record<string, unknown>[])[0] : undefined) ?? {};
+          const choice =
+            (Array.isArray(msg["choices"]) ? (msg["choices"] as Record<string, unknown>[])[0] : undefined) ?? {};
           const delta = (choice["delta"] as Record<string, unknown>) ?? {};
           // Text delta (content-free accounting frames carry "" — ignored).
           // Refusal deltas surface as text with a `refusal` finish.

package/src/providers/openai.ts

@@ -12,7 +12,7 @@
  * effort, service_tier flex/priority, prompt_cache_key affinity, usage,
  * finish reasons, switching, abort, errors.
  *
- * Also implemented: `text.format` structured output, `max_output_tokens` (stop + seed have no Responses equivalent: warn+drop).
+ * Also implemented: `text.format` structured output, `max_output_tokens`.
  *
  * Out of scope (never sent): background, conversation, previous_response_id
  * chaining, include, metadata, truncation, safety_identifier,
@@ -59,7 +59,6 @@ import {
   newToolCallId,
   redactedHeaders,
   readErrorPayload,
-  incompleteStreamError,
   hasUnfinishedToolCall,
   linkStreamAbort,
   withAbortTimer,
@@ -71,7 +70,6 @@ import {
   combinedSignal,
   timeoutFor,
   hasAuthHeader,
-  clampToolCallId,
   openStreamResponse,
   retryOptionsFrom,
   headersToRecord,
@@ -93,6 +91,8 @@ import {
   augmentSystemPromptWithStructuredOutput,
   emitProviderWarning,
   warnIgnoredMediaResolution,
+  warnIgnoredVideoProcessing,
+  warnIgnoredToolMedia,
 } from "../providers.ts";
 
 // ---------------------------------------------------------------------------
@@ -124,7 +124,15 @@ interface ResponsesRequestBody {
   prompt_cache_key?: string;
   store?: boolean;
   stream?: boolean;
-  text?: { format: { type: "json_schema"; name: string; schema: Record<string, unknown>; strict: boolean; description?: string } };
+  text?: {
+    format: {
+      type: "json_schema";
+      name: string;
+      schema: Record<string, unknown>;
+      strict: boolean;
+      description?: string;
+    };
+  };
   [k: string]: unknown;
 }
 
@@ -212,13 +220,9 @@ async function contentPartsToBlocks(parts: ContentPart[]): Promise<ResponseConte
   for (const part of parts) {
     if (part.type === "text" && part.text) {
       blocks.push({ type: "input_text", text: part.text });
-    } else if (
-      part.type === "image" ||
-      part.type === "audio" ||
-      part.type === "video" ||
-      part.type === "file"
-    ) {
-      const raw = (part as { image?: unknown; audio?: unknown; video?: unknown; file?: unknown }).image ??
+    } else if (part.type === "image" || part.type === "audio" || part.type === "video" || part.type === "file") {
+      const raw =
+        (part as { image?: unknown; audio?: unknown; video?: unknown; file?: unknown }).image ??
         (part as { audio?: unknown }).audio ??
         (part as { video?: unknown }).video ??
         (part as { file?: unknown }).file;
@@ -319,7 +323,8 @@ async function fullHistoryInput(context: ProviderContext): Promise<ResponseInput
     if (m.role === "system") continue;
     if (m.role === "user") {
       if (typeof m.content === "string") {
-        if (m.content) items.push({ type: "message", role: "user", content: [{ type: "input_text", text: m.content }] });
+        if (m.content)
+          items.push({ type: "message", role: "user", content: [{ type: "input_text", text: m.content }] });
       } else {
         const blocks = await contentPartsToBlocks(m.content);
         if (blocks.length > 0) items.push({ type: "message", role: "user", content: blocks });
@@ -363,7 +368,11 @@ async function fullHistoryInput(context: ProviderContext): Promise<ResponseInput
         // provider-minted ids that canonical history does not retain.
       }
       if (texts.length > 0) {
-        items.push({ type: "message", role: "assistant", content: texts.map((t) => ({ type: "output_text", text: t })) });
+        items.push({
+          type: "message",
+          role: "assistant",
+          content: texts.map((t) => ({ type: "output_text", text: t })),
+        });
       }
     } else if (m.role === "tool") {
       if (typeof m.content === "string") {
@@ -544,6 +553,8 @@ export class OpenAIResponsesProvider implements Provider {
     // `12h` maps to `prompt_cache_retention: "24h"`; everything else stays on implicit prompt_cache_key affinity.
     const cache = resolveCache("openai", options?.cache, ["implicit", "12h"], `openai/${modelId}`);
     warnIgnoredMediaResolution("openai", context.messages, `openai/${modelId}`);
+    warnIgnoredVideoProcessing("openai", context.messages, `openai/${modelId}`);
+    warnIgnoredToolMedia("openai", context.messages, `openai/${modelId}`);
 
     // Structured outputs: native `text.format` when supported, else emulated
     // via instructions (catalog `structured_output: false` would 400).
@@ -557,7 +568,11 @@ export class OpenAIResponsesProvider implements Provider {
     }
     if (outputSpec && !modelSupportsStructuredOutput("openai", modelId)) {
       outputEmulated = true;
-      effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(context.systemPrompt, outputSpec);
+      effectiveSystemPrompt = augmentSystemPromptWithStructuredOutput(
+        context.systemPrompt,
+        outputSpec,
+        options?.prompts?.structuredOutput
+      );
       emitProviderWarning({
         provider: "openai",
         capability: "structured output",
@@ -579,14 +594,12 @@ export class OpenAIResponsesProvider implements Provider {
     if (effectiveSystemPrompt) body.instructions = effectiveSystemPrompt;
     const aiTools = toOpenAITools(tools);
     if (aiTools) body.tools = aiTools;
-    const toolChoice = mapToolChoiceToOpenAI(
-      options?.toolChoice as "auto" | "none" | "required" | { type: "function"; function: { name: string } } | undefined
-    );
+    const toolChoice = mapToolChoiceToOpenAI(options?.toolChoice);
     if (toolChoice !== undefined) body.tool_choice = toolChoice;
     if (effort) body.reasoning = { effort };
     if (serviceTier) body.service_tier = serviceTier;
-    // max_output_tokens (stop + seed warn+drop: not on this wire).
-    Object.assign(body, mapGenerationParamsToOpenAI(options, `openai/${modelId}`));
+    // max_output_tokens.
+    Object.assign(body, mapGenerationParamsToOpenAI(options));
     // Structured outputs: Responses `text.format{type:json_schema,name,schema,strict}`.
     // Skipped when emulated (instruction already in `instructions`).
     if (outputSpec && !outputEmulated) {
@@ -640,11 +653,7 @@ export class OpenAIResponsesProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): RequestInit {
-    const headers: Record<string, string> = buildSessionHeaders(
-      "openai",
-      options?.headers,
-      sessionId
-    );
+    const headers: Record<string, string> = buildSessionHeaders("openai", options?.headers, sessionId);
     // Case-insensitive merge so a lowercase `authorization` custom header
     // never coexists with the canonical bearer. Proxy flows
     // (`apiKey === "unused"`) preserve custom auth instead of overwriting.
@@ -662,7 +671,10 @@ export class OpenAIResponsesProvider implements Provider {
     sessionId: string | undefined,
     signal?: AbortSignal
   ): Promise<{ status: number; statusText: string; headers: Record<string, string>; text: string }> {
-    const { signal: effective, cleanup } = combinedSignal(signal, timeoutFor(options as { timeoutMs?: number } | undefined));
+    const { signal: effective, cleanup } = combinedSignal(
+      signal,
+      timeoutFor(options as { timeoutMs?: number } | undefined)
+    );
     try {
       const res = await (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, effective));
       const text = await res.text();
@@ -769,12 +781,10 @@ export class OpenAIResponsesProvider implements Provider {
       // Stateless turns never establish chains, but the session store still
       // records the turn so other providers' switch detection keeps working.
       noteProviderTurn(sessionId, "openai");
-      return parseResponse(
-        response,
-        clean,
-        Date.now() - startTime,
-        { request: rawRequest, response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response } }
-      );
+      return parseResponse(response, clean, Date.now() - startTime, {
+        request: rawRequest,
+        response: { status: res.status, statusText: res.statusText, headers: res.headers, body: response },
+      });
     };
 
     try {
@@ -834,9 +844,13 @@ export class OpenAIResponsesProvider implements Provider {
         // Transient failures (429/5xx/network) are retried here, before the
         // first byte; once the stream is live it is never retried.
         const res = await openStreamResponse({
-          fetchOnce: () => withAbortTimer(linked, streamTimeoutMs, () => (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))),
+          fetchOnce: () =>
+            withAbortTimer(linked, streamTimeoutMs, () =>
+              (options?.fetch ?? fetch)(url, this.requestInit(body, options, apiKey, sessionId, linked.signal))
+            ),
           onHttpError: (r, text) => this.throwIfError(r.status, url, text, clean, headersToRecord(r.headers)),
-          noBodyError: () => toConciseProviderError(new Error("OpenAI streaming response had no body"), "openai", clean),
+          noBodyError: () =>
+            toConciseProviderError(new Error("OpenAI streaming response had no body"), "openai", clean),
           retry: retryOptionsFrom(options),
           signal: linked.signal,
           label: { providerId: "openai", modelId: clean },
@@ -845,13 +859,20 @@ export class OpenAIResponsesProvider implements Provider {
         res.headers.forEach((v, k) => {
           responseHeaders[k] = v;
         });
-        const responseMeta: Record<string, unknown> & { status: number; statusText: string; headers: Record<string, string> } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
+        const responseMeta: Record<string, unknown> & {
+          status: number;
+          statusText: string;
+          headers: Record<string, string>;
+        } = { status: res.status, statusText: res.statusText, headers: responseHeaders };
         eventStream.push({ type: "start", raw: { request: rawRequest } } as never);
 
         let text = "";
         let thinking = "";
         // Tool calls keyed by output_index: { itemId, callId, name, startArgs, deltaArgs }.
-        const calls = new Map<number, { itemId: string; callId: string; name: string; startArgs: string; deltaArgs: string }>();
+        const calls = new Map<
+          number,
+          { itemId: string; callId: string; name: string; startArgs: string; deltaArgs: string }
+        >();
         let usage: TokenUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
         let finishReason = "stop";
         let sawFinishReason = false;
@@ -892,10 +913,7 @@ export class OpenAIResponsesProvider implements Provider {
           } else if (type === "response.output_text.delta" && typeof msg["delta"] === "string") {
             text += msg["delta"] as string;
             eventStream.push({ type: "text_delta", delta: msg["delta"] as string, partialText: text });
-          } else if (
-            type === "response.refusal.delta" ||
-            type === "response.output_refusal.delta"
-          ) {
+          } else if (type === "response.refusal.delta" || type === "response.output_refusal.delta") {
             // Refusal deltas carry the filter text; surface as text and
             // remember for a `refusal` finish reason.
             if (typeof msg["delta"] === "string" && msg["delta"]) {
@@ -908,7 +926,11 @@ export class OpenAIResponsesProvider implements Provider {
             typeof msg["delta"] === "string"
           ) {
             thinking += msg["delta"] as string;
-            eventStream.push({ type: "thinking_delta", thinkingDelta: msg["delta"] as string, partialThinking: thinking });
+            eventStream.push({
+              type: "thinking_delta",
+              thinkingDelta: msg["delta"] as string,
+              partialThinking: thinking,
+            });
           } else if (type === "response.output_item.added") {
             const index = (msg["output_index"] as number) ?? 0;
             const item = (msg["item"] as Record<string, unknown>) ?? {};
@@ -957,7 +979,8 @@ export class OpenAIResponsesProvider implements Provider {
             // Non-streaming maps `incomplete` → `length` (max tokens). Streaming
             // must do the same — otherwise truncated turns misreport `stop`.
             // Content-filter incompletes surface as `refusal`.
-            const incompleteReason = (response as { incomplete_details?: { reason?: string } }).incomplete_details?.reason;
+            const incompleteReason = (response as { incomplete_details?: { reason?: string } }).incomplete_details
+              ?.reason;
             if (response.status === "incomplete") {
               finishReason = incompleteReason === "content_filter" ? "refusal" : "length";
               sawFinishReason = true;