@openclaw/ai 2026.8.1-beta.2 → 2026.8.1

package/dist/{openai-completions-BPnt4Sml.mjs → openai-completions-BaTuwID7.mjs}

@@ -1,18 +1,16 @@
-import { n as getEnvApiKey, r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { i as clampThinkingLevel } from "./sanitize-unicode-BYqrYtC_.mjs";
-import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
-import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
+import { i as clampThinkingLevel } from "./sanitize-unicode-DCkltN94.mjs";
+import { n as getAiTransportHost } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-jZP5NMTZ.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
 import { t as resolveCacheRetention } from "./cache-retention-0x979a5V.mjs";
-import { c as splitSystemPromptCacheBoundary, f as sortPromptCacheToolsByName, n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
-import { a as createOpenAICompletionsToolCallDeltaNormalizer, c as resolveOpenAICompletionsCompat, d as clearPendingCommentaryText, f as rememberPendingCommentaryTags, i as hasToolCallHistory, l as resolveOpenAICompletionsResponseFormat, n as resolveOpenAIReasoningEffortMap, o as finalizeOpenAICompletionsToolCalls, p as tagPendingCommentaryText, r as convertMessages, t as mapOpenAIStopReason, u as shouldOmitOllamaCompatResponseFormat } from "./openai-stop-reason-BkFkqqK0.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
-import { n as notifyLlmRequestActivity } from "./headers-DdOQtGuU.mjs";
-import { f as transportAbortError, p as withProviderResponseHook } from "./provider-transcript-transform-ePx-Bbfr.mjs";
-import { d as readOpenAICompletionsContentDeltas, n as reconcileOpenAICompletionsToolChoice, o as createOpenAIResponseHook, s as isOpenAICompletionsThinkingEnabled, t as projectOpenAITools, u as parseOpenAICompletionsUsage } from "./openai-tool-projection-CY04OcvQ.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-rnPwX2pg.mjs";
+import { m as sortPromptCacheToolsByName, n as buildBaseOptions, o as reasoningTagTextPolicy, u as splitSystemPromptCacheBoundary } from "./simple-options-DKx86yX9.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
+import { _ as transportAbortError, y as withProviderResponseHook } from "./transport-stream-shared-CT5ycdzn.mjs";
+import { E as tagUnresolvedTextAsCommentary, S as shouldOmitOllamaCompatResponseFormat, _ as hasToolCallHistory, b as resolveOpenAICompletionsCompat, g as convertMessages, h as resolveOpenAIReasoningEffortMap, t as processCompletionsStream, v as finalizeOpenAICompletionsToolCalls, w as clearPendingCommentaryText, x as resolveOpenAICompletionsResponseFormat } from "./openai-completions-stream-Bpns6uNc.mjs";
+import { C as createOpenAIProviderAcceptanceHook, T as isOpenAICompletionsThinkingEnabled, j as resolveOpenAIClientBaseUrl, v as projectOpenAITools, y as reconcileOpenAICompletionsToolChoice } from "./openai-tool-schema-Dgl4H2MU.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DcNjoFQE.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
@@ -21,11 +19,6 @@ var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	streamOpenAICompletions: () => streamOpenAICompletions,
 	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
 });
