@openclaw/ai 2026.9.33 → 2026.9.35

package/dist/{openai-responses-shared-BpGnmnV8.mjs → openai-responses-shared-DLz_xgps.mjs}

@@ -6,20 +6,21 @@ import { a as normalizeOptionalString, o as normalizeStringifiedOptionalString,
 import { d as supportsOpenAITemperature } from "./openai-reasoning-effort-C_0p3psG.mjs";
 import { o as truncateUtf16Safe, s as stableStringify } from "./provider-error-CwT_j2v0.mjs";
 import { a as resolveModelSseDebugMode, d as isResponsesProviderTool, g as resolveResponsesTerminalStopReason, h as readResponsesReasoningTokens, i as resolveModelPayloadDebugMode, l as ResponsesOutputIdentityError, m as mapResponsesTerminalUsage, r as emitModelTransportDebug, u as hasOnlyResponsesFunctionTools } from "./diagnostics-CJaB6g8J.mjs";
-import { o as redactSensitiveText } from "./transport-utils-CnxX8hPj.mjs";
-import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-D1q02qdx.mjs";
+import { o as redactSensitiveText } from "./transport-utils-B11GlmDO.mjs";
+import { i as resolveOpenAICompletionsCompat } from "./openai-completions-compat-BuszNIRF.mjs";
 import { A as shortHash, C as parseJsonObjectPreservingUnsafeIntegers, E as createToolArgumentPreviewSchedule, O as parseStreamingJson, S as withProviderResponseHook, _ as sanitizeNonEmptyTransportPayloadText, b as transportAbortError, c as failTransportStream, d as iterateModelStream, g as parseTerminalToolCallArguments, t as IncompleteToolCallError, u as finalizeTransportStream, v as sanitizeTransportPayloadText } from "./transport-stream-shared-Dt7VrJFd.mjs";
-import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, s as prepareModelRequestBody } from "./simple-options-B9u6-CF3.mjs";
-import { A as redactIdentifier, C as log, d as prepareOpenAITools, h as resolveOpenAIRequestReasoning, j as sha256Hex, u as resolveOpenAIStrictToolFlagWithDiagnostics, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-C4eZAXf2.mjs";
+import { C as stripSystemPromptCacheBoundary, D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText, r as clampMaxTokensToModel, s as prepareModelRequestBody } from "./simple-options-B9u6-CF3.mjs";
+import { M as sha256Hex, S as detachPartialSnapshot, d as prepareOpenAITools, h as resolveOpenAIRequestReasoning, j as redactIdentifier, u as resolveOpenAIStrictToolFlagWithDiagnostics, w as log, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-DzSQTRdN.mjs";
 import { n as providerReplayContextMatches, t as buildProviderReplayContext } from "./provider-replay-context-BwVRJUQZ.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
 import { t as transformProviderMessages } from "./provider-transcript-transform-Cg-36VSt.mjs";
 import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-B9o0S4SZ.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-vsl-cE-n.mjs";
-import { a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY } from "./openai-responses-contracts-CLxnqS9p.mjs";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, f as withPreparedToolSchemaNormalization, r as normalizeOpenAIStrictToolParameters } from "./openai-tool-schema-DSAxYnHW.mjs";
+import { a as OPENAI_RESPONSES_COMPACTION_REPLAY_TYPE, c as OPENAI_RESPONSES_RETAINED_COMPACTION_REPLAY_TYPE, d as OpenAIResponsesWebSocketSafeRetryError, f as RESPONSE_FAILED_NO_DETAILS_MESSAGE, l as OpenAIResponsesWebSocketPostDispatchError, m as parseOpenAIResponsesWebSocketServerError, o as OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY, p as isPreviousResponseRejection, s as OPENAI_RESPONSES_REASONING_REPLAY_META_KEY, u as OpenAIResponsesWebSocketPreDispatchError } from "./openai-responses-contracts-CLxnqS9p.mjs";
 import { n as isOpenAIResponsesCompactionOutput, r as readOpenAIResponsesCompactionWindow } from "./openai-responses-compaction-window-CYGCjAQz.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import { randomUUID } from "node:crypto";
+import { ResponsesWS } from "openai/resources/responses/ws.js";
 //#region packages/ai/src/transports/openai-responses-replay.ts
 /** Resolves the assistant message id that can be replayed to OpenAI Responses. */
 function resolveReplayableResponsesMessageId(params) {
@@ -649,6 +650,492 @@ function createResponsesInputReplay(model) {
 	};
 }
 //#endregion
+//#region packages/ai/src/transports/openai-responses-steering.ts
+function cloneWireRequest(request) {
+	const serialized = JSON.stringify(request);
+	return JSON.parse(serialized);
+}
+async function projectResponsesSteeringInput(request, project) {
+	const { input: activeInput, ...activeSettings } = cloneWireRequest(request);
+	if (!Array.isArray(activeInput)) return [];
+	const { input, ...settings } = cloneWireRequest(await project());
+	if (!Array.isArray(input) || stableStringify(settings) !== stableStringify(activeSettings) || stableStringify(input.slice(0, activeInput.length)) !== stableStringify(activeInput)) return [];
+	const projected = input.slice(activeInput.length);
+	return projected.every((item) => isRecord(item) && item.role === "user") ? projected : [];
+}
+/** One response owns admission; accepted input stays on this connection until continuation. */
+function createResponsesSteering(params) {
+	let responseId;
+	let sealed = false;
+	let unsubscribe;
+	const pending = [];
+	const accepted = /* @__PURE__ */ new Map();
+	const acknowledged = /* @__PURE__ */ new Set();
+	const seal = () => {
+		sealed = true;
+		const cleanup = unsubscribe;
+		unsubscribe = void 0;
+		cleanup?.();
+	};
+	return {
+		get responseId() {
+			return responseId;
+		},
+		get pending() {
+			return pending.length > 0;
+		},
+		get acceptedInput() {
+			return [...accepted.values()].flat();
+		},
+		seal,
+		close(error) {
+			seal();
+			for (const submission of pending.splice(0)) submission.reject(error);
+		},
+		handle(event) {
+			if (!isRecord(event)) return false;
+			if (event.type === "response.created" && !responseId && !sealed) {
+				const response = isRecord(event.response) ? event.response : void 0;
+				if (typeof response?.id !== "string" || !response.id.trim()) throw new Error("Responses steering requires a response identity");
+				const activeResponseId = response.id;
+				responseId = activeResponseId;
+				const cleanup = params.onActiveResponse({
+					needsContinuation: params.needsContinuation,
+					steer(messages) {
+						if (sealed || messages.length === 0) return Promise.resolve(false);
+						params.assertActive();
+						const converted = params.toInput(messages);
+						const submit = (input) => {
+							if (sealed || input.length === 0) return Promise.resolve(false);
+							params.assertActive();
+							return new Promise((resolve, reject) => {
+								pending.push({
+									input,
+									resolve,
+									reject
+								});
+								params.send({
+									type: "response.steer",
+									previous_response_id: activeResponseId,
+									input
+								});
+							});
+						};
+						return Array.isArray(converted) ? submit(converted) : converted.then(submit);
+					}
+				});
+				if (sealed) cleanup?.();
+				else unsubscribe = cleanup;
+				return false;
+			}
+			if (event.type !== "response.steer.accepted" && event.type !== "response.steer.failed" && event.type !== "response.steer.pending") return false;
+			const steer = isRecord(event.steer) ? event.steer : void 0;
+			if (!responseId || steer?.previous_response_id !== responseId) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.failed" && steer.id === void 0) {
+				const index = pending.findIndex((submission) => stableStringify(submission.input) === stableStringify(steer.input));
+				const submission = pending[index];
+				if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+				pending.splice(index, 1);
+				submission.resolve(false);
+				return true;
+			}
+			if (typeof steer.id !== "string" || !steer.id.trim()) throw new Error("Responses steering acknowledgement has an unexpected identity");
+			if (event.type === "response.steer.pending") {
+				if (!accepted.has(steer.id)) throw new Error("Responses steering pending event has no accepted submission");
+				return true;
+			}
+			if (event.type === "response.steer.failed" && accepted.has(steer.id)) throw new Error("OpenAI could not apply accepted steering; the queued message remains in the conversation");
+			if (acknowledged.has(steer.id)) throw new Error("Responses steering acknowledgement was already applied");
+			const submission = pending.shift();
+			if (!submission) throw new Error("Responses steering acknowledgement has no pending submission");
+			acknowledged.add(steer.id);
+			if (event.type === "response.steer.accepted") {
+				accepted.set(steer.id, submission.input);
+				submission.resolve(true);
+			} else submission.resolve(false);
+			return true;
+		}
+	};
+}
+/** Accepted steering is prepended by the server, so never repeat it in response.create. */
+function omitAcceptedSteering(input, accepted) {
+	const remaining = [...input];
+	for (const message of accepted) {
+		const index = remaining.findIndex((item) => stableStringify(item) === stableStringify(message));
+		if (index < 0) throw new Error("Responses steering continuation no longer contains the accepted user input");
+		remaining.splice(index, 1);
+	}
+	return remaining;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-websocket.ts
+const SESSION_WEBSOCKET_CACHE_TTL_MS = 3e5;
+const SESSION_WEBSOCKET_MAX_AGE_MS = 33e5;
+const WEBSOCKET_OPEN_STATE = 1;
+const websocketSessionCache = /* @__PURE__ */ new Map();
+const degradedWebSocketConnections = /* @__PURE__ */ new Map();
+function isOfficialOpenAIResponsesBaseUrl(baseUrl) {
+	if (!baseUrl) return false;
+	try {
+		const url = new URL(baseUrl);
+		return url.origin === "https://api.openai.com" && url.username === "" && url.password === "" && url.search === "" && url.hash === "" && url.pathname.replace(/\/+$/, "") === "/v1";
+	} catch {
+		return false;
+	}
+}
+function supportsNativeOpenAIResponsesEndpoint(params) {
+	return params.provider.trim().toLowerCase() === "openai" && params.api === "openai-responses" && isOfficialOpenAIResponsesBaseUrl(params.baseUrl);
+}
+function closeWebSocketSilently(socket, reason = "done") {
+	try {
+		socket.close({
+			code: 1e3,
+			reason
+		});
+	} catch {}
+}
+function invalidateOwnedWebSocketSession(cacheKey, entry, reason = "done") {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+		entry.idleTimer = void 0;
+	}
+	closeWebSocketSilently(entry.socket, reason);
+	entry.steeringContinuation?.steering.close(/* @__PURE__ */ new Error("Responses steering connection closed"));
+	entry.steeringContinuation?.iterator.return?.().catch(() => void 0);
+	entry.steeringContinuation = void 0;
+	if (websocketSessionCache.get(cacheKey) === entry) websocketSessionCache.delete(cacheKey);
+}
+function scheduleSessionWebSocketExpiry(cacheKey, entry) {
+	if (entry.idleTimer) clearTimeout(entry.idleTimer);
+	entry.idleTimer = setTimeout(() => {
+		if (entry.busy) return;
+		invalidateOwnedWebSocketSession(cacheKey, entry, "idle_timeout");
+	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
+	entry.idleTimer.unref?.();
+}
+function prepareWebSocketConnection(client, headers) {
+	if (!isOfficialOpenAIResponsesBaseUrl(client.baseURL)) throw new Error("OpenAI Responses WebSocket requires the official API endpoint");
+	if (typeof client.apiKey !== "string" || client.apiKey.length === 0) throw new Error("OpenAI Responses WebSocket requires an API key");
+	const resolvedApiKey = getAiTransportHost().resolveSecretSentinel(client.apiKey);
+	const resolvedHeaders = { ...resolveAiTransportHeaderSentinels(headers) };
+	for (const key of Object.keys(resolvedHeaders)) {
+		const normalizedKey = key.toLowerCase();
+		if (normalizedKey === "authorization" || normalizedKey === "traceparent") delete resolvedHeaders[key];
+	}
+	if (!resolvedApiKey) throw new Error("OpenAI Responses WebSocket requires a resolved API key");
+	return {
+		client: client.withOptions({ apiKey: resolvedApiKey }),
+		headers: resolvedHeaders,
+		identity: sha256Hex(JSON.stringify([
+			resolvedApiKey,
+			client.baseURL,
+			Object.entries(resolvedHeaders).toSorted(([a], [b]) => a.localeCompare(b))
+		]))
+	};
+}
+function createWebSocket(connection, onError) {
+	const socket = new ResponsesWS(connection.client, {
+		headers: connection.headers,
+		maxQueueSize: 1
+	});
+	socket.on("error", () => onError(socket));
+	return socket;
+}
+function createTransientWebSocketLease(connection) {
+	const socket = createWebSocket(connection, (failedSocket) => closeWebSocketSilently(failedSocket, "transport_error"));
+	return {
+		socket,
+		iterator: socket.stream(),
+		reusedConnection: false,
+		release: () => closeWebSocketSilently(socket)
+	};
+}
+function createCachedWebSocketLease(cacheKey, entry, reusedConnection) {
+	entry.busy = true;
+	const steeringContinuation = entry.steeringContinuation;
+	entry.steeringContinuation = void 0;
+	return {
+		socket: entry.socket,
+		iterator: steeringContinuation?.iterator ?? entry.socket.stream(),
+		entry,
+		reusedConnection,
+		steeringContinuation,
+		release: ({ keep } = {}) => {
+			if (!keep || entry.socket.socket.readyState !== WEBSOCKET_OPEN_STATE) {
+				invalidateOwnedWebSocketSession(cacheKey, entry);
+				return;
+			}
+			entry.busy = false;
+			scheduleSessionWebSocketExpiry(cacheKey, entry);
+		}
+	};
+}
+function acquireWebSocket(params, connection) {
+	if (!(params.mode !== "websocket" && Boolean(params.sessionId)) || !params.sessionId) return createTransientWebSocketLease(connection);
+	const cacheKey = `${params.sessionId}\0${connection.identity}`;
+	const cached = websocketSessionCache.get(cacheKey);
+	if (cached) {
+		if (cached.idleTimer) {
+			clearTimeout(cached.idleTimer);
+			cached.idleTimer = void 0;
+		}
+		if (cached.busy) return createTransientWebSocketLease(connection);
+		const expired = Date.now() - cached.createdAt >= SESSION_WEBSOCKET_MAX_AGE_MS;
+		if (!expired && cached.socket.socket.readyState === WEBSOCKET_OPEN_STATE) return createCachedWebSocketLease(cacheKey, cached, true);
+		invalidateOwnedWebSocketSession(cacheKey, cached, expired ? "connection_age_limit" : "done");
+	}
+	const entry = {
+		socket: createWebSocket(connection, (failedSocket) => {
+			const failedEntry = websocketSessionCache.get(cacheKey);
+			if (failedEntry?.socket === failedSocket) invalidateOwnedWebSocketSession(cacheKey, failedEntry, "transport_error");
+			else closeWebSocketSilently(failedSocket, "transport_error");
+		}),
+		sessionId: params.sessionId,
+		busy: true,
+		createdAt: Date.now()
+	};
+	websocketSessionCache.set(cacheKey, entry);
+	return createCachedWebSocketLease(cacheKey, entry, false);
+}
+function sanitizeWebSocketRequest(request) {
+	const { stream: _stream, background: _background, ...websocketRequest } = request;
+	return websocketRequest;
+}
+async function nextWebSocketMessage(iterator, signal) {
+	if (!signal) return iterator.next();
+	if (signal.aborted) throw transportAbortError(signal);
+	let onAbort;
+	try {
+		return await Promise.race([iterator.next(), new Promise((_resolve, reject) => {
+			onAbort = () => reject(transportAbortError(signal));
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+function readServerEvent(message) {
+	if (message.type === "message") return message.message;
+	if (message.type === "error") throw parseOpenAIResponsesWebSocketServerError(message.error) ?? new Error("OpenAI Responses WebSocket transport failed", { cause: message.error });
+	if (message.type === "close") throw new Error(`OpenAI Responses WebSocket closed before completion (code ${message.code})`);
+}
+function createOpenAIResponsesWebSocketStream(params) {
+	const connection = prepareWebSocketConnection(params.client, params.headers);
+	let fullRequest = sanitizeWebSocketRequest(params.request);
+	const requestModel = typeof fullRequest.model === "string" ? fullRequest.model : "";
+	const degradationKey = `${params.sessionId ?? ""}\0${connection.identity}\0${requestModel}`;
+	const degraded = degradedWebSocketConnections.get(degradationKey);
+	if (degraded && degraded.retryAt > Date.now()) throw new OpenAIResponsesWebSocketPreDispatchError(/* @__PURE__ */ new Error("OpenAI Responses WebSocket is cooling down after a transport failure"));
+	degradedWebSocketConnections.delete(degradationKey);
+	const markDegraded = () => {
+		const cooldownMs = params.degradeCooldownMs;
+		if (cooldownMs === void 0 || !Number.isFinite(cooldownMs) || cooldownMs <= 0) return;
+		degradedWebSocketConnections.set(degradationKey, {
+			sessionId: params.sessionId,
+			retryAt: Date.now() + cooldownMs
+		});
+	};
+	let lease;
+	try {
+		lease = acquireWebSocket(params, connection);
+	} catch (error) {
+		markDegraded();
+		throw new OpenAIResponsesWebSocketPreDispatchError(error);
+	}
+	let prepared;
+	let previousContinuation;
+	const resumedSteering = lease.steeringContinuation;
+	const steeringMode = resumedSteering ? resumedSteering.requiresInput ? "required-input" : "automatic" : void 0;
+	try {
+		const continuation = previousContinuation = lease.entry?.continuation;
+		if (continuation && lease.entry) {
+			lease.entry.continuation = void 0;
+			prepared = resolveResponsesContinuationRequest(continuation, fullRequest, steeringMode);
+		} else {
+			fullRequest = params.restoreRequest?.(fullRequest) ?? fullRequest;
+			prepared = {
+				request: fullRequest,
+				continuationStatus: lease.entry ? "no_previous_response" : "socket_not_cached"
+			};
+		}
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw error;
+	}
+	let streamStarted = false;
+	let terminalResponse;
+	let terminalReceived = false;
+	let released = false;
+	let retainIterator = false;
+	let deferredInput = false;
+	let inputReplay;
+	if (resumedSteering) try {
+		if (prepared.continuationStatus !== "continued" || !prepared.request.previous_response_id) throw new Error("Responses steering continuation changed its request or history");
+		const input = omitAcceptedSteering(prepared.request.input ?? [], resumedSteering.acceptedInput);
+		if (!resumedSteering.requiresInput && (stableStringify(fullRequest.instructions) !== stableStringify(resumedSteering.instructions) || stableStringify(fullRequest.tools) !== stableStringify(resumedSteering.tools))) throw new Error("Responses automatic steering continuation cannot change instructions or tools");
+		const baseline = prepared.fullRequest ?? fullRequest;
+		const priorLength = (baseline.input?.length ?? 0) - (prepared.request.input?.length ?? 0);
+		const fingerprints = input.map(responsesInputFingerprint);
+		if (fingerprints.length > 0) inputReplay = {
+			afterResponseId: prepared.request.previous_response_id,
+			before: resumedSteering.requiresInput ? fingerprints : [],
+			after: resumedSteering.requiresInput ? [] : fingerprints
+		};
+		const delivered = resumedSteering.requiresInput ? input : [];
+		prepared.fullRequest = {
+			...baseline,
+			input: [
+				...(baseline.input ?? []).slice(0, priorLength),
+				...resumedSteering.acceptedInput,
+				...delivered
+			]
+		};
+		prepared.request = {
+			...prepared.request,
+			input: delivered
+		};
+		deferredInput = !resumedSteering.requiresInput && input.length > 0;
+	} catch (error) {
+		lease.iterator.return?.().catch(() => void 0);
+		lease.release({ keep: false });
+		throw new OpenAIResponsesWebSocketPostDispatchError(error);
+	}
+	const steering = lease.entry && params.onActiveResponse && params.steeringInput ? createResponsesSteering({
+		onActiveResponse: params.onActiveResponse,
+		toInput: params.steeringInput,
+		send: (event) => lease.socket.sendRaw(JSON.stringify(event)),
+		needsContinuation: () => deferredInput,
+		assertActive: () => {
+			if (released || terminalReceived || params.signal?.aborted) throw new Error("Responses steering is no longer active");
+		}
+	}) : void 0;
+	const finish = ({ keep = true } = {}) => {
+		if (released) return;
+		released = true;
+		if (keep && lease.entry && terminalResponse) lease.entry.continuation = recordResponsesContinuationState(previousContinuation, prepared.fullRequest ?? fullRequest, terminalResponse, previousContinuation?.lastResponseId === prepared.request.previous_response_id);
+		lease.release({ keep });
+	};
+	return {
+		stream: { async *[Symbol.asyncIterator]() {
+			if (streamStarted) throw new Error("OpenAI Responses WebSocket stream can only be consumed once");
+			streamStarted = true;
+			const iterator = lease.iterator;
+			let requestDispatched = false;
+			try {
+				if (params.signal?.aborted) throw transportAbortError(params.signal);
+				if (resumedSteering) {
+					requestDispatched = true;
+					if (resumedSteering.requiresInput) lease.socket.send({
+						...prepared.request,
+						type: "response.create"
+					});
+				}
+				for (;;) {
+					const buffered = resumedSteering?.buffered.shift();
+					const next = buffered ? {
+						value: buffered,
+						done: false
+					} : await nextWebSocketMessage(iterator, params.signal);
+					if (next.done) throw new Error("OpenAI Responses WebSocket closed before a terminal response event");
+					if (next.value.type === "open") {
+						if (!requestDispatched) {
+							requestDispatched = true;
+							lease.socket.send({
+								...prepared.request,
+								type: "response.create"
+							});
+						}
+						continue;
+					}
+					const event = readServerEvent(next.value);
+					if (!event) continue;
+					if (isRecord(event) && typeof event.type === "string" && event.type.startsWith("response.steer.")) {
+						if ((isRecord(event.steer) && event.steer.previous_response_id === steering?.responseId ? steering : resumedSteering?.steering ?? steering)?.handle(event)) continue;
+					}
+					steering?.handle(event);
+					if (event.type === "response.completed") terminalResponse = event.response;
+					terminalReceived = event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed";
+					if (terminalReceived) {
+						steering?.seal();
+						if (event.type === "response.failed") steering?.close(/* @__PURE__ */ new Error("Responses failed before steering could be applied"));
+						const continuationBuffer = [];
+						for (;;) {
+							if (!steering?.pending) break;
+							const acknowledgement = await nextWebSocketMessage(iterator, params.signal);
+							if (acknowledgement.done) throw new Error("Responses closed before acknowledging steering");
+							const acknowledgedEvent = readServerEvent(acknowledgement.value);
+							if (!steering.handle(acknowledgedEvent)) continuationBuffer.push(acknowledgement.value);
+						}
+						const acceptedInput = steering?.acceptedInput ?? [];
+						const isSteered = event.type === "response.incomplete" && isRecord(event.response.incomplete_details) && event.response.incomplete_details.reason === "steered";
+						if (lease.entry && steering && acceptedInput.length > 0 && (event.type === "response.completed" || isSteered)) {
+							if (event.type === "response.incomplete") terminalResponse = event.response;
+							lease.entry.steeringContinuation = {
+								iterator,
+								buffered: continuationBuffer,
+								acceptedInput,
+								requiresInput: (terminalResponse?.output ?? []).some((item) => (item.type === "function_call" || item.type === "custom_tool_call") && !(isRecord(item) && item.async === true) || item.type === "mcp_approval_request"),
+								steering,
+								instructions: fullRequest.instructions,
+								tools: fullRequest.tools
+							};
+							retainIterator = true;
+							if (isSteered) {
+								yield {
+									...event,
+									type: "response.completed",
+									response: {
+										...event.response,
+										status: "completed",
+										incomplete_details: null
+									}
+								};
+								return;
+							}
+						}
+					}
+					yield event;
+					if (terminalReceived) {
+						degradedWebSocketConnections.delete(degradationKey);
+						return;
+					}
+				}
+			} catch (error) {
+				const steeringDispatched = Boolean(steering?.pending || steering?.acceptedInput.length || resumedSteering);
+				steering?.close(error instanceof Error ? error : /* @__PURE__ */ new Error("Responses steering failed"));
+				if (lease.entry) lease.entry.continuation = void 0;
+				const safeRetry = error instanceof OpenAIResponsesWebSocketSafeRetryError && !steeringDispatched;
+				if (!params.callerSignal?.aborted && !safeRetry) markDegraded();
+				if (!requestDispatched && !params.signal?.aborted) throw new OpenAIResponsesWebSocketPreDispatchError(error);
+				if (!requestDispatched || params.callerSignal?.aborted || safeRetry) throw error;
+				throw new OpenAIResponsesWebSocketPostDispatchError(error);
+			} finally {
+				steering?.seal();
+				if (!retainIterator) {
+					steering?.close(/* @__PURE__ */ new Error("Responses stream ended before steering was confirmed"));
+					await iterator.return?.().catch(() => void 0);
+				}
+				if (!terminalReceived) finish({ keep: false });
+			}
+		} },
+		request: prepared.request,
+		fullRequest: prepared.fullRequest ?? fullRequest,
+		reusedConnection: lease.reusedConnection,
+		continuationStatus: prepared.continuationStatus,
+		inputReplay,
+		finish
+	};
+}
+function closeOpenAIResponsesWebSocketSessions(sessionId) {
+	for (const [cacheKey, entry] of websocketSessionCache) {
+		if (sessionId && entry.sessionId !== sessionId) continue;
+		invalidateOwnedWebSocketSession(cacheKey, entry, "session_cleanup");
+	}
+	for (const [key, entry] of degradedWebSocketConnections) if (!sessionId || entry.sessionId === sessionId) degradedWebSocketConnections.delete(key);
+}
+registerSessionResourceCleanup(closeOpenAIResponsesWebSocketSessions);
+//#endregion
 //#region packages/ai/src/transports/openai-responses-replay-messages-internal.ts
 function stripEncryptedReasoningContentFields(value) {
 	if (!value || typeof value !== "object") return {
@@ -803,6 +1290,9 @@ function buildResponsesInputMessage(role, content, source) {
 		...identity ? { [responsesInputSource]: identity } : {}
 	};
 }
+function resolveResponsesInstructionRole(model) {
+	return model.reasoning && model.compat?.supportsDeveloperRole !== false ? "developer" : "system";
+}
 function convertResponsesMessagesWithStyle(model, context, allowedToolCallProviders, options, conversionStyle) {
 	const messages = [];
 	const providerStyle = conversionStyle === "provider";
@@ -851,7 +1341,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 		preserveUnframedToolResults: replayPlan.preserveUnframedToolResults
 	});
 	const transformedMessages = orderResponsesAsyncToolResults(transformMessages(replayPlan.messages));
-	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && model.compat?.supportsDeveloperRole !== false ? "developer" : "system", [{
+	if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(resolveResponsesInstructionRole(model), [{
 		type: "input_text",
 		text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
 	}]));
@@ -873,13 +1363,15 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 	}
 	let msgIndex = 0;
 	const appendAssistant = createResponsesInputReplay(model);
+	const inHistorySystemUpdates = supportsNativeOpenAIResponsesEndpoint(model);
 	for (const msg of replayMessages) {
 		if (!("role" in msg)) {
 			messages.push(msg);
 			continue;
 		}
 		if (msg.role === "user") {
-			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
+			const role = msg.runtimeContextCarrier === true && inHistorySystemUpdates ? resolveResponsesInstructionRole(model) : "user";
+			if (typeof msg.content === "string") messages.push(buildResponsesInputMessage(role, [{
 				type: "input_text",
 				text: sanitizeTransportPayloadText(msg.content)
 			}], msg));
@@ -892,7 +1384,7 @@ function convertResponsesMessagesWithStyle(model, context, allowedToolCallProvid
 					detail: "auto",
 					image_url: `data:${item.mimeType};base64,${item.data}`
 				}).filter((item) => providerStyle || model.input.includes("image") || item.type !== "input_image");
-				if (content.length > 0) messages.push(buildResponsesInputMessage("user", content, msg));
+				if (content.length > 0) messages.push(buildResponsesInputMessage(role, content, msg));
 				else if (providerStyle) continue;
 			}
 		} else if (msg.role === "assistant") {
@@ -1704,7 +2196,7 @@ function createResponsesOutputTracker(params) {
 		trackStream(sink) {
 			return { push(event) {
 				visibleTextEmitted ||= event.type === "text_delta" && event.delta.length > 0 || event.type === "text_end" && event.content.length > 0;
-				sink.push(event);
+				sink.push(detachPartialSnapshot(event));
 			} };
 		},
 		observeEvent(event) {
@@ -2565,7 +3057,7 @@ function applyResponsesServiceTierPricing(usage, serviceTier, model) {
 	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 }
 function applyCommonResponsesParams(params, model, context, options, config) {
-	if (options?.maxTokens) params.max_output_tokens = Math.max(options.maxTokens, 16);
+	if (options?.maxTokens) params.max_output_tokens = clampMaxTokensToModel(model, Math.max(options.maxTokens, 16));
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) params.temperature = options.temperature;
 	if (context.tools) {
 		const tools = convertResponsesToolPayload(context.tools, { model });
@@ -2686,4 +3178,4 @@ async function runResponsesStreamLifecycle(params) {
 	}
 }
 //#endregion
-export { OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as $, recordResponsesContextUsage as A, resolveResponsesContinuationRequest as B, resolveAzureOpenAIApiVersion as C, safeDebugValue as D, logResponsesFailedNoDetails as E, convertResponsesMessages as F, supportsResponsesReasoningUpdate as G, responsesContinuationRequestFingerprint as H, recordResponsesInputReplay as I, captureOpenAIResponsesCompaction as J, CompactionReplayRefreshRequiredError as K, responsesInputFingerprint as L, bindResponsesInputMessage as M, buildResponsesInputMessage as N, summarizeOpenAITransportError as O, convertProviderResponsesMessages as P, OPENAI_RESPONSES_CALL_ID_RE as Q, claimOpenAIResponsesHttpContinuation as R, isInvalidEncryptedContentError as S, ResponsesStreamFailure as T, isConfigurationUpdate as U, responsesContinuationPrefixFingerprint as V, replayResponsesReasoningUpdates as W, resolveNewestOpenAIResponsesCompactionReplay as X, isOpenAIResponsesReplayContext as Y, suppressOpenAIResponsesCompaction as Z, isResponsesTextContentPartType as _, prepareResponsesTools as a, commitResponsesEncryptedContentAttempt as b, observeResponsesStream as c, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as d, OPENAI_RESPONSES_ID_MAX_LENGTH as et, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as f, isAzureResponsesTextDeltaEventType as g, isAzureResponsesTextDeltaEvent as h, convertResponsesToolPayload as i, resolveReplayableResponsesMessageId as it, resolveResponsesContextUsageBoundary as j, summarizeResponsesPayload as k, createResponsesToolCallTracker as l, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as m, applyResponsesServiceTierPricing as n, shouldNormalizeOpenAIResponsesToolCallId as nt, readOpenAIMisalignmentReview as o, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as p, buildOpenAIResponsesReasoningReplayMetadata as q, runResponsesStreamLifecycle as r, splitOpenAIFunctionCallPairing as rt, processResponsesStream as s, applyCommonResponsesParams as t, normalizeOpenAIResponsesFunctionCallId as tt, readResponsesToolCallItemIdentity as u, isResponsesTextDeltaEventType as v, resolveNextResponsesEncryptedContentAttempt as w, createResponsesStreamWithEncryptedContentRetry as x, resolveResponsesMessageSnapshotCollapse as y, recordResponsesContinuationState as z };
+export { OPENAI_RESPONSES_FUNCTION_CALL_ITEM_ID_RE as $, recordResponsesContextUsage as A, claimOpenAIResponsesHttpContinuation as B, resolveAzureOpenAIApiVersion as C, safeDebugValue as D, logResponsesFailedNoDetails as E, convertResponsesMessages as F, supportsResponsesReasoningUpdate as G, responsesContinuationRequestFingerprint as H, createOpenAIResponsesWebSocketStream as I, captureOpenAIResponsesCompaction as J, CompactionReplayRefreshRequiredError as K, supportsNativeOpenAIResponsesEndpoint as L, bindResponsesInputMessage as M, buildResponsesInputMessage as N, summarizeOpenAITransportError as O, convertProviderResponsesMessages as P, OPENAI_RESPONSES_CALL_ID_RE as Q, projectResponsesSteeringInput as R, isInvalidEncryptedContentError as S, ResponsesStreamFailure as T, isConfigurationUpdate as U, responsesContinuationPrefixFingerprint as V, replayResponsesReasoningUpdates as W, resolveNewestOpenAIResponsesCompactionReplay as X, isOpenAIResponsesReplayContext as Y, suppressOpenAIResponsesCompaction as Z, isResponsesTextContentPartType as _, prepareResponsesTools as a, commitResponsesEncryptedContentAttempt as b, observeResponsesStream as c, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as d, OPENAI_RESPONSES_ID_MAX_LENGTH as et, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as f, isAzureResponsesTextDeltaEventType as g, isAzureResponsesTextDeltaEvent as h, convertResponsesToolPayload as i, resolveReplayableResponsesMessageId as it, resolveResponsesContextUsageBoundary as j, summarizeResponsesPayload as k, createResponsesToolCallTracker as l, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as m, applyResponsesServiceTierPricing as n, shouldNormalizeOpenAIResponsesToolCallId as nt, readOpenAIMisalignmentReview as o, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as p, buildOpenAIResponsesReasoningReplayMetadata as q, runResponsesStreamLifecycle as r, splitOpenAIFunctionCallPairing as rt, processResponsesStream as s, applyCommonResponsesParams as t, normalizeOpenAIResponsesFunctionCallId as tt, readResponsesToolCallItemIdentity as u, isResponsesTextDeltaEventType as v, resolveNextResponsesEncryptedContentAttempt as w, createResponsesStreamWithEncryptedContentRetry as x, resolveResponsesMessageSnapshotCollapse as y, recordResponsesInputReplay as z };

package/dist/{openai-responses-terminal-usage-D0WZQlIF.d.mts → openai-responses-terminal-usage-CLzeNWqW.d.mts}

@@ -1,5 +1,5 @@
-import { K as StopReason, a as AssistantMessage, ot as Usage } from "./types-CLLR3eB4.mjs";
-import "./types-CoL-LJ7j.mjs";
+import { K as StopReason, a as AssistantMessage, ot as Usage } from "./types-B89w6ly2.mjs";
+import "./types-DbmNRKvK.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-responses-terminal-usage.d.ts
 /** A known output ceiling can resume sampling after admitted tools have settled. */

package/dist/{openai-tool-schema-vsl-cE-n.mjs → openai-tool-schema-DSAxYnHW.mjs}

@@ -982,6 +982,21 @@ function normalizeOpenAIStrictCompatSchemaRecursive(schema, promoteEmptyObject =
 function normalizeOpenAIStrictCompatSchema(schema) {
 	return normalizeOpenAIStrictCompatSchemaRecursive(schema, true);
 }
+/**
+* Returns whether a regex pattern contains a lookahead or lookbehind group.
+* Escaped parentheses, character classes, and named groups are not lookarounds.
+*/
+function hasRegexLookaround(pattern) {
+	let inCharacterClass = false;
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === "\\") index += 1;
+		else if (inCharacterClass) inCharacterClass = char !== "]";
+		else if (char === "[") inCharacterClass = true;
+		else if (char === "(" && /^\?<?[=!]/.test(pattern.slice(index + 1, index + 4))) return true;
+	}
+	return false;
+}
 /** Finds schema paths that violate OpenAI strict tool-schema requirements. */
 function findOpenAIStrictSchemaViolations(schema, path, options) {
 	if (Array.isArray(schema)) {
@@ -997,6 +1012,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 		"allOf"
 	]) if (key in record) violations.push(`${path}.${key}`);
 	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	if (typeof record.pattern === "string" && hasRegexLookaround(record.pattern)) violations.push(`${path}.pattern`);
 	const properties = isRecord(record.properties) ? record.properties : void 0;
 	if (record.type === "object") {
 		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
@@ -1082,7 +1098,8 @@ function normalizeOpenAIStrictToolParameters(schema, strict, modelCompat) {
 }
 /** Returns whether a schema already satisfies OpenAI strict tool-schema constraints. */
 function isStrictOpenAIJsonSchemaCompatible(schema) {
-	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
+	const normalized = normalizeStrictOpenAIJsonSchema(schema);
+	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalized) && findOpenAIStrictSchemaViolations(normalized, "parameters").length === 0;
 }
 /** Returns strict-schema diagnostics for an already materialized OpenAI tool projection. */
 function findOpenAIStrictToolProjectionDiagnostics(projection) {