@fased/fased 0.1.57 → 0.1.59

package/dist/agents/openai-transport-stream.js

@@ -0,0 +1,1040 @@
+import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./copilot-dynamic-headers.js";
+import { resolveProviderTransportTurnStateWithPlugin } from "../plugins/provider-runtime.js";
+import { stripSystemPromptCacheBoundary } from "./system-prompt-cache-boundary.js";
+import { buildGuardedModelFetch } from "./provider-transport-fetch.js";
+import { transformTransportMessages } from "./transport-message-transform.js";
+import { mergeTransportMetadata, sanitizeTransportPayloadText } from "./transport-stream-shared.js";
+import { detectOpenAICompletionsCompat } from "./openai-completions-compat.js";
+import { applyOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesPayloadPolicy } from "./openai-responses-payload-policy.js";
+import { normalizeOpenAIStrictToolParameters, resolveOpenAIStrictToolFlagForInventory, resolveOpenAIStrictToolSetting } from "./openai-tool-schema.js";
+import { randomUUID } from "node:crypto";
+import { calculateCost, createAssistantMessageEventStream, getEnvApiKey, parseStreamingJson } from "@mariozechner/pi-ai/compat";
+import { convertMessages } from "@mariozechner/pi-ai/api/openai-completions";
+
+//#region src/agents/openai-transport-stream.ts
+function resolveAzureOpenAIApiVersion(env = process.env) {
+	return env.AZURE_OPENAI_API_VERSION?.trim() || "2024-12-01-preview";
+}
+function stringifyUnknown(value, fallback = "") {
+	if (typeof value === "string") {
+		return value;
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	return fallback;
+}
+function stringifyJsonLike(value, fallback = "") {
+	if (typeof value === "string") {
+		return value;
+	}
+	if (value && typeof value === "object") {
+		return JSON.stringify(value);
+	}
+	if (typeof value === "number" || typeof value === "boolean") {
+		return String(value);
+	}
+	return fallback;
+}
+function getServiceTierCostMultiplier(serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return 2;
+		default: return 1;
+	}
+}
+function applyServiceTierPricing(usage, serviceTier) {
+	const multiplier = getServiceTierCostMultiplier(serviceTier);
+	if (multiplier === 1) {
+		return;
+	}
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function resolveOpenAIEndpoint(baseURL, path) {
+	const base = (baseURL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
+	return `${base}${path}`;
+}
+async function* parseServerSentJson(response) {
+	if (!response.body) {
+		const text = await response.text();
+		for (const line of text.split(/\r?\n/)) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed === "[DONE]") {
+				continue;
+			}
+			yield JSON.parse(trimmed);
+		}
+		return;
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const emitBlock = function* (block) {
+		const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trim()).join("\n").trim();
+		if (!data || data === "[DONE]") {
+			return;
+		}
+		yield JSON.parse(data);
+	};
+	while (true) {
+		const chunk = await reader.read();
+		if (chunk.done) {
+			break;
+		}
+		buffer += decoder.decode(chunk.value, { stream: true });
+		let boundary = buffer.indexOf("\n\n");
+		while (boundary >= 0) {
+			const block = buffer.slice(0, boundary);
+			buffer = buffer.slice(boundary + 2);
+			for (const event of emitBlock(block)) {
+				yield event;
+			}
+			boundary = buffer.indexOf("\n\n");
+		}
+	}
+	buffer += decoder.decode();
+	if (buffer.trim()) {
+		for (const event of emitBlock(buffer)) {
+			yield event;
+		}
+	}
+}
+function createOpenAIStreamClient(options) {
+	const request = async (path, payload, init) => {
+		const response = await options.fetch(resolveOpenAIEndpoint(options.baseURL, path), {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${options.apiKey}`,
+				"content-type": "application/json",
+				accept: "text/event-stream",
+				...options.defaultHeaders
+			},
+			body: JSON.stringify(payload),
+			signal: init?.signal
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "");
+			throw new Error(`OpenAI transport request failed (${response.status} ${response.statusText})${text ? `: ${text.slice(0, 500)}` : ""}`);
+		}
+		return parseServerSentJson(response);
+	};
+	return {
+		responses: { create: (payload, init) => request("/responses", payload, init) },
+		chat: { completions: { create: (payload, init) => request("/chat/completions", payload, init) } }
+	};
+}
+async function resolvePayloadOverride(onPayload, payload, model) {
+	const nextPayload = onPayload?.(payload, model);
+	return nextPayload instanceof Promise ? await nextPayload : nextPayload;
+}
+function shortHash(value) {
+	let hash = 0;
+	for (let i = 0; i < value.length; i += 1) {
+		hash = hash * 31 + value.charCodeAt(i) | 0;
+	}
+	return Math.abs(hash).toString(36);
+}
+function encodeTextSignatureV1(id, phase) {
+	return JSON.stringify({
+		v: 1,
+		id,
+		...phase ? { phase } : {}
+	});
+}
+function parseTextSignature(signature) {
+	if (!signature) {
+		return undefined;
+	}
+	if (signature.startsWith("{")) {
+		try {
+			const parsed = JSON.parse(signature);
+			if (parsed.v === 1 && typeof parsed.id === "string") {
+				return parsed.phase === "commentary" || parsed.phase === "final_answer" ? {
+					id: parsed.id,
+					phase: parsed.phase
+				} : { id: parsed.id };
+			}
+		} catch {}
+	}
+	return { id: signature };
+}
+function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+	const messages = [];
+	const normalizeIdPart = (part) => {
+		const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+		const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+		return normalized.replace(/_+$/, "");
+	};
+	const buildForeignResponsesItemId = (itemId) => {
+		const normalized = `fc_${shortHash(itemId)}`;
+		return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+	};
+	const normalizeToolCallId = (id, _targetModel, source) => {
+		if (!allowedToolCallProviders.has(model.provider)) {
+			return normalizeIdPart(id);
+		}
+		if (!id.includes("|")) {
+			return normalizeIdPart(id);
+		}
+		const [callId, itemId] = id.split("|");
+		const normalizedCallId = normalizeIdPart(callId);
+		const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+		let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
+		if (!normalizedItemId.startsWith("fc_")) {
+			normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
+		}
+		return `${normalizedCallId}|${normalizedItemId}`;
+	};
+	const transformedMessages = transformTransportMessages(context.messages, model, normalizeToolCallId);
+	const includeSystemPrompt = options?.includeSystemPrompt ?? true;
+	if (includeSystemPrompt && context.systemPrompt) {
+		messages.push({
+			role: model.reasoning && options?.supportsDeveloperRole !== false ? "developer" : "system",
+			content: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
+		});
+	}
+	let msgIndex = 0;
+	for (const msg of transformedMessages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				messages.push({
+					role: "user",
+					content: [{
+						type: "input_text",
+						text: sanitizeTransportPayloadText(msg.content)
+					}]
+				});
+			} else {
+				const content = msg.content.map((item) => item.type === "text" ? {
+					type: "input_text",
+					text: sanitizeTransportPayloadText(item.text ?? "")
+				} : {
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				}).filter((item) => model.input.includes("image") || item.type !== "input_image");
+				if (content.length > 0) {
+					messages.push({
+						role: "user",
+						content
+					});
+				}
+			}
+		} else if (msg.role === "assistant") {
+			const output = [];
+			const isDifferentModel = msg.model !== model.id && msg.provider === model.provider && msg.api === model.api;
+			for (const block of msg.content) {
+				if (block.type === "thinking") {
+					if (block.thinkingSignature) {
+						output.push(JSON.parse(block.thinkingSignature));
+					}
+				} else if (block.type === "text") {
+					let msgId = parseTextSignature(block.textSignature)?.id ?? `msg_${msgIndex}`;
+					if (msgId.length > 64) {
+						msgId = `msg_${shortHash(msgId)}`;
+					}
+					output.push({
+						type: "message",
+						role: "assistant",
+						content: [{
+							type: "output_text",
+							text: sanitizeTransportPayloadText(block.text),
+							annotations: []
+						}],
+						status: "completed",
+						id: msgId,
+						phase: parseTextSignature(block.textSignature)?.phase
+					});
+				} else if (block.type === "toolCall") {
+					const [callId, itemIdRaw] = block.id.split("|");
+					const itemId = isDifferentModel && itemIdRaw?.startsWith("fc_") ? undefined : itemIdRaw;
+					output.push({
+						type: "function_call",
+						id: itemId,
+						call_id: callId,
+						name: block.name,
+						arguments: JSON.stringify(block.arguments)
+					});
+				}
+			}
+			if (output.length > 0) {
+				messages.push(...output);
+			}
+		} else if (msg.role === "toolResult") {
+			const textResult = msg.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+			const hasImages = msg.content.some((item) => item.type === "image");
+			const [callId] = msg.toolCallId.split("|");
+			messages.push({
+				type: "function_call_output",
+				call_id: callId,
+				output: hasImages && model.input.includes("image") ? [...textResult ? [{
+					type: "input_text",
+					text: sanitizeTransportPayloadText(textResult)
+				}] : [], ...msg.content.filter((item) => item.type === "image").map((item) => ({
+					type: "input_image",
+					detail: "auto",
+					image_url: `data:${item.mimeType};base64,${item.data}`
+				}))] : sanitizeTransportPayloadText(textResult || "(see attached image)")
+			});
+		}
+		msgIndex += 1;
+	}
+	return messages;
+}
+function convertResponsesTools(tools, options) {
+	const strict = resolveOpenAIStrictToolFlagForInventory(tools, options?.strict);
+	if (strict === undefined) {
+		return tools.map((tool) => ({
+			type: "function",
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}));
+	}
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict),
+		strict
+	}));
+}
+async function processResponsesStream(openaiStream, output, stream, model, options) {
+	let currentItem = null;
+	let currentBlock = null;
+	const blockIndex = () => output.content.length - 1;
+	for await (const rawEvent of openaiStream) {
+		const event = rawEvent;
+		const type = stringifyUnknown(event.type);
+		if (type === "response.created") {
+			output.responseId = stringifyUnknown(event.response?.id);
+		} else if (type === "response.output_item.added") {
+			const item = event.item;
+			if (item.type === "reasoning") {
+				currentItem = item;
+				currentBlock = {
+					type: "thinking",
+					thinking: ""
+				};
+				output.content.push(currentBlock);
+				stream.push({
+					type: "thinking_start",
+					contentIndex: blockIndex(),
+					partial: output
+				});
+			} else if (item.type === "message") {
+				currentItem = item;
+				currentBlock = {
+					type: "text",
+					text: ""
+				};
+				output.content.push(currentBlock);
+				stream.push({
+					type: "text_start",
+					contentIndex: blockIndex(),
+					partial: output
+				});
+			} else if (item.type === "function_call") {
+				currentItem = item;
+				currentBlock = {
+					type: "toolCall",
+					id: `${stringifyUnknown(item.call_id)}|${stringifyUnknown(item.id)}`,
+					name: stringifyUnknown(item.name),
+					arguments: {},
+					partialJson: stringifyJsonLike(item.arguments)
+				};
+				output.content.push(currentBlock);
+				stream.push({
+					type: "toolcall_start",
+					contentIndex: blockIndex(),
+					partial: output
+				});
+			}
+		} else if (type === "response.reasoning_summary_text.delta") {
+			if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
+				currentBlock.thinking = `${stringifyUnknown(currentBlock.thinking)}${stringifyUnknown(event.delta)}`;
+				stream.push({
+					type: "thinking_delta",
+					contentIndex: blockIndex(),
+					delta: stringifyUnknown(event.delta),
+					partial: output
+				});
+			}
+		} else if (type === "response.output_text.delta" || type === "response.refusal.delta") {
+			if (currentItem?.type === "message" && currentBlock?.type === "text") {
+				currentBlock.text = `${stringifyUnknown(currentBlock.text)}${stringifyUnknown(event.delta)}`;
+				stream.push({
+					type: "text_delta",
+					contentIndex: blockIndex(),
+					delta: stringifyUnknown(event.delta),
+					partial: output
+				});
+			}
+		} else if (type === "response.function_call_arguments.delta") {
+			if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
+				currentBlock.partialJson = `${stringifyJsonLike(currentBlock.partialJson)}${stringifyJsonLike(event.delta)}`;
+				currentBlock.arguments = parseStreamingJson(stringifyJsonLike(currentBlock.partialJson));
+				stream.push({
+					type: "toolcall_delta",
+					contentIndex: blockIndex(),
+					delta: stringifyJsonLike(event.delta),
+					partial: output
+				});
+			}
+		} else if (type === "response.output_item.done") {
+			const item = event.item;
+			if (item.type === "reasoning" && currentBlock?.type === "thinking") {
+				const summary = Array.isArray(item.summary) ? item.summary.map((part) => String(part.text ?? "")).join("\n\n") : "";
+				currentBlock.thinking = summary;
+				currentBlock.thinkingSignature = JSON.stringify(item);
+				stream.push({
+					type: "thinking_end",
+					contentIndex: blockIndex(),
+					content: stringifyUnknown(currentBlock.thinking),
+					partial: output
+				});
+				currentBlock = null;
+			} else if (item.type === "message" && currentBlock?.type === "text") {
+				const content = Array.isArray(item.content) ? item.content : [];
+				currentBlock.text = content.map((part) => part.type === "output_text" ? String(part.text ?? "") : String(part.refusal ?? "")).join("");
+				currentBlock.textSignature = encodeTextSignatureV1(stringifyUnknown(item.id), item.phase ?? undefined);
+				stream.push({
+					type: "text_end",
+					contentIndex: blockIndex(),
+					content: stringifyUnknown(currentBlock.text),
+					partial: output
+				});
+				currentBlock = null;
+			} else if (item.type === "function_call") {
+				const args = currentBlock?.type === "toolCall" && currentBlock.partialJson ? parseStreamingJson(stringifyJsonLike(currentBlock.partialJson, "{}")) : parseStreamingJson(stringifyJsonLike(item.arguments, "{}"));
+				stream.push({
+					type: "toolcall_end",
+					contentIndex: blockIndex(),
+					toolCall: {
+						type: "toolCall",
+						id: `${stringifyUnknown(item.call_id)}|${stringifyUnknown(item.id)}`,
+						name: stringifyUnknown(item.name),
+						arguments: args
+					},
+					partial: output
+				});
+				currentBlock = null;
+			}
+		} else if (type === "response.completed") {
+			const response = event.response;
+			if (typeof response?.id === "string") {
+				output.responseId = response.id;
+			}
+			const usage = response?.usage;
+			if (usage) {
+				const cachedTokens = usage.input_tokens_details?.cached_tokens || 0;
+				output.usage = {
+					input: (usage.input_tokens || 0) - cachedTokens,
+					output: usage.output_tokens || 0,
+					cacheRead: cachedTokens,
+					cacheWrite: 0,
+					totalTokens: usage.total_tokens || 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				};
+			}
+			calculateCost(model, output.usage);
+			if (options?.applyServiceTierPricing) {
+				options.applyServiceTierPricing(output.usage, response?.service_tier ?? options.serviceTier);
+			}
+			output.stopReason = mapResponsesStopReason(response?.status);
+			if (output.content.some((block) => block.type === "toolCall") && output.stopReason === "stop") {
+				output.stopReason = "toolUse";
+			}
+		} else if (type === "error") {
+			throw new Error(`Error Code ${stringifyUnknown(event.code, "unknown")}: ${stringifyUnknown(event.message, "Unknown error")}`);
+		} else if (type === "response.failed") {
+			const response = event.response;
+			const msg = response?.error ? `${response.error.code || "unknown"}: ${response.error.message || "no message"}` : response?.incomplete_details?.reason ? `incomplete: ${response.incomplete_details.reason}` : "Unknown error (no error details in response)";
+			throw new Error(msg);
+		}
+	}
+}
+function mapResponsesStopReason(status) {
+	if (!status) {
+		return "stop";
+	}
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed":
+		case "cancelled": return "error";
+		case "in_progress":
+		case "queued": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${status}`);
+	}
+}
+function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders) {
+	const headers = { ...model.headers };
+	if (model.provider === "github-copilot") {
+		Object.assign(headers, buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages: hasCopilotVisionInput(context.messages)
+		}));
+	}
+	if (optionHeaders) {
+		Object.assign(headers, optionHeaders);
+	}
+	if (turnHeaders) {
+		Object.assign(headers, turnHeaders);
+	}
+	return headers;
+}
+function resolveProviderTransportTurnState(model, params) {
+	return resolveProviderTransportTurnStateWithPlugin({
+		provider: model.provider,
+		context: {
+			provider: model.provider,
+			modelId: model.id,
+			model,
+			sessionId: params.sessionId,
+			turnId: params.turnId,
+			attempt: params.attempt,
+			transport: params.transport
+		}
+	});
+}
+function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders) {
+	return createOpenAIStreamClient({
+		apiKey,
+		baseURL: model.baseUrl,
+		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
+		fetch: buildGuardedModelFetch(model)
+	});
+}
+function createOpenAIResponsesTransportStreamFn() {
+	return (model, context, options) => {
+		const eventStream = createAssistantMessageEventStream();
+		const stream = eventStream;
+		void (async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const turnState = resolveProviderTransportTurnState(model, {
+					sessionId: options?.sessionId,
+					turnId: randomUUID(),
+					attempt: 1,
+					transport: "stream"
+				});
+				const client = createOpenAIResponsesClient(model, context, apiKey, options?.headers, turnState?.headers);
+				let params = buildOpenAIResponsesParams(model, context, options, turnState?.metadata);
+				const nextParams = await resolvePayloadOverride(options?.onPayload, params, model);
+				if (nextParams !== undefined) {
+					params = nextParams;
+				}
+				params = mergeTransportMetadata(params, turnState?.metadata);
+				const responseStream = await client.responses.create(params, options?.signal ? { signal: options.signal } : undefined);
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				await processResponsesStream(responseStream, output, stream, model, {
+					serviceTier: options?.serviceTier,
+					applyServiceTierPricing
+				});
+				if (options?.signal?.aborted) {
+					throw new Error("Request was aborted");
+				}
+				if (output.stopReason === "aborted" || output.stopReason === "error") {
+					throw new Error("An unknown error occurred");
+				}
+				stream.push({
+					type: "done",
+					reason: output.stopReason,
+					message: output
+				});
+				stream.end();
+			} catch (error) {
+				output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+				output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+				stream.push({
+					type: "error",
+					reason: output.stopReason,
+					error: output
+				});
+				stream.end();
+			}
+		})();
+		return eventStream;
+	};
+}
+function resolveCacheRetention(cacheRetention) {
+	if (cacheRetention === "short" || cacheRetention === "long" || cacheRetention === "none") {
+		return cacheRetention;
+	}
+	if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
+		return "long";
+	}
+	return "short";
+}
+function getPromptCacheRetention(baseUrl, cacheRetention) {
+	if (cacheRetention !== "long") {
+		return undefined;
+	}
+	return baseUrl?.includes("api.openai.com") ? "24h" : undefined;
+}
+function buildOpenAIResponsesParams(model, context, options, metadata) {
+	const compat = getCompat(model);
+	const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : undefined;
+	const messages = convertResponsesMessages(model, context, new Set([
+		"openai",
+		"openai-codex",
+		"opencode"
+	]), { supportsDeveloperRole });
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
+	const params = {
+		model: model.id,
+		input: messages,
+		stream: true,
+		prompt_cache_key: cacheRetention === "none" ? undefined : options?.sessionId,
+		prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
+		...metadata ? { metadata } : {}
+	};
+	if (options?.maxTokens) {
+		params.max_output_tokens = options.maxTokens;
+	}
+	if (options?.temperature !== undefined) {
+		params.temperature = options.temperature;
+	}
+	if (options?.serviceTier !== undefined && payloadPolicy.allowsServiceTier) {
+		params.service_tier = options.serviceTier;
+	}
+	if (context.tools) {
+		params.tools = convertResponsesTools(context.tools, { strict: resolveOpenAIStrictToolSetting(model, { transport: "stream" }) });
+	}
+	const reasoningEffort = options?.reasoningEffort ?? options?.reasoning ?? (model.reasoning ? "high" : undefined);
+	if (model.reasoning) {
+		if (reasoningEffort || options?.reasoningSummary) {
+			params.reasoning = {
+				effort: reasoningEffort || "medium",
+				summary: options?.reasoningSummary || "auto"
+			};
+			params.include = ["reasoning.encrypted_content"];
+		} else if (model.provider !== "github-copilot") {
+			params.reasoning = { effort: "none" };
+		}
+	}
+	applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
+	return params;
+}
+function hasToolHistory(messages) {
+	return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && message.content.some((block) => block.type === "toolCall"));
+}
+function createOpenAICompletionsClient(model, context, apiKey, optionHeaders) {
+	return createOpenAIStreamClient({
+		apiKey,
+		baseURL: model.baseUrl,
+		defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders),
+		fetch: buildGuardedModelFetch(model)
+	});
+}
+function createOpenAICompletionsTransportStreamFn() {
+	return (model, context, options) => {
+		const eventStream = createAssistantMessageEventStream();
+		const stream = eventStream;
+		void (async () => {
+			const output = {
+				role: "assistant",
+				content: [],
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: Date.now()
+			};
+			try {
+				const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+				const client = createOpenAICompletionsClient(model, context, apiKey, options?.headers);
+				let params = buildOpenAICompletionsParams(model, context, options);
+				const nextParams = await resolvePayloadOverride(options?.onPayload, params, model);
+				if (nextParams !== undefined) {
+					params = nextParams;
+				}
+				const responseStream = await client.chat.completions.create(params, { signal: options?.signal });
+				stream.push({
+					type: "start",
+					partial: output
+				});
+				await processOpenAICompletionsStream(responseStream, output, model, stream);
+				if (options?.signal?.aborted) {
+					throw new Error("Request was aborted");
+				}
+				stream.push({
+					type: "done",
+					reason: output.stopReason,
+					message: output
+				});
+				stream.end();
+			} catch (error) {
+				output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+				output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+				stream.push({
+					type: "error",
+					reason: output.stopReason,
+					error: output
+				});
+				stream.end();
+			}
+		})();
+		return eventStream;
+	};
+}
+async function processOpenAICompletionsStream(responseStream, output, model, stream) {
+	let currentBlock = null;
+	const blockIndex = () => output.content.length - 1;
+	const finishCurrentBlock = () => {
+		if (!currentBlock) {
+			return;
+		}
+		if (currentBlock.type === "toolCall") {
+			currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
+			const completed = {
+				...currentBlock,
+				arguments: parseStreamingJson(currentBlock.partialArgs)
+			};
+			output.content[blockIndex()] = completed;
+		}
+	};
+	for await (const chunk of responseStream) {
+		output.responseId ||= chunk.id;
+		if (chunk.usage) {
+			output.usage = parseTransportChunkUsage(chunk.usage, model);
+		}
+		const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : undefined;
+		if (!choice) {
+			continue;
+		}
+		const choiceUsage = choice.usage;
+		if (!chunk.usage && choiceUsage) {
+			output.usage = parseTransportChunkUsage(choiceUsage, model);
+		}
+		if (choice.finish_reason) {
+			const finishReasonResult = mapStopReason(choice.finish_reason);
+			output.stopReason = finishReasonResult.stopReason;
+			if (finishReasonResult.errorMessage) {
+				output.errorMessage = finishReasonResult.errorMessage;
+			}
+		}
+		if (!choice.delta) {
+			continue;
+		}
+		if (choice.delta.content) {
+			if (!currentBlock || currentBlock.type !== "text") {
+				finishCurrentBlock();
+				currentBlock = {
+					type: "text",
+					text: ""
+				};
+				output.content.push(currentBlock);
+				stream.push({
+					type: "text_start",
+					contentIndex: blockIndex(),
+					partial: output
+				});
+			}
+			currentBlock.text += choice.delta.content;
+			stream.push({
+				type: "text_delta",
+				contentIndex: blockIndex(),
+				delta: choice.delta.content,
+				partial: output
+			});
+			continue;
+		}
+		const reasoningFields = [
+			"reasoning_content",
+			"reasoning",
+			"reasoning_text"
+		];
+		const reasoningField = reasoningFields.find((field) => {
+			const value = choice.delta[field];
+			return typeof value === "string" && value.length > 0;
+		});
+		if (reasoningField) {
+			if (!currentBlock || currentBlock.type !== "thinking") {
+				finishCurrentBlock();
+				currentBlock = {
+					type: "thinking",
+					thinking: "",
+					thinkingSignature: reasoningField
+				};
+				output.content.push(currentBlock);
+				stream.push({
+					type: "thinking_start",
+					contentIndex: blockIndex(),
+					partial: output
+				});
+			}
+			currentBlock.thinking += String(choice.delta[reasoningField]);
+			stream.push({
+				type: "thinking_delta",
+				contentIndex: blockIndex(),
+				delta: String(choice.delta[reasoningField]),
+				partial: output
+			});
+			continue;
+		}
+		if (choice.delta.tool_calls) {
+			for (const toolCall of choice.delta.tool_calls) {
+				if (!currentBlock || currentBlock.type !== "toolCall" || toolCall.id && currentBlock.id !== toolCall.id) {
+					finishCurrentBlock();
+					currentBlock = {
+						type: "toolCall",
+						id: toolCall.id || "",
+						name: toolCall.function?.name || "",
+						arguments: {},
+						partialArgs: ""
+					};
+					output.content.push(currentBlock);
+					stream.push({
+						type: "toolcall_start",
+						contentIndex: blockIndex(),
+						partial: output
+					});
+				}
+				if (currentBlock.type !== "toolCall") {
+					continue;
+				}
+				if (toolCall.id) {
+					currentBlock.id = toolCall.id;
+				}
+				if (toolCall.function?.name) {
+					currentBlock.name = toolCall.function.name;
+				}
+				if (toolCall.function?.arguments) {
+					currentBlock.partialArgs += toolCall.function.arguments;
+					currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
+					stream.push({
+						type: "toolcall_delta",
+						contentIndex: blockIndex(),
+						delta: toolCall.function.arguments,
+						partial: output
+					});
+				}
+			}
+		}
+	}
+	finishCurrentBlock();
+}
+function detectCompat(model) {
+	const provider = model.provider;
+	const { capabilities, defaults: compatDefaults } = detectOpenAICompletionsCompat(model);
+	const endpointClass = capabilities.endpointClass;
+	const isDefaultRoute = endpointClass === "default";
+	const isMistral = capabilities.knownProviderFamily === "mistral" || endpointClass === "mistral-public" || isDefaultRoute && provider === "mistral";
+	const isVolcengine = provider === "volcengine" || provider === "volcengine-coding" || provider === "volcengine-plan";
+	const isBytePlus = provider === "byteplus" || provider === "byteplus-coding" || provider === "byteplus-plan";
+	const reasoningEffortMap = isMistral ? {
+		minimal: "none",
+		low: "none",
+		medium: "high",
+		high: "high",
+		xhigh: "high"
+	} : isVolcengine ? {
+		off: "minimal",
+		minimal: "minimal",
+		low: "low",
+		medium: "medium",
+		high: "high",
+		xhigh: "high"
+	} : {};
+	return {
+		supportsStore: compatDefaults.supportsStore,
+		supportsDeveloperRole: compatDefaults.supportsDeveloperRole,
+		supportsReasoningEffort: compatDefaults.supportsReasoningEffort,
+		reasoningEffortMap,
+		supportsUsageInStreaming: compatDefaults.supportsUsageInStreaming,
+		maxTokensField: compatDefaults.maxTokensField,
+		requiresToolResultName: false,
+		requiresAssistantAfterToolResult: false,
+		requiresThinkingAsText: false,
+		thinkingFormat: isBytePlus ? "modelark-thinking-type" : compatDefaults.thinkingFormat,
+		openRouterRouting: {},
+		vercelGatewayRouting: {},
+		supportsStrictMode: compatDefaults.supportsStrictMode
+	};
+}
+function getCompat(model) {
+	const detected = detectCompat(model);
+	const compat = model.compat ?? {};
+	const supportsStore = typeof compat.supportsStore === "boolean" ? compat.supportsStore : detected.supportsStore;
+	const supportsReasoningEffort = typeof compat.supportsReasoningEffort === "boolean" ? compat.supportsReasoningEffort : detected.supportsReasoningEffort;
+	return {
+		supportsStore,
+		supportsDeveloperRole: compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
+		supportsReasoningEffort,
+		reasoningEffortMap: compat.reasoningEffortMap ?? detected.reasoningEffortMap,
+		supportsUsageInStreaming: compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+		maxTokensField: compat.maxTokensField ?? detected.maxTokensField,
+		requiresToolResultName: compat.requiresToolResultName ?? detected.requiresToolResultName,
+		requiresAssistantAfterToolResult: compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
+		requiresThinkingAsText: compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
+		thinkingFormat: compat.thinkingFormat ?? detected.thinkingFormat,
+		openRouterRouting: compat.openRouterRouting ?? {},
+		vercelGatewayRouting: compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
+		supportsStrictMode: compat.supportsStrictMode ?? detected.supportsStrictMode
+	};
+}
+function mapReasoningEffort(effort, reasoningEffortMap) {
+	return reasoningEffortMap[effort] ?? effort;
+}
+function convertTools(tools, compat, model) {
+	const strict = resolveOpenAIStrictToolFlagForInventory(tools, resolveOpenAIStrictToolSetting(model, {
+		transport: "stream",
+		supportsStrictMode: compat?.supportsStrictMode
+	}));
+	return tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true),
+			...strict === undefined ? {} : { strict }
+		}
+	}));
+}
+function buildOpenAICompletionsParams(model, context, options) {
+	const compat = getCompat(model);
+	const completionsContext = context.systemPrompt ? {
+		...context,
+		systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
+	} : context;
+	const params = {
+		model: model.id,
+		messages: convertMessages(model, completionsContext, compat),
+		stream: true
+	};
+	if (compat.supportsUsageInStreaming) {
+		params.stream_options = { include_usage: true };
+	}
+	if (compat.supportsStore) {
+		params.store = false;
+	}
+	if (options?.maxTokens) {
+		if (compat.maxTokensField === "max_tokens") {
+			params.max_tokens = options.maxTokens;
+		} else {
+			params.max_completion_tokens = options.maxTokens;
+		}
+	}
+	if (options?.temperature !== undefined) {
+		params.temperature = options.temperature;
+	}
+	if (context.tools) {
+		params.tools = convertTools(context.tools, compat, model);
+	} else if (hasToolHistory(context.messages)) {
+		params.tools = [];
+	}
+	if (options?.toolChoice) {
+		params.tool_choice = options.toolChoice;
+	}
+	const reasoningEffort = options?.reasoningEffort ?? options?.reasoning ?? (model.reasoning ? "high" : undefined);
+	if (compat.thinkingFormat === "modelark-thinking-type" && model.reasoning && reasoningEffort) {
+		params.thinking = { type: reasoningEffort === "off" ? "disabled" : "enabled" };
+	} else if (compat.thinkingFormat === "openrouter" && model.reasoning && reasoningEffort) {
+		params.reasoning = { effort: mapReasoningEffort(reasoningEffort, compat.reasoningEffortMap) };
+	} else if (reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
+		params.reasoning_effort = mapReasoningEffort(reasoningEffort, compat.reasoningEffortMap);
+	}
+	return params;
+}
+function parseTransportChunkUsage(rawUsage, model) {
+	const cachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+	const promptTokens = rawUsage.prompt_tokens || 0;
+	const input = Math.max(0, promptTokens - cachedTokens);
+	const outputTokens = rawUsage.completion_tokens || 0;
+	const usage = {
+		input,
+		output: outputTokens,
+		cacheRead: cachedTokens,
+		cacheWrite: 0,
+		totalTokens: input + outputTokens + cachedTokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	calculateCost(model, usage);
+	return usage;
+}
+function mapStopReason(reason) {
+	if (reason === null) {
+		return { stopReason: "stop" };
+	}
+	switch (reason) {
+		case "stop":
+		case "end": return { stopReason: "stop" };
+		case "length": return { stopReason: "length" };
+		case "function_call":
+		case "tool_calls": return { stopReason: "toolUse" };
+		case "content_filter": return {
+			stopReason: "error",
+			errorMessage: "Provider finish_reason: content_filter"
+		};
+		case "network_error": return {
+			stopReason: "error",
+			errorMessage: "Provider finish_reason: network_error"
+		};
+		default: return {
+			stopReason: "error",
+			errorMessage: `Provider finish_reason: ${reason}`
+		};
+	}
+}
+
+//#endregion
+export { createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn };