@veryfront/ext-llm-openai 0.1.1186 → 0.1.1189

package/esm/openai-provider.js

@@ -9,12 +9,16 @@
  */
 import { buildProviderError, createOpenAIRequestInit, createWarningCollector, getOpenAIChatCompletionsUrl, getOpenAIEmbeddingUrl, getOpenAIResponsesUrl, isNumberArray, mergeUsage, parseRetryAfterMs, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, readGatewayBillingMode, readRecord, requestJson, requestStream, stringifyJsonValue, TOOL_INPUT_PENDING_THRESHOLD_MS, } from "veryfront/provider/shared";
 import { buildOpenAIChatRequest, } from "./openai-chat-request-builder.js";
-import { streamOpenAICompatibleParts } from "./openai-chat-stream.js";
+import { MAX_OPENAI_STREAM_TOOL_CALLS, streamOpenAICompatibleParts } from "./openai-chat-stream.js";
 import { buildOpenAIResponsesRequest } from "./openai-responses-request-builder.js";
 import { isOpenAIReasoningModel } from "./openai-reasoning-models.js";
+import { isBoundedOpenAIStreamString, MAX_OPENAI_STREAM_IDENTIFIER_BYTES, MAX_OPENAI_STREAM_ITEM_TYPE_BYTES, MAX_OPENAI_STREAM_TOOL_NAME_BYTES, } from "./openai-stream-metadata.js";
 import { extractOpenAIResponsesUsage, normalizeOpenAIResponsesFinishReason, streamOpenAIResponsesParts, } from "./openai-responses-stream.js";
+import { isJsonObjectText, MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES } from "./openai-tool-input.js";
+import { createOpenAIRawResponseMetadata, MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES, MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS, normalizeOpenAIWebSearchCall, readOpenAIRawResponseOutputItems, resolveOpenAIWebSearchDescriptor, validateOpenAIUrlCitation, } from "./openai-web-search.js";
 // Re-export error classes so extension tests can import from this module.
 export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, TOOL_INPUT_PENDING_THRESHOLD_MS, };
+const OPENAI_RESPONSE_TEXT_ENCODER = new TextEncoder();
 function readNonEmptyString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
@@ -27,31 +31,92 @@ function getRuntimeOpenAIProviderName(config) {
 function getLLMOpenAIProviderName(config) {
     return readNonEmptyString(config.providerName) ?? "openai";
 }
+function getOpenAICompatibleProviderKind(config) {
+    const providerName = getRuntimeOpenAIProviderName(config).trim().toLowerCase();
+    return providerName === "mistral" || providerName === "moonshotai" ? providerName : "openai";
+}
+function invalidOpenAIResponse(context, issue) {
+    return new ProviderRequestError({
+        provider: context.providerKind,
+        status: 200,
+        message: `${context.providerLabel} request failed: invalid successful response (${issue})`,
+        retryable: false,
+    });
+}
+function sanitizeRuntimeUsage(usage) {
+    const normalized = mergeUsage(undefined, usage);
+    return normalized && Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function readUsageTokenCount(value) {
+    return typeof value === "number" &&
+        Number.isFinite(value) &&
+        Number.isSafeInteger(value) &&
+        value >= 0
+        ? value
+        : undefined;
+}
 // ---------------------------------------------------------------------------
 // Embedding helpers
 // ---------------------------------------------------------------------------
-function extractOpenAIEmbeddings(payload) {
+function extractOpenAIEmbeddings(payload, expectedCount, context) {
     const record = readRecord(payload);
     const data = record?.data;
     if (!Array.isArray(data)) {
-        throw new Error("Invalid OpenAI embedding response: data array missing");
+        throw invalidOpenAIResponse(context, "embedding data array missing");
+    }
+    if (data.length !== expectedCount) {
+        throw invalidOpenAIResponse(context, `expected ${expectedCount} embedding vectors but received ${data.length}`);
     }
-    const embeddings = [];
+    const positionalEmbeddings = [];
+    const indexedEmbeddings = Array(expectedCount);
+    let indexMode;
+    let dimensions;
     for (const item of data) {
         const itemRecord = readRecord(item);
         const embedding = itemRecord?.embedding;
-        if (!isNumberArray(embedding)) {
-            throw new Error("Invalid OpenAI embedding response: embedding vector missing");
+        if (!isNumberArray(embedding) || embedding.length === 0) {
+            throw invalidOpenAIResponse(context, "embedding vector missing or invalid");
+        }
+        dimensions ??= embedding.length;
+        if (embedding.length !== dimensions) {
+            throw invalidOpenAIResponse(context, "embedding vectors had inconsistent dimensions");
+        }
+        const rawIndex = itemRecord?.index;
+        const itemIndexMode = rawIndex === undefined ? "positional" : "indexed";
+        if (indexMode !== undefined && indexMode !== itemIndexMode) {
+            throw invalidOpenAIResponse(context, "embedding indices were inconsistently provided");
+        }
+        indexMode = itemIndexMode;
+        if (itemIndexMode === "positional") {
+            positionalEmbeddings.push(embedding);
+            continue;
+        }
+        if (typeof rawIndex !== "number" ||
+            !Number.isSafeInteger(rawIndex) ||
+            rawIndex < 0 ||
+            rawIndex >= expectedCount) {
+            throw invalidOpenAIResponse(context, "embedding index was invalid");
         }
-        embeddings.push(embedding);
+        if (indexedEmbeddings[rawIndex] !== undefined) {
+            throw invalidOpenAIResponse(context, "embedding indices contained a duplicate");
+        }
+        indexedEmbeddings[rawIndex] = embedding;
+    }
+    if (indexMode !== "indexed") {
+        return positionalEmbeddings;
     }
-    return embeddings;
+    return indexedEmbeddings.map((embedding) => {
+        if (embedding === undefined) {
+            throw invalidOpenAIResponse(context, "embedding indices were incomplete");
+        }
+        return embedding;
+    });
 }
 function extractOpenAIUsageTokens(payload) {
     const record = readRecord(payload);
     const usage = readRecord(record?.usage);
     const totalTokens = usage?.total_tokens;
-    return typeof totalTokens === "number" ? totalTokens : undefined;
+    return readUsageTokenCount(totalTokens);
 }
 // ---------------------------------------------------------------------------
 // Chat helpers
@@ -131,38 +196,94 @@ function extractOpenAIUsage(payload) {
             : {}),
     };
 }
-function extractOpenAIContentText(content) {
+function extractOpenAIContentText(content, context) {
     if (typeof content === "string") {
+        if (OPENAI_RESPONSE_TEXT_ENCODER.encode(content).byteLength >
+            MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES) {
+            throw invalidOpenAIResponse(context, `message content exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`);
+        }
         return content;
     }
     if (!Array.isArray(content)) {
         return "";
     }
-    let text = "";
+    if (content.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+        throw invalidOpenAIResponse(context, `message content exceeded ${MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS} parts`);
+    }
+    const textParts = [];
+    let retainedBytes = 0;
     for (const part of content) {
         const record = readRecord(part);
+        if (!record) {
+            throw invalidOpenAIResponse(context, "message content part was not an object");
+        }
         const type = record?.type;
-        if (type === "text" && typeof record?.text === "string") {
-            text += record.text;
+        let value;
+        if (type === "text") {
+            if (typeof record.text !== "string") {
+                throw invalidOpenAIResponse(context, "text content part was malformed");
+            }
+            value = record.text;
+        }
+        else if (type === "refusal") {
+            if (typeof record.refusal !== "string") {
+                throw invalidOpenAIResponse(context, "refusal content part was malformed");
+            }
+            value = record.refusal;
+        }
+        else {
+            throw invalidOpenAIResponse(context, "message content part type was unsupported");
         }
+        const valueBytes = OPENAI_RESPONSE_TEXT_ENCODER.encode(value).byteLength;
+        if (valueBytes >
+            MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES - retainedBytes) {
+            throw invalidOpenAIResponse(context, `message content exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`);
+        }
+        retainedBytes += valueBytes;
+        textParts.push(value);
     }
-    return text;
+    return textParts.join("");
 }
-function extractOpenAIToolCalls(message) {
+function extractOpenAIToolCalls(message, context) {
     const toolCalls = message.tool_calls;
-    if (!Array.isArray(toolCalls)) {
+    if (toolCalls === undefined || toolCalls === null) {
         return [];
     }
+    if (!Array.isArray(toolCalls)) {
+        throw invalidOpenAIResponse(context, "message tool_calls was not an array");
+    }
+    if (toolCalls.length > MAX_OPENAI_STREAM_TOOL_CALLS) {
+        throw invalidOpenAIResponse(context, `message exceeded ${MAX_OPENAI_STREAM_TOOL_CALLS} tool calls`);
+    }
     const normalized = [];
+    const seenToolCallIds = new Set();
+    let retainedArgumentBytes = 0;
     for (const entry of toolCalls) {
         const record = readRecord(entry);
-        const id = typeof record?.id === "string" ? record.id : undefined;
+        const id = isBoundedOpenAIStreamString(record?.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES)
+            ? record.id
+            : undefined;
         const fn = readRecord(record?.function);
-        const name = typeof fn?.name === "string" ? fn.name : undefined;
+        const name = isBoundedOpenAIStreamString(fn?.name, MAX_OPENAI_STREAM_TOOL_NAME_BYTES)
+            ? fn.name
+            : undefined;
         const argumentsText = typeof fn?.arguments === "string" ? fn.arguments : undefined;
-        if (!id || !name || argumentsText === undefined) {
-            continue;
+        if (record?.type !== "function" || !id || !name || argumentsText === undefined) {
+            throw invalidOpenAIResponse(context, "message contained a malformed tool call");
+        }
+        if (seenToolCallIds.has(id)) {
+            throw invalidOpenAIResponse(context, "message contained duplicate tool call ids");
+        }
+        const argumentBytes = OPENAI_RESPONSE_TEXT_ENCODER.encode(argumentsText).byteLength;
+        if (argumentBytes >
+            MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES - retainedArgumentBytes) {
+            throw invalidOpenAIResponse(context, `message tool call arguments exceeded ${MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES} UTF-8 bytes`);
         }
+        if (!isJsonObjectText(argumentsText)) {
+            throw invalidOpenAIResponse(context, "message tool call arguments were not valid JSON object text");
+        }
+        retainedArgumentBytes += argumentBytes;
+        seenToolCallIds.add(id);
         normalized.push({
             toolCallId: id,
             toolName: name,
@@ -171,99 +292,386 @@ function extractOpenAIToolCalls(message) {
     }
     return normalized;
 }
-function extractFirstChoice(payload) {
+function extractFirstChoice(payload, context) {
     const record = readRecord(payload);
     const choices = record?.choices;
     if (!Array.isArray(choices) || choices.length === 0) {
-        return undefined;
+        throw invalidOpenAIResponse(context, "choices array missing or empty");
     }
     const first = readRecord(choices[0]);
     if (!first) {
-        return undefined;
+        throw invalidOpenAIResponse(context, "first choice was not an object");
     }
     return first;
 }
-function buildOpenAIGenerateResult(payload) {
-    const choice = extractFirstChoice(payload);
-    const message = readRecord(choice?.message);
-    const text = extractOpenAIContentText(message?.content);
-    const toolCalls = message ? extractOpenAIToolCalls(message) : [];
+function buildOpenAIGenerateResult(payload, context) {
+    const choice = extractFirstChoice(payload, context);
+    const message = readRecord(choice.message);
+    if (!message) {
+        throw invalidOpenAIResponse(context, "choice message missing");
+    }
+    if (message.role !== "assistant") {
+        throw invalidOpenAIResponse(context, "choice message role was not assistant");
+    }
+    if (message.content !== undefined &&
+        message.content !== null &&
+        typeof message.content !== "string" &&
+        !Array.isArray(message.content)) {
+        throw invalidOpenAIResponse(context, "message content had an invalid type");
+    }
+    if (message.refusal !== undefined &&
+        message.refusal !== null &&
+        typeof message.refusal !== "string") {
+        throw invalidOpenAIResponse(context, "message refusal had an invalid type");
+    }
+    if (typeof choice.finish_reason !== "string" || choice.finish_reason.length === 0) {
+        throw invalidOpenAIResponse(context, "choice finish reason missing");
+    }
+    const regularText = extractOpenAIContentText(message.content, context);
+    const refusalText = typeof message.refusal === "string" ? message.refusal : "";
+    const regularTextBytes = OPENAI_RESPONSE_TEXT_ENCODER.encode(regularText).byteLength;
+    const refusalTextBytes = OPENAI_RESPONSE_TEXT_ENCODER.encode(refusalText).byteLength;
+    if (refusalTextBytes >
+        MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES - regularTextBytes) {
+        throw invalidOpenAIResponse(context, `message content exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`);
+    }
+    const text = regularText + refusalText;
+    const toolCalls = extractOpenAIToolCalls(message, context);
+    if ((choice.finish_reason === "tool_calls") !== (toolCalls.length > 0)) {
+        throw invalidOpenAIResponse(context, "choice finish reason and tool calls were inconsistent");
+    }
+    const content = [
+        ...(text.length > 0 ? [{ type: "text", text }] : []),
+        ...toolCalls.map((toolCall) => ({
+            type: "tool-call",
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+        })),
+    ];
     return {
-        content: [
-            ...(text.length > 0 ? [{ type: "text", text }] : []),
-            ...toolCalls.map((toolCall) => ({
-                type: "tool-call",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input,
-            })),
-        ],
+        content,
         finishReason: normalizeOpenAIFinishReason(choice?.finish_reason),
-        usage: extractOpenAIUsage(payload),
+        usage: sanitizeRuntimeUsage(extractOpenAIUsage(payload)),
     };
 }
-function buildOpenAIResponsesGenerateResult(payload) {
+function assertTerminalOpenAIResponsesOutputItem(item, context) {
+    const validStatus = item.status === undefined ||
+        item.status === "completed" ||
+        item.status === "incomplete" ||
+        (item.type === "web_search_call" && item.status === "failed");
+    if (!validStatus) {
+        throw invalidOpenAIResponse(context, "output item status was unsupported or nonterminal");
+    }
+}
+function createValidatedOpenAIRawResponseMetadata(outputItems, context) {
+    const metadata = createOpenAIRawResponseMetadata(outputItems);
+    try {
+        readOpenAIRawResponseOutputItems(metadata);
+    }
+    catch {
+        throw invalidOpenAIResponse(context, "raw response output items were unsafe to replay");
+    }
+    return metadata;
+}
+function buildOpenAIResponsesGenerateResult(payload, context, webSearchToolName) {
     const record = readRecord(payload);
-    const output = Array.isArray(record?.output) ? record.output : [];
+    if (!record) {
+        throw invalidOpenAIResponse(context, "response body was not an object");
+    }
+    if (typeof record.status !== "string" || record.status.length === 0) {
+        throw invalidOpenAIResponse(context, "response status missing");
+    }
+    if (record.status !== "completed" &&
+        record.status !== "incomplete" &&
+        record.status !== "failed") {
+        throw invalidOpenAIResponse(context, "response status was unsupported or nonterminal");
+    }
+    if (!Array.isArray(record.output)) {
+        throw invalidOpenAIResponse(context, "output array missing");
+    }
+    const output = record.output;
+    if (output.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+        throw invalidOpenAIResponse(context, `output exceeded ${MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS} items`);
+    }
     const content = [];
+    const rawOutputItems = [];
+    const seenOutputItemIds = new Set();
+    const seenToolCallIds = new Set();
+    let normalizedContentBytes = 0;
+    function reserveNormalizedContent(value, issue) {
+        const valueBytes = OPENAI_RESPONSE_TEXT_ENCODER.encode(value).byteLength;
+        if (valueBytes > MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES -
+            normalizedContentBytes) {
+            throw invalidOpenAIResponse(context, `${issue} exceeded ${MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES} UTF-8 bytes`);
+        }
+        normalizedContentBytes += valueBytes;
+    }
     for (const item of output) {
         const itemRecord = readRecord(item);
-        const itemType = typeof itemRecord?.type === "string" ? itemRecord.type : undefined;
-        if (itemType === "message" && Array.isArray(itemRecord?.content)) {
+        if (!itemRecord) {
+            throw invalidOpenAIResponse(context, "output item was not an object");
+        }
+        rawOutputItems.push(itemRecord);
+        const itemType = isBoundedOpenAIStreamString(itemRecord.type, MAX_OPENAI_STREAM_ITEM_TYPE_BYTES)
+            ? itemRecord.type
+            : undefined;
+        if (!itemType) {
+            throw invalidOpenAIResponse(context, "output item type missing");
+        }
+        assertTerminalOpenAIResponsesOutputItem(itemRecord, context);
+        if (!isBoundedOpenAIStreamString(itemRecord.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES)) {
+            throw invalidOpenAIResponse(context, "output item id was malformed");
+        }
+        if (seenOutputItemIds.has(itemRecord.id)) {
+            throw invalidOpenAIResponse(context, "response contained duplicate output item ids");
+        }
+        seenOutputItemIds.add(itemRecord.id);
+        if (itemType === "message") {
+            if (itemRecord.role !== "assistant") {
+                throw invalidOpenAIResponse(context, "message output role was not assistant");
+            }
+            if (!Array.isArray(itemRecord.content)) {
+                throw invalidOpenAIResponse(context, "message output content was not an array");
+            }
+            if (itemRecord.content.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+                throw invalidOpenAIResponse(context, "message output contained too many content parts");
+            }
             // A message item bundles one or more output_text parts.
-            let text = "";
+            const textParts = [];
             for (const part of itemRecord.content) {
                 const p = readRecord(part);
-                if (typeof p?.type === "string" && p.type === "output_text" && typeof p.text === "string") {
-                    text += p.text;
+                if (!p) {
+                    throw invalidOpenAIResponse(context, "message content part was not an object");
+                }
+                if (p.type === "output_text") {
+                    if (typeof p.text !== "string") {
+                        throw invalidOpenAIResponse(context, "output-text content part was malformed");
+                    }
+                    if (p.annotations !== undefined) {
+                        if (!Array.isArray(p.annotations) ||
+                            p.annotations.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+                            throw invalidOpenAIResponse(context, "output-text annotations were malformed");
+                        }
+                        for (const annotation of p.annotations) {
+                            const citation = validateOpenAIUrlCitation(annotation, (issue) => invalidOpenAIResponse(context, issue));
+                            if (citation.end_index > p.text.length) {
+                                throw invalidOpenAIResponse(context, "URL citation annotation range exceeded output text");
+                            }
+                        }
+                    }
+                    reserveNormalizedContent(p.text, "normalized response content");
+                    textParts.push(p.text);
+                }
+                else if (p.type === "refusal") {
+                    if (typeof p.refusal !== "string" ||
+                        p.annotations !== undefined) {
+                        throw invalidOpenAIResponse(context, "refusal content part was malformed");
+                    }
+                    reserveNormalizedContent(p.refusal, "normalized response content");
+                    textParts.push(p.refusal);
+                }
+                else {
+                    throw invalidOpenAIResponse(context, "message content part type was unsupported");
                 }
             }
+            const text = textParts.join("");
             if (text.length > 0) {
                 content.push({ type: "text", text });
             }
             continue;
         }
         if (itemType === "function_call") {
+            const toolCallId = isBoundedOpenAIStreamString(itemRecord.call_id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES)
+                ? itemRecord.call_id
+                : undefined;
+            const toolName = isBoundedOpenAIStreamString(itemRecord.name, MAX_OPENAI_STREAM_TOOL_NAME_BYTES)
+                ? itemRecord.name
+                : undefined;
+            if (!toolCallId ||
+                !toolName ||
+                !isBoundedOpenAIStreamString(itemRecord.arguments, MAX_OPENAI_STREAM_TOOL_ARGUMENT_BYTES)) {
+                throw invalidOpenAIResponse(context, "function call output item was malformed");
+            }
+            if (seenToolCallIds.has(toolCallId)) {
+                throw invalidOpenAIResponse(context, "response contained duplicate function call ids");
+            }
+            if (!isJsonObjectText(itemRecord.arguments)) {
+                throw invalidOpenAIResponse(context, "function call arguments were not valid JSON object text");
+            }
+            reserveNormalizedContent(itemRecord.arguments, "normalized response content");
             content.push({
                 type: "tool-call",
-                toolCallId: typeof itemRecord?.call_id === "string"
-                    ? itemRecord.call_id
-                    : (typeof itemRecord?.id === "string" ? itemRecord.id : ""),
-                toolName: typeof itemRecord?.name === "string" ? itemRecord.name : "",
-                input: typeof itemRecord?.arguments === "string"
-                    ? itemRecord.arguments
-                    : stringifyJsonValue(itemRecord?.arguments ?? {}),
+                toolCallId,
+                toolName,
+                input: itemRecord.arguments,
             });
+            seenToolCallIds.add(toolCallId);
             continue;
         }
-        if (itemType === "reasoning") {
-            const summary = Array.isArray(itemRecord?.summary) ? itemRecord.summary : [];
-            const summaries = [];
-            for (const s of summary) {
-                const sr = readRecord(s);
-                if (typeof sr?.text === "string" && sr.text.length > 0) {
-                    summaries.push({
-                        ...(typeof sr?.id === "string" ? { id: sr.id } : {}),
-                        text: sr.text,
-                    });
-                }
+        if (itemType === "web_search_call") {
+            if (!webSearchToolName) {
+                throw invalidOpenAIResponse(context, "provider emitted web search without a configured web-search tool");
             }
+            const webSearch = normalizeOpenAIWebSearchCall(itemRecord, (issue) => invalidOpenAIResponse(context, issue));
+            if (seenToolCallIds.has(webSearch.id)) {
+                throw invalidOpenAIResponse(context, "response contained duplicate tool call ids");
+            }
+            reserveNormalizedContent(webSearch.input, "normalized response content");
+            reserveNormalizedContent(stringifyJsonValue(webSearch.result), "normalized response content");
             content.push({
-                type: "reasoning",
-                ...(summaries.length > 0 ? { summaries } : {}),
-                ...(typeof itemRecord?.encrypted_content === "string"
-                    ? { signature: itemRecord.encrypted_content }
-                    : {}),
+                type: "tool-call",
+                toolCallId: webSearch.id,
+                toolName: webSearchToolName,
+                input: webSearch.input,
+                providerExecuted: true,
             });
+            content.push({
+                type: "tool-result",
+                toolCallId: webSearch.id,
+                toolName: webSearchToolName,
+                result: webSearch.result,
+                ...(webSearch.isError ? { isError: true } : {}),
+                providerExecuted: true,
+            });
+            seenToolCallIds.add(webSearch.id);
             continue;
         }
+        if (itemType === "reasoning") {
+            if ((itemRecord.summary !== undefined && !Array.isArray(itemRecord.summary)) ||
+                (itemRecord.content !== undefined && !Array.isArray(itemRecord.content))) {
+                throw invalidOpenAIResponse(context, "reasoning summary or content was not an array");
+            }
+            const summary = Array.isArray(itemRecord.summary) ? itemRecord.summary : [];
+            const reasoningContent = Array.isArray(itemRecord.content) ? itemRecord.content : [];
+            if (summary.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS ||
+                reasoningContent.length > MAX_OPENAI_RAW_RESPONSE_OUTPUT_ITEMS) {
+                throw invalidOpenAIResponse(context, "reasoning contained too many parts");
+            }
+            const reasoningText = [];
+            for (const [parts, expectedType] of [
+                [summary, "summary_text"],
+                [reasoningContent, "reasoning_text"],
+            ]) {
+                for (const rawPart of parts) {
+                    const part = readRecord(rawPart);
+                    if (!part ||
+                        part.type !== expectedType ||
+                        typeof part.text !== "string" ||
+                        (part.id !== undefined &&
+                            !isBoundedOpenAIStreamString(part.id, MAX_OPENAI_STREAM_IDENTIFIER_BYTES))) {
+                        throw invalidOpenAIResponse(context, expectedType === "summary_text"
+                            ? "reasoning summary item was malformed"
+                            : "reasoning content item was malformed");
+                    }
+                    if (part.text.length > 0) {
+                        reserveNormalizedContent(part.text, "normalized response content");
+                        reasoningText.push(part.text);
+                    }
+                }
+            }
+            if (itemRecord.encrypted_content !== undefined &&
+                (typeof itemRecord.encrypted_content !== "string" ||
+                    OPENAI_RESPONSE_TEXT_ENCODER.encode(itemRecord.encrypted_content).byteLength >
+                        MAX_OPENAI_RAW_RESPONSE_METADATA_BYTES)) {
+                throw invalidOpenAIResponse(context, "reasoning encrypted content was malformed");
+            }
+            const signature = typeof itemRecord.encrypted_content === "string"
+                ? itemRecord.encrypted_content
+                : undefined;
+            if (signature !== undefined) {
+                reserveNormalizedContent(signature, "normalized response content");
+            }
+            if (reasoningText.length > 0 || signature !== undefined) {
+                content.push({
+                    type: "reasoning",
+                    ...(reasoningText.length > 0 ? { text: reasoningText.join("") } : {}),
+                    ...(signature !== undefined ? { signature } : {}),
+                });
+            }
+            continue;
+        }
+        throw invalidOpenAIResponse(context, "output item type was unsupported");
     }
     return {
         content,
         finishReason: normalizeOpenAIResponsesFinishReason(record?.status),
-        usage: extractOpenAIResponsesUsage(payload),
+        usage: sanitizeRuntimeUsage(extractOpenAIResponsesUsage(payload)),
+        ...(rawOutputItems.length > 0
+            ? {
+                providerMetadata: createValidatedOpenAIRawResponseMetadata(rawOutputItems, context),
+            }
+            : {}),
+    };
+}
+function createOpenAIProviderAbortScope(callerSignal) {
+    const controller = new AbortController();
+    const abortFromCaller = () => controller.abort(callerSignal?.reason);
+    if (callerSignal?.aborted) {
+        abortFromCaller();
+        return { controller, dispose() { } };
+    }
+    callerSignal?.addEventListener("abort", abortFromCaller, { once: true });
+    return {
+        controller,
+        dispose() {
+            callerSignal?.removeEventListener("abort", abortFromCaller);
+        },
     };
 }
+function createCancelableOpenAIProviderStream(iterable, providerAbortController, disposeAbortScope) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    let consumerCanceled = false;
+    let disposed = false;
+    const dispose = () => {
+        if (disposed)
+            return;
+        disposed = true;
+        disposeAbortScope();
+    };
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    dispose();
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(next.value);
+            }
+            catch (error) {
+                if (!providerAbortController.signal.aborted) {
+                    providerAbortController.abort(error);
+                }
+                dispose();
+                if (!consumerCanceled) {
+                    controller.error(error);
+                }
+            }
+        },
+        async cancel(reason) {
+            consumerCanceled = true;
+            if (!providerAbortController.signal.aborted) {
+                providerAbortController.abort(reason);
+            }
+            try {
+                await iterator.return?.();
+            }
+            catch (error) {
+                if (!providerAbortController.signal.aborted) {
+                    throw error;
+                }
+            }
+            finally {
+                dispose();
+            }
+        },
+    }, 
+    // Avoid speculative reads so cancellation reaches the provider body as
+    // soon as the consumer stops after its most recent part.
+    { highWaterMark: 0 });
+}
 // ---------------------------------------------------------------------------
 // Public factory functions
 // ---------------------------------------------------------------------------
@@ -271,13 +679,14 @@ export function createOpenAIModelRuntime(config, modelId) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     const providerLabel = getOpenAIProviderLabel(config);
     const providerName = getRuntimeOpenAIProviderName(config);
+    const providerKind = getOpenAICompatibleProviderKind(config);
+    const responseContext = { providerKind, providerLabel };
     return {
         provider: providerLabel,
         modelId,
         specificationVersion: "v3",
         supportedUrls: {},
-        doGenerate(optionsForRuntime) {
-            const options = optionsForRuntime;
+        doGenerate(options) {
             const url = getOpenAIChatCompletionsUrl(config.baseURL);
             const warnings = createWarningCollector();
             const body = buildOpenAIChatRequest(modelId, providerName, options, false, warnings);
@@ -285,7 +694,7 @@ export function createOpenAIModelRuntime(config, modelId) {
                 url,
                 fetchImpl,
                 providerLabel,
-                providerKind: "openai",
+                providerKind,
                 init: createOpenAIRequestInit({
                     apiKey: config.apiKey,
                     extraHeaders: options.headers,
@@ -295,34 +704,39 @@ export function createOpenAIModelRuntime(config, modelId) {
             }).then((payload) => {
                 const drained = warnings.drain();
                 return {
-                    ...buildOpenAIGenerateResult(payload),
+                    ...buildOpenAIGenerateResult(payload, responseContext),
                     ...(drained.length > 0 ? { warnings: drained } : {}),
                 };
             });
         },
-        doStream(optionsForRuntime) {
-            const options = optionsForRuntime;
+        async doStream(options) {
             const url = getOpenAIChatCompletionsUrl(config.baseURL);
             const warnings = createWarningCollector();
             const body = buildOpenAIChatRequest(modelId, providerName, options, true, warnings);
-            return requestStream({
-                url,
-                fetchImpl,
-                providerLabel,
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((responseStream) => {
+            const providerAbortScope = createOpenAIProviderAbortScope(options.abortSignal);
+            try {
+                const responseStream = await requestStream({
+                    url,
+                    fetchImpl,
+                    providerLabel,
+                    providerKind,
+                    init: createOpenAIRequestInit({
+                        apiKey: config.apiKey,
+                        extraHeaders: options.headers,
+                        body: JSON.stringify(body),
+                        signal: providerAbortScope.controller.signal,
+                    }),
+                });
                 const drained = warnings.drain();
                 return {
-                    stream: ReadableStream.from(streamOpenAICompatibleParts(responseStream)),
+                    stream: createCancelableOpenAIProviderStream(streamOpenAICompatibleParts(responseStream, responseContext), providerAbortScope.controller, providerAbortScope.dispose),
                     ...(drained.length > 0 ? { warnings: drained } : {}),
                 };
-            });
+            }
+            catch (error) {
+                providerAbortScope.dispose();
+                throw error;
+            }
         },
     };
 }
@@ -330,21 +744,23 @@ export function createOpenAIResponsesRuntime(config, modelId) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     const providerLabel = getOpenAIProviderLabel(config);
     const providerName = getRuntimeOpenAIProviderName(config);
+    const providerKind = getOpenAICompatibleProviderKind(config);
+    const responseContext = { providerKind, providerLabel };
     return {
         provider: providerLabel,
         modelId,
         specificationVersion: "v3",
         supportedUrls: {},
-        doGenerate(optionsForRuntime) {
-            const options = optionsForRuntime;
+        doGenerate(options) {
             const url = getOpenAIResponsesUrl(config.baseURL);
             const warnings = createWarningCollector();
             const body = buildOpenAIResponsesRequest(modelId, providerName, options, false, warnings);
+            const webSearchToolName = resolveOpenAIWebSearchDescriptor(options.tools)?.name;
             return requestJson({
                 url,
                 fetchImpl,
                 providerLabel,
-                providerKind: "openai",
+                providerKind,
                 init: createOpenAIRequestInit({
                     apiKey: config.apiKey,
                     extraHeaders: options.headers,
@@ -354,40 +770,76 @@ export function createOpenAIResponsesRuntime(config, modelId) {
             }).then((payload) => {
                 const drained = warnings.drain();
                 return {
-                    ...buildOpenAIResponsesGenerateResult(payload),
+                    ...buildOpenAIResponsesGenerateResult(payload, responseContext, webSearchToolName),
                     ...(drained.length > 0 ? { warnings: drained } : {}),
                 };
             });
         },
-        doStream(optionsForRuntime) {
-            const options = optionsForRuntime;
+        async doStream(options) {
             const url = getOpenAIResponsesUrl(config.baseURL);
             const warnings = createWarningCollector();
             const body = buildOpenAIResponsesRequest(modelId, providerName, options, true, warnings);
-            return requestStream({
-                url,
-                fetchImpl,
-                providerLabel,
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((responseStream) => {
+            const webSearchToolName = resolveOpenAIWebSearchDescriptor(options.tools)?.name;
+            const providerAbortScope = createOpenAIProviderAbortScope(options.abortSignal);
+            try {
+                const responseStream = await requestStream({
+                    url,
+                    fetchImpl,
+                    providerLabel,
+                    providerKind,
+                    init: createOpenAIRequestInit({
+                        apiKey: config.apiKey,
+                        extraHeaders: options.headers,
+                        body: JSON.stringify(body),
+                        signal: providerAbortScope.controller.signal,
+                    }),
+                });
                 const drained = warnings.drain();
                 return {
-                    stream: ReadableStream.from(streamOpenAIResponsesParts(responseStream)),
+                    stream: createCancelableOpenAIProviderStream(streamOpenAIResponsesParts(responseStream, {
+                        ...responseContext,
+                        webSearchToolName,
+                        preserveRawOutputItems: true,
+                    }), providerAbortScope.controller, providerAbortScope.dispose),
                     ...(drained.length > 0 ? { warnings: drained } : {}),
                 };
-            });
+            }
+            catch (error) {
+                providerAbortScope.dispose();
+                throw error;
+            }
+        },
+    };
+}
+function requestUsesOpenAIHostedTool(optionsForRuntime) {
+    const options = readRecord(optionsForRuntime);
+    if (!options || options.tools === undefined)
+        return false;
+    if (!Array.isArray(options.tools)) {
+        throw new TypeError("OpenAI runtime tools must be an array");
+    }
+    return resolveOpenAIWebSearchDescriptor(options.tools) !== undefined;
+}
+function createOpenAIAdaptiveModelRuntime(chatRuntime, responsesRuntime) {
+    return {
+        ...chatRuntime,
+        doGenerate(optionsForRuntime) {
+            return requestUsesOpenAIHostedTool(optionsForRuntime)
+                ? responsesRuntime.doGenerate(optionsForRuntime)
+                : chatRuntime.doGenerate(optionsForRuntime);
+        },
+        doStream(optionsForRuntime) {
+            return requestUsesOpenAIHostedTool(optionsForRuntime)
+                ? responsesRuntime.doStream(optionsForRuntime)
+                : chatRuntime.doStream(optionsForRuntime);
         },
     };
 }
 export function createOpenAIEmbeddingRuntime(config, modelId) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     const providerLabel = getOpenAIProviderLabel(config);
+    const providerKind = getOpenAICompatibleProviderKind(config);
+    const responseContext = { providerKind, providerLabel };
     return {
         provider: providerLabel,
         modelId,
@@ -405,7 +857,7 @@ export function createOpenAIEmbeddingRuntime(config, modelId) {
                 url,
                 fetchImpl,
                 providerLabel,
-                providerKind: "openai",
+                providerKind,
                 init: createOpenAIRequestInit({
                     apiKey: config.apiKey,
                     body: JSON.stringify({
@@ -414,14 +866,15 @@ export function createOpenAIEmbeddingRuntime(config, modelId) {
                     }),
                     signal: abortSignal,
                 }),
-            }).then((payload) => ({
-                embeddings: extractOpenAIEmbeddings(payload),
-                usage: {
-                    tokens: extractOpenAIUsageTokens(payload),
-                },
-                rawResponse: payload,
-                warnings: [],
-            }));
+            }).then((payload) => {
+                const tokens = extractOpenAIUsageTokens(payload);
+                return {
+                    embeddings: extractOpenAIEmbeddings(payload, values.length, responseContext),
+                    ...(tokens !== undefined ? { usage: { tokens } } : {}),
+                    rawResponse: payload,
+                    warnings: [],
+                };
+            });
         },
     };
 }
@@ -430,28 +883,25 @@ export class OpenAIProvider {
     createModel(modelId, config) {
         const providerLabel = getOpenAIProviderLabel(config);
         const providerName = getLLMOpenAIProviderName(config);
-        if (isOpenAIReasoningModel(modelId, providerName)) {
-            return createOpenAIResponsesRuntime({
-                apiKey: config.credential,
-                baseURL: config.baseURL,
-                name: providerLabel,
-                providerName,
-                fetch: config.fetch,
-            }, modelId);
-        }
-        return createOpenAIModelRuntime({
+        const runtimeConfig = {
             apiKey: config.credential,
             baseURL: config.baseURL,
             name: providerLabel,
             providerName,
             fetch: config.fetch,
-        }, modelId);
+        };
+        const responsesRuntime = createOpenAIResponsesRuntime(runtimeConfig, modelId);
+        if (isOpenAIReasoningModel(modelId, providerName)) {
+            return responsesRuntime;
+        }
+        return createOpenAIAdaptiveModelRuntime(createOpenAIModelRuntime(runtimeConfig, modelId), responsesRuntime);
     }
     createEmbedding(modelId, config) {
         return createOpenAIEmbeddingRuntime({
             apiKey: config.credential,
             baseURL: config.baseURL,
             name: getOpenAIProviderLabel(config),
+            providerName: getLLMOpenAIProviderName(config),
             fetch: config.fetch,
         }, modelId);
     }