@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/openai-responses-DTkBiiy-.mjs

@@ -0,0 +1,867 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-B-9cMxz5.mjs";
+import { I as $flag, S as debug, T as warn, t as structuredCloneJSON } from "./src-DTid0g4K.mjs";
+import { A as isTransientStreamParseError, B as OpenAIHttpError, d as callWithCopilotModelRetry, l as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-B3bevhrs.mjs";
+import { A as NO_STRICT, L as sanitizeSchemaForOpenAIResponses, O as flattenExclusiveRequiredRootUnion, P as normalizeSchemaForMoonshot, a as normalizeSystemPrompts, j as adaptSchemaForStrict, k as toolWireSchema, l as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, s as resolveCacheRetention, t as createOpenAIResponsesHistoryPayload } from "./utils-2Wq2eATG.mjs";
+import { $ as isOpenRouterAnthropicModel, Ct as withEmptyCompletionRetry, D as buildResponsesInput, E as buildResponsesDeltaInput, G as getJuiceValue, I as disableStrictToolsForScope, J as getOpenAIStrictToolsScope, K as getOpenAIPromptCacheKey, N as createInitialResponsesAssistantMessage, P as createOpenAIStrictToolsState, Q as isOpenAIResponsesProgressEvent, S as applyResponsesCompatPolicy, T as applyWireModelIdTransform, Y as getOpenRouterResponsesSessionId, Z as isCompiledGrammarTooLargeStrictError, _ as applyOpenAIExtraBody, _t as isForcedToolChoice, ct as resolveOpenAICompatPolicy, dt as resolveOpenAIRequestSetup, et as isStrictToolsDisabledForScope, ft as resolveOpenAIResponsesOutputClamp, g as applyCommonResponsesSamplingParams, k as clearOpenAIStrictToolsState, n as getEnvApiKey, ot as processResponsesStream, pt as shouldRetryWithoutStrictTools, q as getOpenAIResponsesRoutingSessionId, ut as resolveOpenAIOutputTokenParam, v as applyOpenAIGatewayRouting, w as applyVercelResponsesCacheControls, yt as mapToOpenAIResponsesToolChoice } from "./stream-C_RAoxJC.mjs";
+import { t as createAbortSourceTracker } from "./abort-B7izMMna.mjs";
+import { A as semverGte, D as bareModelId, j as hostMatchesUrl, k as parseOpenAIModel } from "./models-CfT4coYT.mjs";
+import "./identity-DnB63pS7.mjs";
+import { t as findStrictToolSchemaViolation } from "./strict-tool-validation-imVLUcbI.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BDPi64mK.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-C6XbWcuB.mjs";
+import { t as notifyProviderResponse } from "./provider-response-C6vcbQyO.mjs";
+import { t as compactGrammarDefinition } from "./grammar-D-NqNUxQ.mjs";
+import { a as getOpenAIReasoningEffortFallback, c as postOpenAIStream, i as createOpenAIReasoningEffortFallbackState, n as clearOpenAIReasoningEffortFallbackState, o as rememberOpenAIReasoningEffortFallback, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-DGVVLgd1.mjs";
+import { scheduler } from "node:timers/promises";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-responses.ts
+var openai_responses_exports = /* @__PURE__ */ __exportAll({
+	buildParams: () => buildParams,
+	convertTools: () => convertTools,
+	mapOpenAIResponsesToolChoiceForTools: () => mapOpenAIResponsesToolChoiceForTools,
+	streamOpenAIResponses: () => streamOpenAIResponses,
+	supportsFreeformApplyPatch: () => supportsFreeformApplyPatch
+});
+const OPENAI_RESPONSES_PROVIDER_SESSION_STATE_PREFIX = "openai-responses:";
+const OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE = "OpenAI responses stream timed out while waiting for the first event";
+/** Consecutive stale-previous-response failures before chaining is disabled for the session. */
+const OPENAI_RESPONSES_CHAIN_STALE_FAILURE_LIMIT = 3;
+const OPENAI_RESPONSES_MAX_TRANSIENT_STREAM_RETRIES = 1;
+const OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS = 500;
+function isOpenAIResponsesReplayUnsafeEvent(event) {
+	switch (event.type) {
+		case "response.output_text.delta":
+		case "response.refusal.delta":
+		case "response.reasoning_summary_text.delta":
+		case "response.reasoning_text.delta":
+		case "response.function_call_arguments.delta":
+		case "response.custom_tool_call_input.delta": return typeof event.delta === "string" && event.delta.length > 0;
+		case "response.reasoning_summary_part.done": return true;
+		case "response.output_item.done": return true;
+		default: return false;
+	}
+}
+function isRetryableOpenAIResponsesStreamFailure(error) {
+	return isTransientStreamParseError(error) || error instanceof ProviderResponseError && error.kind === "incomplete-stream";
+}
+function createOpenAIResponsesProviderSessionState() {
+	const strictToolsState = createOpenAIStrictToolsState();
+	const reasoningEffortFallbackState = createOpenAIReasoningEffortFallbackState();
+	const state = {
+		...strictToolsState,
+		...reasoningEffortFallbackState,
+		nativeHistoryReplayWarmed: false,
+		chains: /* @__PURE__ */ new Map(),
+		close: () => {
+			state.nativeHistoryReplayWarmed = false;
+			state.chains.clear();
+			clearOpenAIStrictToolsState(state);
+			clearOpenAIReasoningEffortFallbackState(state);
+		}
+	};
+	return state;
+}
+function getOpenAIResponsesProviderSessionState(model, providerSessionState) {
+	if (!providerSessionState) return void 0;
+	const key = `${OPENAI_RESPONSES_PROVIDER_SESSION_STATE_PREFIX}${model.provider}`;
+	const existing = providerSessionState.get(key);
+	if (existing) return existing;
+	const created = createOpenAIResponsesProviderSessionState();
+	providerSessionState.set(key, created);
+	return created;
+}
+function isOpenAIResponsesStatefulEnabled(options, baseUrl) {
+	if (options?.statefulResponses === false) return false;
+	if (options?.statefulResponses === true) return true;
+	return $flag("PI_OPENAI_STATEFUL", !baseUrl || hostMatchesUrl(baseUrl, "openai"));
+}
+function getOpenAIResponsesChainState(providerSessionState, model, resolvedBaseUrl, sessionId) {
+	const key = `${resolvedBaseUrl ?? model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`;
+	const existing = providerSessionState.chains.get(key);
+	if (existing) return existing;
+	const created = {
+		canAppend: false,
+		staleFailures: 0,
+		disabled: false
+	};
+	providerSessionState.chains.set(key, created);
+	return created;
+}
+function resetOpenAIResponsesChainState(state) {
+	state.canAppend = false;
+	state.lastParams = void 0;
+	state.lastResponseId = void 0;
+	state.lastResponseItems = void 0;
+	state.lastPromptCacheBreakpointPolicy = void 0;
+}
+/**
+* Shape the next turn's request: when the session's append baseline is intact
+* (same options, strict history prefix), chain via `previous_response_id` +
+* delta-only `input`; otherwise break the chain and replay the full transcript.
+*
+* The prefix check runs on the wire form of the conversation arguments, so
+* history mutations or option changes force a full replay.
+*/
+function buildOpenAIResponsesChainedParams(params, trailingScaffoldingItems, chain) {
+	const historyParams = trailingScaffoldingItems > 0 && Array.isArray(params.input) ? {
+		...params,
+		input: params.input.slice(0, params.input.length - trailingScaffoldingItems)
+	} : params;
+	const deltaInput = chain.canAppend ? buildResponsesDeltaInput(chain.lastParams, chain.lastResponseItems, historyParams) : null;
+	if (deltaInput && deltaInput.length > 0 && chain.lastResponseId) {
+		const scaffolding = historyParams !== params && Array.isArray(params.input) ? params.input.slice(params.input.length - trailingScaffoldingItems) : [];
+		return {
+			params: {
+				...params,
+				previous_response_id: chain.lastResponseId,
+				input: [...deltaInput, ...scaffolding]
+			},
+			previousResponseId: chain.lastResponseId
+		};
+	}
+	if (chain.canAppend) resetOpenAIResponsesChainState(chain);
+	return { params };
+}
+function isOpenAIResponsesStalePreviousResponseError(error) {
+	if (!(error instanceof Error)) return false;
+	if (error.code === "previous_response_not_found") return true;
+	return /previous[ _]?response/i.test(error.message) && /not[ _]?found|invalid|expired|stale|unsupported/i.test(error.message);
+}
+function registerOpenAIResponsesChainStaleFailure(chain, error) {
+	resetOpenAIResponsesChainState(chain);
+	chain.staleFailures += 1;
+	if (chain.staleFailures >= OPENAI_RESPONSES_CHAIN_STALE_FAILURE_LIMIT) chain.disabled = true;
+	debug("OpenAI responses previous_response_id rejected; falling back to full context", {
+		error: error instanceof Error ? error.message : String(error),
+		consecutiveFailures: chain.staleFailures,
+		disabled: chain.disabled
+	});
+}
+/**
+* One-shot ZDR signal: the org will never resolve a stored response, so skip
+* the staleFailures counter and disable chaining immediately for this session.
+*/
+function markOpenAIResponsesChainZeroDataRetention(chain, error) {
+	resetOpenAIResponsesChainState(chain);
+	chain.disabled = true;
+	chain.staleFailures = OPENAI_RESPONSES_CHAIN_STALE_FAILURE_LIMIT;
+	debug("OpenAI responses chaining disabled (Zero Data Retention)", { error: error instanceof Error ? error.message : String(error) });
+}
+function maybeAddOpenRouterAnthropicCacheControl(params, model, cacheRetention) {
+	if (cacheRetention === "none" || !isOpenRouterAnthropicModel(model)) return;
+	if (params.cache_control != null) return;
+	params.cache_control = cacheRetention === "long" ? {
+		type: "ephemeral",
+		ttl: "1h"
+	} : { type: "ephemeral" };
+}
+/**
+* Generate function for OpenAI Responses API
+*/
+const streamOpenAIResponsesOnce = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		let firstTokenTime;
+		const output = createInitialResponsesAssistantMessage(model.api, model.provider, model.id);
+		let rawRequestDump;
+		let chainState;
+		let sentPreviousResponseId;
+		const abortTracker = createAbortSourceTracker(options?.signal);
+		const firstEventTimeoutAbortError = new StreamTimeoutError(OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE);
+		const { requestAbortController, requestSignal } = abortTracker;
+		const onSseEvent = options?.onSseEvent;
+		const rawSseObserver = onSseEvent ? (event) => {
+			if (!event.event && event.data && event.data !== "[DONE]") try {
+				const parsed = JSON.parse(event.data);
+				const resolvedEvent = typeof parsed.type === "string" ? parsed.type : typeof parsed.object === "string" ? parsed.object : null;
+				if (resolvedEvent) {
+					event.event = resolvedEvent;
+					event.raw = [`event: ${resolvedEvent}`, ...event.raw];
+				}
+			} catch {}
+			onSseEvent(event, model);
+		} : void 0;
+		try {
+			const routingSessionId = getOpenAIResponsesRoutingSessionId(options);
+			const promptCacheSessionId = getOpenAIPromptCacheKey(options);
+			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+			const { headers, copilotPremiumRequests, baseUrl } = resolveOpenAIRequestSetup(model, {
+				apiKey,
+				extraHeaders: options?.headers,
+				initiatorOverride: options?.initiatorOverride,
+				messages: context.messages,
+				openAISessionId: routingSessionId,
+				promptCacheSessionId
+			});
+			const premiumRequestsTotal = copilotPremiumRequests;
+			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
+			const strictToolsScope = getOpenAIStrictToolsScope(model, baseUrl);
+			const promptCacheBreakpointPolicy = resolveCacheRetention(options?.cacheRetention) !== "none" && options?.promptCache?.mode === "explicit" ? options.promptCache.breakpoint ?? "latest-stable-message" : void 0;
+			if (isOpenAIResponsesStatefulEnabled(options, baseUrl) && routingSessionId && providerSessionState) {
+				chainState = getOpenAIResponsesChainState(providerSessionState, model, baseUrl, routingSessionId);
+				if (chainState.canAppend && chainState.lastPromptCacheBreakpointPolicy !== promptCacheBreakpointPolicy) resetOpenAIResponsesChainState(chainState);
+			}
+			const builtParams = buildParams(model, context, options, providerSessionState, strictToolsScope, false, chainState?.canAppend ? chainState.lastParams?.input : void 0);
+			const { params, trailingScaffoldingItems } = builtParams;
+			let activeParams = params;
+			let activeTrailingScaffoldingItems = trailingScaffoldingItems;
+			const resolvedBaseUrl = (baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+			const requestReasoningEffortFallbacks = /* @__PURE__ */ new Map();
+			const attemptedReasoningEffortFallbacks = /* @__PURE__ */ new Set();
+			let pendingReasoningEffortFallback;
+			let activeReasoningEffortFallbackKey;
+			let activeRequestParams;
+			const applyReasoningEffortFallbackForRequest = (requestParams) => {
+				const fallbackKey = createOpenAIReasoningEffortFallbackKey("responses", resolvedBaseUrl, typeof requestParams.model === "string" ? requestParams.model : model.id);
+				const requestReasoningEffortFallback = requestReasoningEffortFallbacks.has(fallbackKey) ? requestReasoningEffortFallbacks.get(fallbackKey) : getOpenAIReasoningEffortFallback(providerSessionState, fallbackKey);
+				if (requestReasoningEffortFallback !== void 0) applyOpenAIReasoningEffortFallback(requestParams, requestReasoningEffortFallback);
+				return fallbackKey;
+			};
+			if (chainState && !chainState.disabled) params.store = true;
+			applyReasoningEffortFallbackForRequest(params);
+			let chained = chainState && !chainState.disabled ? buildOpenAIResponsesChainedParams(params, trailingScaffoldingItems, chainState) : { params };
+			sentPreviousResponseId = chained.previousResponseId;
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(model.compat.streamIdleTimeoutMs);
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs, model.compat.streamFirstEventTimeoutMs);
+			const requestTimeoutMs = firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0 ? firstEventTimeoutMs : void 0;
+			const requestUrl = `${resolvedBaseUrl}/responses`;
+			const applyPayloadReplacement = async (requestParams) => {
+				const replacementPayload = await options?.onPayload?.(requestParams, model);
+				const payload = replacementPayload !== void 0 ? replacementPayload : requestParams;
+				applyReasoningEffortFallbackForRequest(payload);
+				return payload;
+			};
+			chained = {
+				...chained,
+				params: await applyPayloadReplacement(chained.params)
+			};
+			const activeRawRequestDump = {
+				provider: model.provider,
+				api: output.api,
+				model: model.id,
+				method: "POST",
+				url: requestUrl,
+				body: chained.params
+			};
+			rawRequestDump = activeRawRequestDump;
+			const openResponsesStream = (requestParams) => {
+				activeReasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("responses", resolvedBaseUrl, typeof requestParams.model === "string" ? requestParams.model : model.id);
+				activeRequestParams = requestParams;
+				return callWithCopilotModelRetry(async () => {
+					let requestTimeout;
+					if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
+					try {
+						const headersWithTimeout = { ...headers };
+						if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
+						const { events, response, requestId } = await postOpenAIStream({
+							url: requestUrl,
+							headers: headersWithTimeout,
+							body: requestParams,
+							signal: requestSignal,
+							fetch: options?.fetch,
+							onSseEvent: rawSseObserver
+						});
+						if (requestTimeout !== void 0) {
+							clearTimeout(requestTimeout);
+							requestTimeout = void 0;
+						}
+						await notifyProviderResponse(options, response, model, requestId);
+						return events;
+					} finally {
+						if (requestTimeout !== void 0) clearTimeout(requestTimeout);
+					}
+				}, {
+					provider: model.provider,
+					signal: requestSignal
+				});
+			};
+			let strictRetryAvailable = true;
+			let activeStrictToolsApplied = builtParams.strictToolsApplied;
+			let forceDisableStrictTools = false;
+			const openResponsesStreamWithFallbacks = async () => {
+				let openaiStream;
+				while (true) try {
+					openaiStream = await openResponsesStream(chained.params);
+					if (pendingReasoningEffortFallback) {
+						rememberOpenAIReasoningEffortFallback(providerSessionState, pendingReasoningEffortFallback.key, pendingReasoningEffortFallback.fallback);
+						pendingReasoningEffortFallback = void 0;
+					}
+					break;
+				} catch (error) {
+					const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
+					const reasoningEffortFallback = activeReasoningEffortFallbackKey && activeRequestParams && !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, activeRequestParams, { explicitDisable: options?.forceReasoningOff === true || options?.disableReasoning === true && options.reasoning === void 0 }) : void 0;
+					if (reasoningEffortFallback !== void 0 && activeReasoningEffortFallbackKey) {
+						const retryMarker = `${activeReasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
+						if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
+						attemptedReasoningEffortFallbacks.add(retryMarker);
+						requestReasoningEffortFallbacks.set(activeReasoningEffortFallbackKey, reasoningEffortFallback);
+						applyOpenAIReasoningEffortFallback(chained.params, reasoningEffortFallback);
+						applyOpenAIReasoningEffortFallback(activeParams, reasoningEffortFallback);
+						activeRawRequestDump.body = chained.params;
+						pendingReasoningEffortFallback = {
+							key: activeReasoningEffortFallbackKey,
+							fallback: reasoningEffortFallback
+						};
+						continue;
+					}
+					const compiledGrammarTooLarge = isOpenRouterAnthropicModel(model) && isCompiledGrammarTooLargeStrictError(error, capturedErrorResponse);
+					if (strictRetryAvailable && !requestSignal.aborted && (compiledGrammarTooLarge || shouldRetryWithoutStrictTools(error, capturedErrorResponse, {
+						model,
+						strictToolsApplied: activeStrictToolsApplied,
+						tools: context.tools
+					}))) {
+						strictRetryAvailable = false;
+						forceDisableStrictTools = true;
+						disableStrictToolsForScope(providerSessionState, strictToolsScope);
+						const fallbackBuilt = buildParams(model, context, options, providerSessionState, strictToolsScope, true, chainState?.canAppend ? chainState.lastParams?.input : void 0);
+						const fallbackParams = fallbackBuilt.params;
+						if (chainState && !chainState.disabled) fallbackParams.store = true;
+						let fallbackChained = chainState && !chainState.disabled ? buildOpenAIResponsesChainedParams(fallbackParams, fallbackBuilt.trailingScaffoldingItems, chainState) : { params: fallbackParams };
+						sentPreviousResponseId = fallbackChained.previousResponseId;
+						fallbackChained = {
+							...fallbackChained,
+							params: await applyPayloadReplacement(fallbackChained.params)
+						};
+						chained = fallbackChained;
+						activeRawRequestDump.body = chained.params;
+						activeParams = fallbackParams;
+						activeTrailingScaffoldingItems = fallbackBuilt.trailingScaffoldingItems;
+						continue;
+					}
+					if (!chainState || !sentPreviousResponseId || requestSignal.aborted) throw error;
+					const zdrRejection = error instanceof Error && /previous[ _]?response/i.test(error.message) && /zero[ _-]?data[ _-]?retention/i.test(error.message);
+					const isPromptBlocked = error instanceof Error && (error.code === "invalid_prompt" || /invalid_prompt|Request blocked/i.test(error.message));
+					if (!zdrRejection && !isPromptBlocked && !isOpenAIResponsesStalePreviousResponseError(error)) throw error;
+					if (zdrRejection) markOpenAIResponsesChainZeroDataRetention(chainState, error);
+					else registerOpenAIResponsesChainStaleFailure(chainState, error);
+					sentPreviousResponseId = void 0;
+					const currentBuilt = buildParams(model, context, options, providerSessionState, strictToolsScope, forceDisableStrictTools);
+					const currentParams = currentBuilt.params;
+					currentParams.store = !zdrRejection;
+					const retryParams = await applyPayloadReplacement(currentParams);
+					chained = { params: retryParams };
+					activeRawRequestDump.body = retryParams;
+					activeParams = currentParams;
+					activeTrailingScaffoldingItems = currentBuilt.trailingScaffoldingItems;
+					activeStrictToolsApplied = currentBuilt.strictToolsApplied;
+				}
+				return openaiStream;
+			};
+			let openaiStream = await openResponsesStreamWithFallbacks();
+			if (premiumRequestsTotal !== void 0) output.usage.premiumRequests = premiumRequestsTotal;
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			const nativeOutputItems = [];
+			let transientStreamRetryAttempt = 0;
+			while (true) {
+				let sawReplayUnsafeOutput = false;
+				let sawTerminalResponseEvent = false;
+				const attemptStream = new AssistantMessageEventStream();
+				let forwardAttemptLive = false;
+				const forwardAttemptEvents = () => {
+					for (const event of attemptStream.queue) stream.push(event);
+					attemptStream.queue.length = 0;
+				};
+				nativeOutputItems.length = 0;
+				const timedOpenaiStream = iterateWithIdleTimeout(openaiStream, {
+					idleTimeoutMs,
+					firstItemTimeoutMs: firstEventTimeoutMs,
+					firstItemErrorMessage: OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
+					errorMessage: "OpenAI responses stream stalled while waiting for the next event",
+					onFirstItemTimeout: () => abortTracker.abortLocally(firstEventTimeoutAbortError),
+					onIdle: () => requestAbortController.abort(),
+					abortSignal: options?.signal,
+					isProgressItem: isOpenAIResponsesProgressEvent
+				});
+				const observedOpenaiStream = (async function* () {
+					for await (const event of timedOpenaiStream) {
+						if (isOpenAIResponsesReplayUnsafeEvent(event)) {
+							sawReplayUnsafeOutput = true;
+							if (!forwardAttemptLive) {
+								forwardAttemptEvents();
+								forwardAttemptLive = true;
+							}
+						}
+						yield event;
+						if (forwardAttemptLive) forwardAttemptEvents();
+					}
+				})();
+				try {
+					await processResponsesStream(observedOpenaiStream, output, attemptStream, model, {
+						onFirstToken: () => {
+							if (!firstTokenTime) firstTokenTime = performance.now();
+						},
+						onOutputItemDone: (item) => {
+							nativeOutputItems.push(item);
+						},
+						onCompleted: () => {
+							sawTerminalResponseEvent = true;
+						},
+						requestServiceTier: options?.serviceTier
+					});
+					const localAbortReason = abortTracker.getLocalAbortReason();
+					if (localAbortReason) throw localAbortReason;
+					if (abortTracker.wasCallerAbort()) throw new AbortError();
+					if (!sawTerminalResponseEvent) throw new ProviderResponseError("OpenAI responses stream closed before a terminal response event was received", {
+						provider: model.provider,
+						kind: "incomplete-stream"
+					});
+					if (output.stopReason === "aborted" || output.stopReason === "error") throw new ProviderResponseError(output.errorMessage ?? "An unknown error occurred", {
+						provider: model.provider,
+						kind: "runtime"
+					});
+					forwardAttemptEvents();
+					break;
+				} catch (error) {
+					const streamFailure = abortTracker.getLocalAbortReason() ?? error;
+					if (!(!sawReplayUnsafeOutput && !requestSignal.aborted && !abortTracker.wasCallerAbort() && transientStreamRetryAttempt < OPENAI_RESPONSES_MAX_TRANSIENT_STREAM_RETRIES && isRetryableOpenAIResponsesStreamFailure(streamFailure))) {
+						forwardAttemptEvents();
+						throw streamFailure;
+					}
+					transientStreamRetryAttempt++;
+					debug("OpenAI responses stream ended before replay-unsafe output; retrying", {
+						provider: model.provider,
+						model: model.id,
+						attempt: transientStreamRetryAttempt,
+						error: streamFailure instanceof Error ? streamFailure.message : String(streamFailure)
+					});
+					const retryOutput = createInitialResponsesAssistantMessage(model.api, model.provider, model.id);
+					output.content.length = 0;
+					output.responseId = void 0;
+					output.upstreamProvider = void 0;
+					output.errorMessage = void 0;
+					output.errorStatus = void 0;
+					output.errorId = void 0;
+					output.stopDetails = void 0;
+					output.providerPayload = void 0;
+					output.usage = retryOutput.usage;
+					if (premiumRequestsTotal !== void 0) output.usage.premiumRequests = premiumRequestsTotal;
+					output.stopReason = "stop";
+					output.duration = void 0;
+					output.ttft = void 0;
+					firstTokenTime = void 0;
+					nativeOutputItems.length = 0;
+					if (options?.providerRetryWait) await options.providerRetryWait(OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS, options.signal);
+					else await scheduler.wait(OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS, { signal: options?.signal });
+					if (abortTracker.wasCallerAbort()) throw new AbortError();
+					openaiStream = await openResponsesStreamWithFallbacks();
+				}
+			}
+			output.providerPayload = createOpenAIResponsesHistoryPayload(model.provider, nativeOutputItems);
+			const replayableResponseItems = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(structuredCloneJSON(nativeOutputItems));
+			if (replayableResponseItems) {
+				if (providerSessionState) providerSessionState.nativeHistoryReplayWarmed = true;
+				if (chainState) {
+					chainState.lastParams = structuredCloneJSON(activeTrailingScaffoldingItems > 0 && Array.isArray(activeParams.input) ? {
+						...activeParams,
+						input: activeParams.input.slice(0, activeParams.input.length - activeTrailingScaffoldingItems)
+					} : activeParams);
+					chainState.lastPromptCacheBreakpointPolicy = promptCacheBreakpointPolicy;
+					if (output.responseId) {
+						chainState.lastResponseId = output.responseId;
+						chainState.lastResponseItems = replayableResponseItems;
+						chainState.canAppend = true;
+						if (sentPreviousResponseId) chainState.staleFailures = 0;
+					} else chainState.canAppend = false;
+				}
+			} else if (chainState) {
+				chainState.canAppend = false;
+				chainState.lastParams = structuredCloneJSON(activeTrailingScaffoldingItems > 0 && Array.isArray(activeParams.input) ? {
+					...activeParams,
+					input: activeParams.input.slice(0, activeParams.input.length - activeTrailingScaffoldingItems)
+				} : activeParams);
+				chainState.lastPromptCacheBreakpointPolicy = promptCacheBreakpointPolicy;
+				chainState.lastResponseId = void 0;
+				chainState.lastResponseItems = void 0;
+			}
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			if (chainState) resetOpenAIResponsesChainState(chainState);
+			const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
+			const result = await finalize(error, {
+				api: model.api,
+				provider: model.provider,
+				abortTracker,
+				rawRequestDump,
+				capturedErrorResponse
+			});
+			output.stopReason = result.stopReason;
+			output.errorStatus = result.status;
+			output.errorId = result.id;
+			output.errorMessage = result.message;
+			const rawMetadata = error?.error?.metadata?.raw;
+			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
+			output.duration = performance.now() - startTime;
+			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+/**
+* Public entry: wrap the single-attempt Responses streamer with bounded
+* empty-completion retries — a `response.completed` carrying no content/usage
+* would otherwise stall the agent loop. Shared with the OpenAI-completions and
+* Anthropic providers via `withEmptyCompletionRetry`.
+*/
+const streamOpenAIResponses = (model, context, options) => withEmptyCompletionRetry(model, context, options, streamOpenAIResponsesOnce);
+function isOfficialOpenAIResponsesEndpoint(model) {
+	if (model.provider !== "openai") return false;
+	if (!model.baseUrl) return true;
+	try {
+		return new URL(model.baseUrl).hostname === "api.openai.com";
+	} catch {
+		return false;
+	}
+}
+/**
+* GPT-5.6+ family check for Responses routes. The model id classifies the
+* reasoning family regardless of the provider/host serving it — a cliproxy or
+* other OpenAI-compatible gateway carrying `gpt-5.6-sol` gets the same
+* scaffolding as the official endpoint.
+*/
+function isGpt56PlusResponsesModel(model) {
+	const parsed = parseOpenAIModel(bareModelId(model.requestModelId ?? model.id));
+	return parsed !== null && semverGte(parsed.version, "5.6");
+}
+function isResponsesPromptCacheableContentBlock(block) {
+	if (typeof block !== "object" || block === null || !("type" in block)) return false;
+	return block.type === "input_text" || block.type === "input_image" || block.type === "input_file";
+}
+function isResponsesPromptCacheableMessage(item) {
+	if (typeof item !== "object" || item === null || !("role" in item) || !("content" in item)) return false;
+	if (item.role !== "assistant" && item.role !== "developer" && item.role !== "system" && item.role !== "user") return false;
+	return Array.isArray(item.content) && item.content.every(isResponsesPromptCacheableContentBlock);
+}
+function isStableStringResponsesInstruction(item) {
+	if (typeof item !== "object" || item === null || !("role" in item) || !("content" in item)) return false;
+	return (item.role === "developer" || item.role === "system") && typeof item.content === "string" && item.content.length > 0;
+}
+function matchesResponsesCacheBaseline(baseline, current) {
+	if (baseline.role !== current.role || baseline.content.length !== current.content.length) return false;
+	for (let index = 0; index < baseline.content.length; index++) {
+		const baselineBlock = baseline.content[index];
+		const currentBlock = current.content[index];
+		if (!baselineBlock || !currentBlock) return false;
+		const breakpoint = baselineBlock.prompt_cache_breakpoint;
+		if (breakpoint) {
+			if (!Bun.deepEquals(baselineBlock, {
+				...currentBlock,
+				prompt_cache_breakpoint: breakpoint
+			})) return false;
+		} else if (!Bun.deepEquals(baselineBlock, currentBlock)) return false;
+	}
+	return true;
+}
+function restoreResponsesCacheBreakpointsFromBaseline(input, baseline) {
+	if (!input || !baseline) return false;
+	let restored = false;
+	for (let i = 0; i < baseline.length && i < input.length; i++) {
+		const baselineMessage = baseline[i];
+		const message = input[i];
+		if (!isResponsesPromptCacheableMessage(baselineMessage)) continue;
+		if (isStableStringResponsesInstruction(message)) {
+			const [baselineBlock] = baselineMessage.content;
+			if (baselineMessage.role === message.role && baselineBlock?.type === "input_text" && baselineBlock.text === message.content && baselineBlock.prompt_cache_breakpoint) {
+				Object.assign(message, { content: [{
+					type: "input_text",
+					text: message.content,
+					prompt_cache_breakpoint: baselineBlock.prompt_cache_breakpoint
+				}] });
+				restored = true;
+			}
+			continue;
+		}
+		if (!isResponsesPromptCacheableMessage(message) || !matchesResponsesCacheBaseline(baselineMessage, message)) continue;
+		for (let j = 0; j < baselineMessage.content.length; j++) {
+			const baselineBlock = baselineMessage.content[j];
+			const block = message.content[j];
+			if (!baselineBlock?.prompt_cache_breakpoint || !block) continue;
+			Object.assign(block, { prompt_cache_breakpoint: baselineBlock.prompt_cache_breakpoint });
+			restored = true;
+		}
+	}
+	return restored;
+}
+function hasResponsesCacheBreakpoint(input) {
+	return input?.some((message) => isResponsesPromptCacheableMessage(message) && message.content.some((block) => block.prompt_cache_breakpoint !== void 0)) ?? false;
+}
+function markLatestStableResponsesCacheBreakpoint(input, statefulBaseline) {
+	if (!input) return false;
+	if (statefulBaseline) {
+		if (restoreResponsesCacheBreakpointsFromBaseline(input, statefulBaseline)) return true;
+		if (!hasResponsesCacheBreakpoint(statefulBaseline)) return false;
+	}
+	let latestInputMessage = -1;
+	for (let i = input.length - 1; i >= 0; i--) {
+		const message = input[i];
+		if (!("role" in message)) continue;
+		if (message.role === "user" || message.role === "developer") {
+			latestInputMessage = i;
+			break;
+		}
+	}
+	if (latestInputMessage <= 0) return false;
+	for (let i = latestInputMessage - 1; i >= 0; i--) {
+		const message = input[i];
+		if (isStableStringResponsesInstruction(message)) {
+			const text = message.content;
+			Object.assign(message, { content: [{
+				type: "input_text",
+				text,
+				prompt_cache_breakpoint: { mode: "explicit" }
+			}] });
+			return true;
+		}
+		if (!isResponsesPromptCacheableMessage(message)) continue;
+		for (let j = message.content.length - 1; j >= 0; j--) {
+			const block = message.content[j];
+			if (!isResponsesPromptCacheableContentBlock(block)) continue;
+			Object.assign(block, { prompt_cache_breakpoint: { mode: "explicit" } });
+			return true;
+		}
+	}
+	return false;
+}
+function applyOpenAIResponsesPromptCachePolicy(params, model, options, statefulCacheBaseline) {
+	const promptCache = options?.promptCache;
+	if (!promptCache || resolveCacheRetention(options?.cacheRetention) === "none") return;
+	if (!model.compat.supportsPromptCacheBreakpoints) {
+		if (promptCache.mode === "explicit") throw new ConfigurationError(`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; enable compat.supportsPromptCacheBreakpoints only for a compatible endpoint.`);
+		return;
+	}
+	params.prompt_cache_options = {
+		mode: promptCache.mode,
+		ttl: promptCache.ttl ?? model.compat.promptCacheBreakpointTtl
+	};
+	if (promptCache.mode === "explicit" && promptCache.breakpoint !== "none") markLatestStableResponsesCacheBreakpoint(params.input, statefulCacheBaseline);
+}
+function buildParams(model, context, options, providerSessionState, strictToolsScope, disableStrictToolsOverride = false, statefulCacheBaseline) {
+	const policy = resolveOpenAICompatPolicy(model, {
+		endpoint: "responses",
+		reasoning: options?.reasoning,
+		disableReasoning: options?.disableReasoning,
+		toolChoice: options?.toolChoice,
+		strictResponsesPairing: options?.strictResponsesPairing,
+		includeEncryptedReasoning: options?.includeEncryptedReasoning,
+		filterReasoningHistory: options?.filterReasoningHistory,
+		omitReasoningEffort: options?.omitReasoningEffort
+	});
+	const strictResponsesPairing = policy.tools.strictResponsesPairing;
+	const shouldReplayNativeHistory = providerSessionState?.nativeHistoryReplayWarmed ?? true;
+	const messages = buildResponsesInput({
+		model,
+		context,
+		strictResponsesPairing,
+		supportsImageDetailOriginal: model.compat.supportsImageDetailOriginal,
+		nativeHistory: {
+			replay: shouldReplayNativeHistory,
+			filterReasoning: policy.reasoning.filterReasoningHistory
+		},
+		includeThinkingSignatures: shouldReplayNativeHistory && !policy.reasoning.filterReasoningHistory,
+		requiresReasoningReplayForAllTurns: policy.reasoning.enabled && policy.reasoning.requiresReasoningContentForAllAssistantTurns,
+		requiresReasoningReplayForToolCalls: policy.reasoning.enabled && policy.reasoning.requiresReasoningContentForToolCalls,
+		repairOrphanOutputs: true
+	});
+	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
+	let systemInstructions;
+	if (systemPrompts.length > 0) {
+		if (policy.messages.systemRole === "developer") messages.unshift(...systemPrompts.map((systemPrompt) => ({
+			role: "developer",
+			content: systemPrompt
+		})));
+		else systemInstructions = systemPrompts.join("\n\n");
+	}
+	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
+	const promptCacheKey = getOpenAIPromptCacheKey(options);
+	const params = {
+		model: applyWireModelIdTransform(model.requestModelId ?? model.id, model.compat.wireModelIdMode, options?.openrouterVariant),
+		input: messages,
+		instructions: systemInstructions,
+		stream: true,
+		prompt_cache_key: promptCacheKey,
+		prompt_cache_retention: promptCacheKey ? cacheRetention === "long" && model.compat.supportsLongPromptCacheRetention ? "24h" : void 0 : void 0,
+		session_id: model.compat.isOpenRouterHost ? getOpenRouterResponsesSessionId(options) : void 0,
+		store: false,
+		stream_options: model.compat.supportsObfuscationOptOut ? { include_obfuscation: false } : void 0
+	};
+	if (options?.include?.length) params.include = Array.from(new Set(options.include));
+	maybeAddOpenRouterAnthropicCacheControl(params, model, cacheRetention);
+	const outputToken = resolveOpenAIOutputTokenParam({
+		field: "max_output_tokens",
+		maxTokens: options?.maxTokens,
+		maxTokensExplicit: options?.maxTokensExplicit ?? options?.maxTokens !== void 0,
+		modelMaxTokens: model.maxTokens,
+		omitMaxOutputTokens: model.omitMaxOutputTokens ?? false,
+		isOpenRouterHost: model.compat.isOpenRouterHost,
+		alwaysSendMaxTokens: model.compat.alwaysSendMaxTokens,
+		providerOutputClamp: resolveOpenAIResponsesOutputClamp(model)
+	});
+	applyCommonResponsesSamplingParams(params, {
+		...options,
+		maxTokens: outputToken?.value
+	}, model);
+	if (options?.textVerbosity && isOfficialOpenAIResponsesEndpoint(model)) params.text = {
+		...params.text,
+		verbosity: options.textVerbosity
+	};
+	let strictToolsApplied = false;
+	if (context.tools) {
+		const strictMode = !(disableStrictToolsOverride || isStrictToolsDisabledForScope(providerSessionState, strictToolsScope)) && model.compat.supportsStrictMode !== false;
+		params.tools = convertTools(context.tools, strictMode, model);
+		strictToolsApplied = params.tools.some((t) => t.strict === true);
+		if (options?.toolChoice) {
+			const emittedNames = new Set(params.tools.map((t) => t.name).filter((n) => n !== void 0));
+			const emittedComputer = params.tools.some((tool) => tool.type === "computer");
+			const survivingTools = params.tools.length === context.tools.length ? context.tools : context.tools.filter((t) => emittedNames.has(t.customWireName ?? t.name) || t.native?.type === "computer" && emittedComputer);
+			const toolChoice = mapOpenAIResponsesToolChoiceForTools(options.toolChoice, survivingTools, model);
+			if (toolChoice !== void 0 && params.tools.length > 0) {
+				if (typeof toolChoice === "object" && toolChoice.type === "function" && !model.compat.supportsNamedToolChoice) {
+					params.tools = params.tools.filter((tool) => tool.type === "function" && tool.name === toolChoice.name);
+					params.tool_choice = "required";
+				} else params.tool_choice = toolChoice;
+			}
+		}
+	}
+	const reasoningPolicy = resolveOpenAICompatPolicy(model, {
+		endpoint: "responses",
+		reasoning: options?.reasoning,
+		disableReasoning: options?.disableReasoning,
+		toolChoice: params.tool_choice,
+		strictResponsesPairing: options?.strictResponsesPairing,
+		includeEncryptedReasoning: options?.includeEncryptedReasoning,
+		filterReasoningHistory: options?.filterReasoningHistory,
+		omitReasoningEffort: options?.omitReasoningEffort
+	});
+	const reasoningSummary = model.compat.supportsReasoningSummary ? options?.reasoningSummary : options?.reasoning === void 0 ? void 0 : null;
+	applyResponsesCompatPolicy(params, reasoningPolicy, {
+		reasoningSummary,
+		forceReasoningOff: options?.forceReasoningOff,
+		mapEffort: (effort) => model.compat.reasoningEffortMap?.[effort] ?? model.thinking?.effortMap?.[effort] ?? effort
+	});
+	if (model.reasoningMode && !options?.forceReasoningOff) params.reasoning = {
+		...params.reasoning,
+		mode: model.reasoningMode
+	};
+	if (model.compat.isVercelGatewayHost) applyVercelResponsesCacheControls(params, model.compat, cacheRetention);
+	else applyOpenAIGatewayRouting(params, model.compat);
+	applyOpenAIExtraBody(params, options?.extraBody);
+	applyOpenAIResponsesPromptCachePolicy(params, model, options, statefulCacheBaseline);
+	let trailingScaffoldingItems = 0;
+	if (options?.forceReasoningOff && isGpt56PlusResponsesModel(model)) {
+		const effort = options.reasoning ?? "medium";
+		const juice = getJuiceValue(effort);
+		messages.push({
+			role: "developer",
+			content: [{
+				type: "input_text",
+				text: `# Juice: ${juice} !important`
+			}]
+		});
+		trailingScaffoldingItems = 1;
+	}
+	return {
+		params,
+		trailingScaffoldingItems,
+		strictToolsApplied
+	};
+}
+/**
+* Whether this model should get the OpenAI custom-tool grammar variant
+* for `apply_patch`. The generated model catalog sets
+* `model.applyPatchToolType` for first-party GPT-5 Responses models; this
+* runtime path only consumes that metadata.
+* @internal Exported for tests.
+*/
+function supportsFreeformApplyPatch(model) {
+	return model.applyPatchToolType === "freeform";
+}
+/** @internal Exported for tests. */
+function mapOpenAIResponsesToolChoiceForTools(choice, tools, model) {
+	if (!model.compat.supportsToolChoice) return void 0;
+	if (isForcedToolChoice(choice) && !model.compat.supportsForcedToolChoice) return "auto";
+	if (typeof choice !== "string" && choice?.type === "computer") {
+		const computer = tools.find((tool) => tool.native?.type === "computer");
+		if (!computer) return void 0;
+		return model.supportsComputerUse === true ? { type: "computer" } : {
+			type: "function",
+			name: computer.name
+		};
+	}
+	const mapped = mapToOpenAIResponsesToolChoice(choice);
+	if (!mapped || typeof mapped === "string" || mapped.type !== "function") return mapped;
+	const directTool = tools.find((tool) => tool.name === mapped.name);
+	const customTool = supportsFreeformApplyPatch(model) ? tools.find((tool) => tool.customFormat && (tool.name === mapped.name || tool.customWireName === mapped.name)) : void 0;
+	const offeredTool = customTool ?? directTool;
+	if (offeredTool?.native?.type === "computer") return model.supportsComputerUse === true ? { type: "computer" } : {
+		type: "function",
+		name: offeredTool.name
+	};
+	if (!offeredTool) return;
+	return customTool ? {
+		type: "custom",
+		name: customTool.customWireName ?? customTool.name
+	} : mapped;
+}
+/** @internal Exported for tests. */
+function convertTools(tools, strictMode, model, onQuarantine = (toolName, schemaPath) => warn(`Tool "${toolName}" omitted from the openai-responses request: its parameter schema is invalid for this provider at ${schemaPath} (an enum/const value cannot match its declared type). Other tools are unaffected.`)) {
+	const allowFreeform = supportsFreeformApplyPatch(model);
+	const rejectXaiRootObjectUnion = model.provider === "xai" || model.provider === "xai-oauth";
+	const out = [];
+	for (const tool of tools) {
+		if (tool.native?.type === "computer" && model.supportsComputerUse === true) {
+			out.push({ type: "computer" });
+			continue;
+		}
+		if (allowFreeform && tool.customFormat) {
+			out.push({
+				type: "custom",
+				name: tool.customWireName ?? tool.name,
+				description: tool.description || "",
+				format: {
+					type: "grammar",
+					syntax: tool.customFormat.syntax,
+					definition: compactGrammarDefinition(tool.customFormat.syntax, tool.customFormat.definition)
+				}
+			});
+			continue;
+		}
+		const strict = !NO_STRICT && strictMode && tool.strict !== false;
+		const baseParameters = toolWireSchema(tool);
+		const sanitized = sanitizeSchemaForOpenAIResponses(baseParameters);
+		const providerParameters = rejectXaiRootObjectUnion ? flattenExclusiveRequiredRootUnion(sanitized) : sanitized;
+		const responseParameters = model.compat.toolSchemaFlavor === "moonshot-mfjs" ? normalizeSchemaForMoonshot(providerParameters) : providerParameters;
+		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(responseParameters, strict);
+		const violation = findStrictToolSchemaViolation(parameters, "#", { rejectXaiRootObjectUnion });
+		if (violation) {
+			onQuarantine(tool.name, violation);
+			continue;
+		}
+		out.push({
+			type: "function",
+			name: tool.name,
+			description: tool.description || "",
+			parameters,
+			...effectiveStrict ? { strict: true } : !NO_STRICT && strictMode && tool.strict === false ? { strict: false } : {}
+		});
+	}
+	return out;
+}
+//#endregion
+export { openai_responses_exports as t };