-function isEncryptedReasoningDetail(detail) {
-	if (typeof detail !== "object" || detail === null) return false;
-	const candidate = detail;
-	return candidate.type === "reasoning.encrypted" && typeof candidate.id === "string" && candidate.id.length > 0 && typeof candidate.data === "string" && candidate.data.length > 0;
-}
 const streamOpenAICompletions = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	(async () => {
@@ -57,6 +50,7 @@ const streamOpenAICompletions = (model, context, options) => {
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			const compat = resolveOpenAICompletionsCompat(model);
+			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);
@@ -74,267 +68,76 @@ const streamOpenAICompletions = (model, context, options) => {
 				stream: openaiStream,
 				signal: firstEventAbort.signal,
 				abort: firstEventAbort.abort,
-				hook: createOpenAIResponseHook(options?.onResponse, response, model),
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
 				onReady: () => stream.push({
 					type: "start",
 					partial: output
 				})
 			});
-			let textBlock = null;
-			let thinkingBlock = null;
-			let hasFinishReason = false;
-			const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
-			const toolCallBlocksById = /* @__PURE__ */ new Map();
-			const toolCallBlocksByFirstId = /* @__PURE__ */ new Map();
-			const normalizeToolCallDeltas = createOpenAICompletionsToolCallDeltaNormalizer();
-			const pendingReasoningDetailsByToolCallId = /* @__PURE__ */ new Map();
-			const blocks = output.content;
 			const finishedBlocks = /* @__PURE__ */ new Set();
 			const contentIndices = /* @__PURE__ */ new WeakMap();
-			const appendBlock = (block) => {
-				contentIndices.set(block, blocks.length);
-				blocks.push(block);
-			};
-			const getContentIndex = (block) => contentIndices.get(block) ?? -1;
-			const rememberFirstToolCallById = (id, block) => {
-				if (toolCallBlocksByFirstId.has(id)) return;
-				toolCallBlocksByFirstId.set(id, block);
-				const pendingDetail = pendingReasoningDetailsByToolCallId.get(id);
-				if (pendingDetail) {
-					block.thoughtSignature = pendingDetail;
-					pendingReasoningDetailsByToolCallId.delete(id);
-				}
-			};
+			let openTextBlock;
+			let openThinkingBlock;
 			const finishBlock = (block) => {
-				const contentIndex = getContentIndex(block);
-				if (contentIndex === -1 || finishedBlocks.has(block)) return;
+				const contentIndex = contentIndices.get(block);
+				if (contentIndex === void 0 || finishedBlocks.has(block)) return;
 				finishedBlocks.add(block);
-				if (block.type === "text") stream.push({
-					type: "text_end",
-					contentIndex,
-					content: block.text,
-					partial: output
-				});
-				else if (block.type === "thinking") stream.push({
-					type: "thinking_end",
-					contentIndex,
-					content: block.thinking,
-					partial: output
-				});
-				else if (block.type === "toolCall") stream.push({
-					type: "toolcall_end",
-					contentIndex,
-					toolCall: block,
-					partial: output
-				});
-			};
-			const ensureTextBlock = () => {
-				if (!textBlock) {
-					textBlock = {
-						type: "text",
-						text: ""
-					};
-					appendBlock(textBlock);
+				if (block.type === "text") {
+					openTextBlock = void 0;
 					stream.push({
-						type: "text_start",
-						contentIndex: getContentIndex(textBlock),
+						type: "text_end",
+						contentIndex,
+						content: block.text,
 						partial: output
 					});
-				}
-				return textBlock;
-			};
-			const ensureThinkingBlock = (thinkingSignature) => {
-				if (!thinkingBlock) {
-					thinkingBlock = {
-						type: "thinking",
-						thinking: "",
-						...thinkingSignature ? { thinkingSignature } : {}
-					};
-					appendBlock(thinkingBlock);
+				} else if (block.type === "thinking") {
+					openThinkingBlock = void 0;
 					stream.push({
-						type: "thinking_start",
-						contentIndex: getContentIndex(thinkingBlock),
+						type: "thinking_end",
+						contentIndex,
+						content: block.thinking,
 						partial: output
 					});
-				}
-				return thinkingBlock;
-			};
-			const sealNativeReasoningBeforeText = () => {
-				if (thinkingBlock && !reasoningTagTextPartitioner.isInsideReasoning()) {
-					finishBlock(thinkingBlock);
-					thinkingBlock = null;
-				}
-			};
-			const appendTextDelta = (delta) => {
-				sealNativeReasoningBeforeText();
-				const block = ensureTextBlock();
-				block.text += delta;
-				stream.push({
-					type: "text_delta",
-					contentIndex: getContentIndex(block),
-					delta,
-					partial: output
-				});
-			};
-			const appendThinkingDelta = (thinkingSignature, delta) => {
-				const block = ensureThinkingBlock(thinkingSignature);
-				block.thinking += delta;
-				stream.push({
-					type: "thinking_delta",
-					contentIndex: getContentIndex(block),
-					delta,
+				} else if (block.type === "toolCall") stream.push({
+					type: "toolcall_end",
+					contentIndex,
+					toolCall: block,
 					partial: output
 				});
 			};
-			const ensureToolCallBlock = (toolCall) => {
-				const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
-				let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
-				if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
-				if (!block) {
-					block = {
-						type: "toolCall",
-						id: toolCall.id || "",
-						name: toolCall.function?.name || "",
-						arguments: {},
-						partialArgs: "",
-						streamIndex
-					};
-					if (streamIndex !== void 0) toolCallBlocksByIndex.set(streamIndex, block);
-					if (toolCall.id) {
-						toolCallBlocksById.set(toolCall.id, block);
-						rememberFirstToolCallById(toolCall.id, block);
+			const directEventStream = { push(event) {
+				if (event.type === "text_start" || event.type === "thinking_start" || event.type === "toolcall_start") {
+					const block = output.content[event.contentIndex];
+					if (block) {
+						contentIndices.set(block, event.contentIndex);
+						if (block.type === "text") openTextBlock = block;
+						else if (block.type === "thinking") openThinkingBlock = block;
 					}
-					appendBlock(block);
-					stream.push({
-						type: "toolcall_start",
-						contentIndex: getContentIndex(block),
-						partial: output
-					});
-				}
-				if (streamIndex !== void 0 && block.streamIndex === void 0) {
-					block.streamIndex = streamIndex;
-					toolCallBlocksByIndex.set(streamIndex, block);
 				}
-				if (toolCall.id) toolCallBlocksById.set(toolCall.id, block);
-				return block;
-			};
-			const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
-			const appendPartitionedContent = (text, hasMirroredReasoning) => {
-				const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(text) : reasoningTagTextPartitioner.pushVisible(text);
-				for (const delta of routedDeltas) if (delta.kind === "text") appendTextDelta(delta.text);
-			};
-			const flushPartitionedContent = () => {
-				for (const delta of reasoningTagTextPartitioner.flush()) if (delta.kind === "text") appendTextDelta(delta.text);
-			};
-			const guardedOpenaiStream = withFirstStreamEventTimeout(hookedOpenAIStream, {
-				provider: model.provider,
-				api: model.api,
-				model: model.id,
-				timeoutMs: getFirstStreamEventTimeoutMs(options) ?? 0,
-				stage: "completions",
-				abort: firstEventAbort.abort,
-				onTimeout: getFirstStreamEventTimeoutHandler(options),
-				hint: "The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools."
-			});
-			for await (const chunk of guardedOpenaiStream) {
-				if (!chunk || typeof chunk !== "object") continue;
-				notifyLlmRequestActivity(options?.signal);
-				output.responseId ||= chunk.id;
-				if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
-				if (chunk.usage) output.usage = parseOpenAICompletionsUsage(chunk.usage, model, { includeReasoningTokens: false });
-				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
-				if (!choice) continue;
-				const choiceUsage = choice.usage;
-				if (!chunk.usage && choiceUsage) output.usage = parseOpenAICompletionsUsage(choiceUsage, model, { includeReasoningTokens: false });
-				if (choice.finish_reason) {
-					const finishReasonResult = mapOpenAIStopReason(choice.finish_reason);
-					output.stopReason = finishReasonResult.stopReason;
-					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
-					hasFinishReason = true;
-				}
-				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;
-						}
-					}
-					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();
-						if (shouldEmitReasoning) appendThinkingDelta(contentDelta.signature, contentDelta.text);
-					} else appendPartitionedContent(contentDelta.text, Boolean(foundReasoningField));
-					const toolCallDeltas = normalizedDelta.toolCalls;
-					if (toolCallDeltas.length > 0) {
-						flushPartitionedContent();
-						sealNativeReasoningBeforeText();
-						rememberPendingCommentaryTags(provisionalCommentaryTags, tagPendingCommentaryText(output.content));
-						for (const toolCall of toolCallDeltas) {
-							const block = ensureToolCallBlock(toolCall);
-							if (!block.id && toolCall.id) {
-								block.id = toolCall.id;
-								toolCallBlocksById.set(toolCall.id, block);
-								rememberFirstToolCallById(toolCall.id, block);
-							}
-							if (!block.name && toolCall.function?.name) block.name = toolCall.function.name;
-							let delta = "";
-							if (toolCall.function?.arguments) {
-								delta = toolCall.function.arguments;
-								block.partialArgs = (block.partialArgs ?? "") + toolCall.function.arguments;
-								block.arguments = parseStreamingJson(block.partialArgs);
-							}
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: getContentIndex(block),
-								delta,
-								partial: output
-							});
-						}
-					}
-					const reasoningDetails = choiceDelta.reasoning_details;
-					if (Array.isArray(reasoningDetails)) {
-						for (const detail of reasoningDetails) if (isEncryptedReasoningDetail(detail)) {
-							const serializedDetail = JSON.stringify(detail);
-							const matchingToolCall = toolCallBlocksByFirstId.get(detail.id);
-							if (matchingToolCall) matchingToolCall.thoughtSignature = serializedDetail;
-							else pendingReasoningDetailsByToolCallId.set(detail.id, serializedDetail);
-						}
-					}
-				}
-			}
-			flushPartitionedContent();
-			let terminalError;
-			if (options?.signal?.aborted) terminalError = transportAbortError(options.signal);
-			else if (output.stopReason === "aborted") terminalError = /* @__PURE__ */ new Error("Request was aborted");
-			else if (output.stopReason === "error") terminalError = new Error(output.errorMessage || "Provider returned an error stop reason");
-			else if (!hasFinishReason) terminalError = /* @__PURE__ */ new Error("Stream ended without finish_reason");
-			if (terminalError) {
-				for (const block of blocks) if (block.type !== "toolCall") finishBlock(block);
-				throw terminalError;
-			}
-			finalizeOpenAICompletionsToolCalls(output);
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				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"));
+				stream.push(event);
+			} };
+			try {
+				await processCompletionsStream(hookedOpenAIStream, output, model, directEventStream, {
+					mode: "direct",
+					beforeContentBlock(nextType) {
+						if (openThinkingBlock) finishBlock(openThinkingBlock);
+						if (openTextBlock && nextType !== "toolCall") finishBlock(openTextBlock);
+					},
+					provisionalCommentaryTags,
+					signal: options?.signal,
+					emitReasoning: shouldEmitReasoning,
+					strictReasoningTags: reasoningTagTextPolicy.isStrict(options),
+					firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+					abortFirstEventStream: firstEventAbort.abort,
+					onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options)
+				});
+				if (options?.signal?.aborted) throw transportAbortError(options.signal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage || (output.stopReason === "aborted" ? "Request was aborted" : "Provider returned an invalid tool call"));
+			} catch (error) {
+				for (const block of output.content) if (block.type !== "toolCall") finishBlock(block);
+				throw error;
 			}
-			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);
+			for (const block of output.content) if (block.type !== "toolCall" || output.stopReason === "toolUse") finishBlock(block);
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -345,6 +148,8 @@ const streamOpenAICompletions = (model, context, options) => {
 			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;
@@ -400,7 +205,7 @@ function createClient(model, context, apiKey, optionsHeaders, sessionId, compat
 	} : headers;
 	return new OpenAI({
 		apiKey,
-		baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl,
+		baseURL: resolveOpenAIClientBaseUrl(model, isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model) : model.baseUrl),
 		dangerouslyAllowBrowser: true,
 		defaultHeaders,
 		fetch: getAiTransportHost().buildModelFetch(model)

package/dist/{openai-completions-compat-Dt3dcawL.d.mts → openai-completions-compat-DB7FFq7k.d.mts}

@@ -1,6 +1,6 @@
-import { E as Model, O as OpenAICompletionsCompat } from "./types-BHNrPS1l.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-vWgMMhiJ.mjs";
-
+import "./index-N3zr6__t.mjs";
+import { D as Model, k as OpenAICompletionsCompat } from "./types-h38Azne1.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DoPJJ1KD.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
 type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";