@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/{openai-completions-BaIpl93j.mjs → openai-completions-D88orSJ9.mjs}

@@ -1,19 +1,17 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
-import { r as clampThinkingLevel } from "./model-utils-Dau5dlgm.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { i as clampThinkingLevel } from "./sanitize-unicode-BP7HLLZn.mjs";
+import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
+import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { c as buildBaseOptions, m as splitSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
-import { a as convertMessages, c as resolveOpenAICompletionsResponseFormat, d as rememberPendingCommentaryTags, f as tagPendingCommentaryText, i as finalizeOpenAICompletionsToolCalls, l as shouldOmitOllamaCompatResponseFormat, n as mapOpenAIStopReason, r as createOpenAICompletionsToolCallDeltaNormalizer, s as resolveOpenAICompletionsCompat, t as resolveOpenAIReasoningEffortMap, u as clearPendingCommentaryText } from "./openai-reasoning-compat-DKebnIBL.mjs";
-import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
+import { A as splitSystemPromptCacheBoundary, C as withProviderResponseHook, P as sortPromptCacheToolsByName, n as buildBaseOptions, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
+import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, h as tagUnresolvedTextAsCommentary, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, m as tagPendingCommentaryText, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagInterruptedTextPhases, r as convertMessages, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-9OONKyAm.mjs";
+import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-BjtkplhG.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-CPNv7A3r.mjs";
-import { a as parseOpenAICompletionsUsage, l as projectOpenAITools, o as readOpenAICompletionsContentDeltas, r as isOpenAICompletionsThinkingEnabled, u as reconcileOpenAICompletionsToolChoice } from "./openai-transport-shared-Cipt7egQ.mjs";
-import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-CGDyLWUR.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { t as formatProviderError } from "./provider-error-DI0Ts28U.mjs";
+import { c as isOpenAICompletionsThinkingEnabled, d as parseOpenAICompletionsUsage, f as readOpenAICompletionsContentDeltas, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIProviderAcceptanceHook, p as readOpenAICompletionsReasoningBatch, t as projectOpenAITools } from "./openai-tool-projection-CHGLt03m.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { t as createReasoningTagTextPartitioner } from "./reasoning-tag-text-partitioner-5ygO2rZc.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-completions.ts
@@ -22,20 +20,6 @@ var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAICompletions: () => streamOpenAICompletions,
 	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
 });
-/**
-* Check if conversation messages contain tool calls or tool results.
-* This is needed because Anthropic (via proxy) requires the tools param
-* to be present when messages include tool_calls or tool role messages.
-*/
-function hasToolHistory(messages) {
-	for (const msg of messages) {
-		if (msg.role === "toolResult") return true;
-		if (msg.role === "assistant") {
-			if (Array.isArray(msg.content) && msg.content.some((block) => block.type === "toolCall")) return true;
-		}
-	}
-	return false;
-}
 function isEncryptedReasoningDetail(detail) {
 	if (typeof detail !== "object" || detail === null) return false;
 	const candidate = detail;
@@ -72,6 +56,8 @@ const streamOpenAICompletions = (model, context, options) => {
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			const compat = resolveOpenAICompletionsCompat(model);
+			const visibleReasoningDetailTypes = new Set(compat.visibleReasoningDetailTypes);
+			const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
 			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
 			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
@@ -85,16 +71,21 @@ const streamOpenAICompletions = (model, context, options) => {
 				maxRetries: options?.maxRetries ?? 0
 			};
 			const { data: openaiStream, response } = await client.chat.completions.create(params, requestOptions).withResponse();
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			stream.push({
-				type: "start",
-				partial: output
+			const hookedOpenAIStream = withProviderResponseHook({
+				stream: openaiStream,
+				signal: firstEventAbort.signal,
+				abort: firstEventAbort.abort,
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
+				onReady: () => stream.push({
+					type: "start",
+					partial: output
+				})
 			});
 			let textBlock = null;
+			let textBlockSource;
 			let thinkingBlock = null;
+			let pendingInterruptedTextBlock = null;
+			let confirmedInterruptedTextBlock = null;
 			let hasFinishReason = false;
 			const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
 			const toolCallBlocksById = /* @__PURE__ */ new Map();
@@ -104,6 +95,7 @@ const streamOpenAICompletions = (model, context, options) => {
 			const blocks = output.content;
 			const finishedBlocks = /* @__PURE__ */ new Set();
 			const contentIndices = /* @__PURE__ */ new WeakMap();
+			let explicitVisibleTextBlocks;
 			const appendBlock = (block) => {
 				contentIndices.set(block, blocks.length);
 				blocks.push(block);
@@ -141,12 +133,21 @@ const streamOpenAICompletions = (model, context, options) => {
 					partial: output
 				});
 			};
-			const ensureTextBlock = () => {
+			const finishTextBlock = () => {
+				if (!textBlock) return;
+				finishBlock(textBlock);
+				textBlock = null;
+				textBlockSource = void 0;
+			};
+			const ensureTextBlock = (source) => {
+				if (textBlock && textBlockSource !== source) finishTextBlock();
 				if (!textBlock) {
 					textBlock = {
 						type: "text",
 						text: ""
 					};
+					textBlockSource = source;
+					if (source === "reasoning_detail") (explicitVisibleTextBlocks ??= /* @__PURE__ */ new Set()).add(textBlock);
 					appendBlock(textBlock);
 					stream.push({
 						type: "text_start",
@@ -178,10 +179,14 @@ const streamOpenAICompletions = (model, context, options) => {
 					thinkingBlock = null;
 				}
 			};
-			const appendTextDelta = (delta) => {
+			const appendTextDelta = (delta, source) => {
 				sealNativeReasoningBeforeText();
-				const block = ensureTextBlock();
+				const block = ensureTextBlock(source);
 				block.text += delta;
+				if (pendingInterruptedTextBlock && delta.trim()) {
+					confirmedInterruptedTextBlock = pendingInterruptedTextBlock;
+					pendingInterruptedTextBlock = null;
+				}
 				stream.push({
 					type: "text_delta",
 					contentIndex: getContentIndex(block),
@@ -199,6 +204,15 @@ const streamOpenAICompletions = (model, context, options) => {
 					partial: output
 				});
 			};
+			const appendReasoningDeltas = (reasoningDeltas) => {
+				for (const reasoningDelta of reasoningDeltas) if (reasoningDelta.kind === "thinking") {
+					if (!shouldEmitReasoning) continue;
+					finishTextBlock();
+					const signature = reasoningDelta.signature;
+					const thinkingSignature = model.provider === "opencode-go" && signature === "reasoning" ? "reasoning_content" : signature;
+					appendThinkingDelta(thinkingSignature, reasoningDelta.text);
+				} else appendTextDelta(reasoningDelta.text, reasoningDelta.source);
+			};
 			const ensureToolCallBlock = (toolCall) => {
 				const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
 				let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
@@ -239,7 +253,22 @@ const streamOpenAICompletions = (model, context, options) => {
 			const flushPartitionedContent = () => {
 				for (const delta of reasoningTagTextPartitioner.flush()) if (delta.kind === "text") appendTextDelta(delta.text);
 			};
-			const guardedOpenaiStream = withFirstStreamEventTimeout(openaiStream, {
+			const sealTextBeforeReasoning = () => {
+				if (!textBlock && !reasoningTagTextPartitioner.hasPending()) return;
+				flushPartitionedContent();
+				if (!textBlock) return;
+				if (textBlockSource !== "reasoning_detail" && textBlock.text.trim()) pendingInterruptedTextBlock = textBlock;
+				finishTextBlock();
+			};
+			const beginReasoning = (hasFollowingVisibleText, forceStrict = false) => {
+				if (!output.openclawDelivery?.textPhaseRequiresTerminal) output.openclawDelivery = {
+					...output.openclawDelivery,
+					textPhaseRequiresTerminal: true
+				};
+				if (forceStrict || reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
+				if (!hasFollowingVisibleText || !reasoningTagTextPartitioner.hasPendingSyntax()) sealTextBeforeReasoning();
+			};
+			const guardedOpenaiStream = withFirstStreamEventTimeout(hookedOpenAIStream, {
 				provider: model.provider,
 				api: model.api,
 				model: model.id,
@@ -268,30 +297,21 @@ const streamOpenAICompletions = (model, context, options) => {
 				const rawChoiceDelta = choice.delta ?? choice.message;
 				if (rawChoiceDelta) for (const normalizedDelta of normalizeToolCallDeltas(rawChoiceDelta, choice.finish_reason)) {
 					const choiceDelta = normalizedDelta.delta;
-					const reasoningFields = [
-						"reasoning_content",
-						"reasoning",
-						"reasoning_text"
-					];
-					const deltaFields = choiceDelta;
-					const shouldEmitReasoning = Boolean(model.reasoning && options?.reasoningEffort && isOpenAICompletionsThinkingEnabled(options.reasoningEffort));
-					let foundReasoningField = null;
-					for (const field of reasoningFields) {
-						const value = deltaFields[field];
-						if (typeof value === "string" && value.length > 0) {
-							foundReasoningField = field;
-							break;
-						}
+					const reasoningBatch = readOpenAICompletionsReasoningBatch(choiceDelta, visibleReasoningDetailTypes);
+					const reasoningDeltas = reasoningBatch.deltas;
+					const hasReasoningThinking = reasoningBatch.hasThinking;
+					const contentDeltas = readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, reasoningBatch.mirroredThinking);
+					const lastVisibleTextIndex = contentDeltas.findLastIndex((delta) => delta.kind === "text");
+					const hasSameChunkVisibleText = reasoningBatch.hasVisibleText || lastVisibleTextIndex !== -1;
+					if (hasReasoningThinking) {
+						beginReasoning(hasSameChunkVisibleText, true);
+						appendReasoningDeltas(reasoningDeltas);
 					}
-					if (foundReasoningField) reasoningTagTextPartitioner.markStrict();
-					if (shouldEmitReasoning && foundReasoningField) {
-						const delta = deltaFields[foundReasoningField];
-						if (typeof delta === "string" && delta.length > 0) appendThinkingDelta(model.provider === "opencode-go" && foundReasoningField === "reasoning" ? "reasoning_content" : foundReasoningField, delta);
-					}
-					for (const contentDelta of readOpenAICompletionsContentDeltas(choiceDelta.content, choiceDelta.refusal, foundReasoningField ? [deltaFields[foundReasoningField]] : [])) if (contentDelta.kind === "thinking") {
-						if (reasoningTagTextPartitioner.hasPending()) reasoningTagTextPartitioner.markStrict();
+					for (const [contentDeltaIndex, contentDelta] of contentDeltas.entries()) if (contentDelta.kind === "thinking") {
+						beginReasoning(contentDeltaIndex < lastVisibleTextIndex);
 						if (shouldEmitReasoning) appendThinkingDelta(contentDelta.signature, contentDelta.text);
-					} else appendPartitionedContent(contentDelta.text, Boolean(foundReasoningField));
+					} else appendPartitionedContent(contentDelta.text, hasReasoningThinking);
+					if (!hasReasoningThinking) appendReasoningDeltas(reasoningDeltas);
 					const toolCallDeltas = normalizedDelta.toolCalls;
 					if (toolCallDeltas.length > 0) {
 						flushPartitionedContent();
@@ -345,6 +365,7 @@ const streamOpenAICompletions = (model, context, options) => {
 				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
 				throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
 			}
+			if (output.stopReason !== "toolUse" && confirmedInterruptedTextBlock) tagInterruptedTextPhases(output.content, confirmedInterruptedTextBlock, explicitVisibleTextBlocks);
 			for (const block of blocks) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
 			if (output.stopReason !== "toolUse") clearPendingCommentaryText(provisionalCommentaryTags);
 			if (output.stopReason === "toolUse") tagPendingCommentaryText(output.content);
@@ -355,19 +376,19 @@ const streamOpenAICompletions = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			const terminal = projectProviderError(error, options?.signal);
+			Object.assign(output, terminal);
 			finalizeOpenAICompletionsToolCalls(output, { allowSilentToolCallPromotion: false });
+			clearPendingCommentaryText(provisionalCommentaryTags);
+			tagUnresolvedTextAsCommentary(output);
 			for (const block of output.content) {
 				delete block.index;
 				delete block.partialArgs;
 				delete block.streamIndex;
 			}
-			output.errorMessage = formatProviderError(error);
-			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata && !output.errorMessage.includes(rawMetadata)) output.errorMessage += `\n${rawMetadata}`;
 			stream.push({
 				type: "error",
-				reason: output.stopReason,
+				reason: terminal.stopReason,
 				error: output
 			});
 			stream.end();
@@ -458,9 +479,9 @@ function buildParams(model, context, options, compat = resolveOpenAICompletionsC
 		const converted = convertTools(context.tools, compat);
 		toolProjection = converted.projection;
 		if (converted.tools.length > 0) params.tools = converted.tools;
-		else if (hasToolHistory(context.messages)) params.tools = [];
+		else if (hasToolCallHistory(context.messages)) params.tools = [];
 		if (compat.zaiToolStream && converted.tools.length > 0) params.tool_stream = true;
-	} else if (hasToolHistory(context.messages)) params.tools = [];
+	} else if (hasToolCallHistory(context.messages)) params.tools = [];
 	if (cacheControl) applyAnthropicCacheControl(messages, params.tools, cacheControl, cacheOptOutIndexes);
 	if (options?.toolChoice) {
 		const toolChoice = reconcileOpenAICompletionsToolChoice(options.toolChoice, toolProjection ?? projectOpenAITools([]));
@@ -596,7 +617,7 @@ function convertTools(tools, compat) {
 	const projection = projectOpenAITools(tools);
 	return {
 		projection,
-		tools: projection.tools.map((tool) => ({
+		tools: sortPromptCacheToolsByName(projection.tools).map((tool) => ({
 			type: "function",
 			function: {
 				name: tool.name,

package/dist/openai-completions-compat-B0KTleXp.d.mts

@@ -0,0 +1,43 @@
+import { D as Model, k as OpenAICompletionsCompat } from "./types-DTAP49HF.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DJq_FGcz.mjs";
+
+//#region packages/ai/src/transports/openai-completions-compat.d.ts
+type ProviderRequestCapabilities = AiProviderRequestCapabilities;
+type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
+type OpenAICompletionsCompatDefaults = {
+  supportsStore: boolean;
+  supportsDeveloperRole: boolean;
+  supportsReasoningEffort: boolean;
+  supportsUsageInStreaming: boolean;
+  maxTokensField: "max_completion_tokens" | "max_tokens";
+  thinkingFormat: "openai" | "openrouter" | "deepseek" | "together" | "zai";
+  visibleReasoningDetailTypes: string[];
+  supportsStrictMode: boolean;
+  supportsJsonSchemaResponseFormat: boolean;
+  requiresReasoningContentOnAssistantMessages: boolean;
+  requiresNonEmptyUserOrAssistantMessage: boolean;
+  cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+  sessionAffinityFormat: Exclude<OpenAICompletionsSessionAffinity, "none">;
+  supportsLongCacheRetention: boolean;
+};
+type DetectedOpenAICompletionsCompat = {
+  capabilities: ProviderRequestCapabilities;
+  defaults: OpenAICompletionsCompatDefaults;
+};
+type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "openRouterRouting" | "sendSessionAffinityHeaders"> & {
+  cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
+  openRouterRouting?: OpenAICompletionsCompat["openRouterRouting"];
+  sessionAffinity: OpenAICompletionsSessionAffinity;
+  visibleReasoningDetailTypes: string[];
+  requiresNonEmptyUserOrAssistantMessage: boolean;
+};
+/** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
+declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "provider" | "baseUrl" | "id"> & {
+  compat?: {
+    supportsStore?: boolean;
+  } | null;
+}, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): DetectedOpenAICompletionsCompat;
+/** Applies explicit model overrides once on top of the canonical transport defaults. */
+declare function resolveOpenAICompletionsCompat(model: Model<"openai-completions">, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): ResolvedOpenAICompletionsCompat;
+//#endregion
+export { detectOpenAICompletionsCompat as n, resolveOpenAICompletionsCompat as r, ResolvedOpenAICompletionsCompat as t };

package/dist/{openai-responses-Bdx3V_Yu.mjs → openai-responses-BXEcr-Tp.mjs}

@@ -1,12 +1,12 @@
 import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
+import { S as supportsOpenAITemperature } from "./openai-responses-contracts-DvILoqBk.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { c as buildBaseOptions } from "./tool-result-text-Dvkp2Dus.mjs";
-import { pt as supportsOpenAITemperature } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
+import { n as buildBaseOptions } from "./simple-options-oqsXB6U3.mjs";
+import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, o as runResponsesStreamLifecycle, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-Cvt5MgEm.mjs";
 import { i as resolveCloudflareBaseUrl, n as hasCopilotVisionInput, r as isCloudflareProvider, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-NCJtz9i0.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, o as runResponsesStreamLifecycle, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-CCyMvg7M.mjs";
 import OpenAI from "openai";
 //#region packages/ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
@@ -23,19 +23,6 @@ function getCompat(model) {
 function getPromptCacheRetention(compat, cacheRetention) {
 	return cacheRetention === "long" && compat.supportsLongCacheRetention ? "24h" : void 0;
 }
-function formatOpenAIResponsesError(error) {
-	if (error instanceof Error) {
-		const status = error.status;
-		const statusCode = typeof status === "number" ? status : void 0;
-		if (statusCode !== void 0) return `OpenAI API error (${statusCode}): ${error.message}`;
-		return error.message;
-	}
-	try {
-		return JSON.stringify(error);
-	} catch {
-		return String(error);
-	}
-}
 /**
 * Generate function for OpenAI Responses API
 */
@@ -51,12 +38,11 @@ const streamOpenAIResponses = (model, context, options) => {
 			const cacheSessionId = resolveCacheRetention(options?.cacheRetention) === "none" ? void 0 : options?.sessionId;
 			return createClient(model, context, apiKey, options?.headers, cacheSessionId);
 		},
-		buildParams: () => buildParams(model, context, options),
+		buildParams: (_requestModel, replayMode) => buildParams(model, context, options, replayMode),
 		processStreamOptions: {
 			serviceTier: options?.serviceTier,
 			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
-		},
-		formatError: formatOpenAIResponsesError
+		}
 	});
 	return stream;
 };
@@ -64,10 +50,12 @@ const streamSimpleOpenAIResponses = (model, context, options) => {
 	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	const base = buildBaseOptions(model, options, apiKey);
+	const replayOptions = options;
 	return streamOpenAIResponses(model, context, {
 		...base,
+		authProfileId: replayOptions?.authProfileId,
 		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning),
-		replayResponsesItemIds: options?.replayResponsesItemIds
+		replayResponsesItemIds: replayOptions?.replayResponsesItemIds
 	});
 };
 function createClient(model, context, apiKey, optionsHeaders, sessionId) {
@@ -100,8 +88,13 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId) {
 		fetch: getAiTransportHost().buildModelFetch(model)
 	});
 }
-function buildParams(model, context, options) {
-	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, { replayResponsesItemIds: options?.replayResponsesItemIds ?? false });
+function buildParams(model, context, options, replayMode = "checkpoint") {
+	const messages = convertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+		replayResponsesItemIds: options?.replayResponsesItemIds ?? false,
+		sessionId: options?.sessionId,
+		authProfileId: options?.authProfileId,
+		replayMode
+	});
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const compat = getCompat(model);
 	const params = {

package/dist/openai-responses-contracts-CD75pQ0m.d.mts

@@ -0,0 +1,68 @@
+import { n as Api } from "./types-DTAP49HF.mjs";
+import { h as OpenAIReasoningEffort, i as BaseOpenAIStreamOptions, m as OpenAIApiReasoningEffort } from "./provider-options-Cc5ZQ6Aa.mjs";
+import { FunctionTool, ResponseCompactionItem, ResponseCreateParamsStreaming, ResponseInput } from "openai/resources/responses/responses.js";
+
+//#region packages/ai/src/transports/openai-responses-contracts.d.ts
+declare const OPENAI_RESPONSES_APIS: ReadonlySet<Api>;
+type ReplayableResponseCompactionItem = Omit<ResponseCompactionItem, "id"> & {
+  id?: string;
+};
+type OpenAIResponsesReasoningReplayMetadata = {
+  v: 1;
+  source: "openai-responses";
+  provider: string;
+  api: Api;
+  model: string;
+  baseUrlHash?: string;
+  sessionHash?: string;
+  authProfileHash?: string;
+};
+type OpenAIResponsesOptions = BaseOpenAIStreamOptions & {
+  reasoning?: OpenAIReasoningEffort;
+  reasoningEffort?: OpenAIReasoningEffort;
+  reasoningSummary?: "auto" | "detailed" | "concise" | null;
+  replayResponsesItemIds?: boolean;
+  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+  toolChoice?: ResponseCreateParamsStreaming["tool_choice"];
+};
+type ResponsesPromptObservation = {
+  egress: "responses-sdk" | "responses-websocket" | "native-codex-websocket" | "native-codex-sse";
+  payloadVariant: "initial" | "reasoning-stripped" | "compaction-stripped" | "continuation-rejected";
+  promptSource: "instructions" | "input.developer" | "input.system" | "missing";
+  expectedChars: number;
+  observedChars: number;
+  matchesAssembledPrompt: boolean;
+};
+type ResponsesPromptObserver = (observation: ResponsesPromptObservation) => void;
+declare const responsesPromptObserver: {
+  set(options: object, observer: ResponsesPromptObserver): void;
+  get(options: object): ResponsesPromptObserver | undefined;
+  copy(source: object | undefined, target: object): void;
+};
+type OpenAIResponsesRequestParams = {
+  model: string;
+  input: ResponseInput;
+  stream: true;
+  instructions?: string;
+  prompt_cache_key?: string;
+  prompt_cache_retention?: "24h";
+  metadata?: Record<string, string>;
+  previous_response_id?: string;
+  store?: boolean;
+  max_output_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  text?: ResponseCreateParamsStreaming["text"];
+  service_tier?: ResponseCreateParamsStreaming["service_tier"];
+  tools?: FunctionTool[];
+  tool_choice?: ResponseCreateParamsStreaming["tool_choice"];
+  reasoning?: {
+    effort: OpenAIApiReasoningEffort;
+  } | {
+    effort: OpenAIApiReasoningEffort;
+    summary: NonNullable<OpenAIResponsesOptions["reasoningSummary"]>;
+  };
+  include?: string[];
+};
+//#endregion
+export { ReplayableResponseCompactionItem as a, OpenAIResponsesRequestParams as i, OpenAIResponsesOptions as n, ResponsesPromptObservation as o, OpenAIResponsesReasoningReplayMetadata as r, responsesPromptObserver as s, OPENAI_RESPONSES_APIS as t };