@openclaw/ai 2026.8.1-beta.2 → 2026.9.1-beta.1

package/dist/{mistral-CEWoQI_g.mjs → mistral-EiHdymeb.mjs}

@@ -1,14 +1,15 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-BYqrYtC_.mjs";
-import { a as describeToolResultMediaPlaceholder, l as isImageWithMediaPayload, n as getAiTransportHost, s as extractToolResultText } from "./host-DTqNc7ad.mjs";
-import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
-import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
-import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel } from "./simple-options-D58D5Kvw.mjs";
-import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
+import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-DCkltN94.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, l as formatToolResultText, n as getAiTransportHost } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { f as sortPromptCacheToolsByName, l as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel } from "./simple-options-CFj7x3J4.mjs";
+import { _ as transportAbortError, f as notifyProviderHttpResponse, s as finalizeTerminalToolCallArguments } from "./transport-stream-shared-ljShVIZB.mjs";
+import { r as parseStreamingJson, t as createToolArgumentPreviewSchedule } from "./json-parse-BuAJEbdW.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import { f as transportAbortError, t as transformProviderMessages } from "./provider-transcript-transform-ePx-Bbfr.mjs";
-import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform-C01bQ5a3.mjs";
+import { t as mapOpenAIStopReason } from "./openai-stop-reason-Drnn_6Qj.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 import { randomUUID } from "node:crypto";
 import { HTTPClient, Mistral } from "@mistralai/mistralai";
 //#region packages/ai/src/providers/mistral.ts
@@ -63,10 +64,25 @@ const streamMistral = (model, context, options) => {
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 			if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+			const boundedFetcher = createBoundedMistralFetcher(MISTRAL_STREAM_BODY_MAX_BYTES, getAiTransportHost().buildModelFetch(model) ?? fetch);
+			let mistralResponse;
+			let reportedResponse;
+			const httpClient = new HTTPClient({ fetcher: boundedFetcher });
+			httpClient.addHook("response", async (response) => {
+				mistralResponse = response;
+				if (!response.ok) {
+					await notifyProviderHttpResponse({
+						options,
+						response,
+						model
+					});
+					reportedResponse = response;
+				}
+			});
 			const mistral = new Mistral({
 				apiKey,
 				serverURL: model.baseUrl,
-				httpClient: new HTTPClient({ fetcher: createBoundedMistralFetcher(MISTRAL_STREAM_BODY_MAX_BYTES, getAiTransportHost().buildModelFetch(model) ?? fetch) })
+				httpClient
 			});
 			const normalizeMistralToolCallId = createMistralToolCallIdNormalizer();
 			let payload = buildChatPayload(model, context, transformProviderMessages(context.messages, model, (id) => normalizeMistralToolCallId(id)), options);
@@ -81,13 +97,19 @@ const streamMistral = (model, context, options) => {
 				headers,
 				signal: options?.signal
 			});
+			if (mistralResponse && mistralResponse !== reportedResponse) await notifyProviderHttpResponse({
+				options,
+				response: mistralResponse,
+				model,
+				cancelStream: (reason) => mistralStream.cancel(reason)
+			});
 			stream.push({
 				type: "start",
 				partial: output
 			});
 			await consumeChatStream(model, output, stream, mistralStream);
 			if (options?.signal?.aborted) throw transportAbortError(options.signal);
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -221,6 +243,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 	const blocks = output.content;
 	const blockIndex = () => blocks.length - 1;
 	const toolBlockIdentities = /* @__PURE__ */ new Map();
+	const toolArgumentPreviewSchedules = /* @__PURE__ */ new WeakMap();
 	const normalizeMissingToolCallId = createMistralToolCallIdNormalizer();
 	const missingToolCallIdScope = randomUUID();
 	const createMissingToolCallId = (contentIndex) => normalizeMissingToolCallId(`${missingToolCallIdScope}:toolcall:${contentIndex}`);
@@ -300,6 +323,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 	for await (const event of mistralStream) {
 		const chunk = event.data;
 		output.responseId ||= chunk.id;
+		if (typeof chunk.model === "string" && chunk.model.length > 0 && chunk.model !== model.id) output.responseModel ||= chunk.model;
 		if (chunk.usage) {
 			const promptTokens = chunk.usage.promptTokens || 0;
 			const cachedPromptTokens = readMistralCachedPromptTokens(chunk.usage, promptTokens);
@@ -314,7 +338,9 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 		if (!choice) continue;
 		if (choice.finishReason) {
 			terminalFinishReason = choice.finishReason;
-			output.stopReason = mapChatStopReason(choice.finishReason);
+			const { stopReason, errorMessage } = mapOpenAIStopReason(choice.finishReason === "model_length" ? "length" : choice.finishReason);
+			output.stopReason = stopReason;
+			if (errorMessage) output.errorMessage = errorMessage;
 		}
 		const delta = choice.delta;
 		if (delta.content !== null && delta.content !== void 0) {
@@ -425,6 +451,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 					partialArgs: ""
 				};
 				output.content.push(block);
+				toolArgumentPreviewSchedules.set(block, createToolArgumentPreviewSchedule());
 				toolBlockIdentities.set(contentIndex, {
 					explicitIds: new Set(providedCallId ? [providedCallId] : []),
 					functionNames: new Set(functionName ? [functionName] : []),
@@ -452,7 +479,7 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 			if (toolCallIndex !== void 0) identity.indexes.add(toolCallIndex);
 			const argsDelta = typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments || {});
 			block.partialArgs = (block.partialArgs || "") + argsDelta;
-			block.arguments = parseStreamingJson(block.partialArgs);
+			if (toolArgumentPreviewSchedules.get(block)?.(block.partialArgs.length)) block.arguments = parseStreamingJson(block.partialArgs);
 			stream.push({
 				type: "toolcall_delta",
 				contentIndex,
@@ -467,23 +494,20 @@ async function consumeChatStream(model, output, stream, mistralStream) {
 		if (!terminalFinishReason) throw new Error("Mistral stream ended without a terminal finish reason");
 		return;
 	}
-	try {
-		for (const index of toolBlockIdentities.keys()) {
-			const rawArguments = blocks[index].partialArgs ?? "";
-			if (!isRecord(JSON.parse(rawArguments))) throw new Error("Mistral tool-call arguments must be a JSON object");
-		}
-	} catch {
-		throw new Error("Mistral completed tool call has invalid JSON arguments");
-	}
-	for (const index of toolBlockIdentities.keys()) {
-		const block = output.content.at(index);
-		if (block?.type !== "toolCall") continue;
-		const toolBlock = block;
-		delete toolBlock.partialArgs;
+	const completedToolCalls = [...toolBlockIdentities.keys()].flatMap((contentIndex) => {
+		const block = blocks[contentIndex];
+		return block?.type === "toolCall" ? [{
+			block,
+			contentIndex
+		}] : [];
+	});
+	finalizeTerminalToolCallArguments(completedToolCalls.map(({ block }) => block), (block) => block.partialArgs ?? "", "Mistral completed tool call has invalid JSON arguments");
+	for (const { block, contentIndex } of completedToolCalls) {
+		delete block.partialArgs;
 		stream.push({
 			type: "toolcall_end",
-			contentIndex: index,
-			toolCall: toolBlock,
+			contentIndex,
+			toolCall: block,
 			partial: output
 		});
 	}
@@ -592,7 +616,14 @@ function toChatMessages(messages, supportsImages) {
 			continue;
 		}
 		const toolContent = [];
-		const toolText = buildToolResultText(extractToolResultText(msg.content), describeToolResultMediaPlaceholder(msg.content), msg.content.some(isImageWithMediaPayload), supportsImages, msg.isError);
+		const textResult = extractToolResultText(msg.content);
+		const mediaPlaceholder = describeToolResultMediaPlaceholder(msg.content);
+		const toolText = formatToolResultText({
+			text: textResult,
+			mediaPlaceholder,
+			omittedMediaPlaceholder: msg.content.some(isImageWithMediaPayload) && !supportsImages ? textResult.trim() ? "[tool image omitted: model does not support images]" : mediaPlaceholder === "(see attached media)" ? "(media omitted: model does not support images)" : "(image omitted: model does not support images)" : void 0,
+			isError: msg.isError
+		});
 		toolContent.push({
 			type: "text",
 			text: toolText
@@ -614,16 +645,6 @@ function toChatMessages(messages, supportsImages) {
 	}
 	return result;
 }
-function buildToolResultText(text, mediaPlaceholder, hasImages, supportsImages, isError) {
-	const trimmed = text.trim();
-	const errorPrefix = isError ? "[tool error] " : "";
-	if (trimmed.length > 0) return `${errorPrefix}${trimmed}${hasImages && !supportsImages ? "\n[tool image omitted: model does not support images]" : ""}`;
-	if (mediaPlaceholder) {
-		if (!hasImages || supportsImages) return `${errorPrefix}${mediaPlaceholder}`;
-		return `${errorPrefix}${mediaPlaceholder === "(see attached media)" ? "(media omitted: model does not support images)" : "(image omitted: model does not support images)"}`;
-	}
-	return isError ? "[tool error] (no tool output)" : "(no tool output)";
-}
 function usesReasoningEffort(model) {
 	return model.id === "mistral-small-2603" || model.id === "mistral-small-latest" || model.id === "mistral-medium-3-5";
 }
@@ -647,16 +668,5 @@ function mapToolChoice(choice, convertedToolNames) {
 		function: { name: toolName }
 	};
 }
-function mapChatStopReason(reason) {
-	if (reason === null) return "stop";
-	switch (reason) {
-		case "stop": return "stop";
-		case "length":
-		case "model_length": return "length";
-		case "tool_calls": return "toolUse";
-		case "error": return "error";
-		default: return "stop";
-	}
-}
 //#endregion
 export { createBoundedMistralFetcher, streamMistral, streamSimpleMistral };

package/dist/{openai-chatgpt-responses-CrPmqERt.mjs → openai-chatgpt-responses-DHpF9o1e.mjs}

@@ -1,24 +1,23 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-DTqNc7ad.mjs";
-import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DgNTYnRY.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-D51fmkH6.mjs";
+import { n as projectProviderError } from "./provider-error-DDOs_Bz0.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-Cd4hJG-S.mjs";
 import { c as resolveTimerTimeoutMs, i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
-import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-CyfIkQi5.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { l as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
-import { t as headersToRecord } from "./headers-DdOQtGuU.mjs";
-import { F as commitResponsesEncryptedContentAttempt, G as suppressOpenAIResponsesCompaction, L as isInvalidEncryptedContentError, U as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DXIt3iY5.mjs";
-import { f as transportAbortError, p as withProviderResponseHook } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+import { l as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-CFj7x3J4.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-DJqkxbhC.mjs";
-import { o as createOpenAIResponseHook } from "./openai-tool-projection-CY04OcvQ.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-LJ1_rbi-.mjs";
+import { C as headersToRecord, _ as transportAbortError, p as notifyProviderStreamOpened, y as withProviderResponseHook } from "./transport-stream-shared-ljShVIZB.mjs";
+import { F as commitResponsesEncryptedContentAttempt, G as suppressOpenAIResponsesCompaction, L as isInvalidEncryptedContentError, U as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DJThc6jW.mjs";
+import { C as createOpenAIProviderAcceptanceHook, w as createOpenAIResponseHook } from "./openai-tool-schema-ho-hIkQf.mjs";
 import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-QUY12X0B.mjs";
 import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
 import "./diagnostics.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
-import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
 import { t as inspectTlsCertificateError } from "./tls-certificate-errors-DXSpluKI.mjs";
 //#region packages/ai/src/internal/retry-sleep.ts
 function sleepWithAbort(ms, signal) {
@@ -155,6 +154,12 @@ function isRequestTimeoutError(error, callerSignal, requestSignal, timeoutMs) {
 	if (!(error instanceof Error)) return false;
 	return error.name === "AbortError" || error.name === "TimeoutError" || error.message === "Request was aborted";
 }
+/** Local-only failure category for transport diagnostics; never provider text. */
+function classifyStreamFailure(error, signal, requestTimedOut) {
+	if (requestTimedOut) return "timeout";
+	if (signal?.aborted) return "caller-abort";
+	return error instanceof ResponsesStreamFailure || error instanceof CodexApiError ? "provider-failure" : "transport";
+}
 function formatRequestTimeoutError(timeoutMs, cause) {
 	return new Error(`Request timed out after ${timeoutMs}ms`, { cause: cause instanceof Error ? cause : void 0 });
 }
@@ -172,6 +177,7 @@ function compressRequestBodyZstd(bodyJson) {
 const streamOpenAICodexResponses = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	(async () => {
+		const startedAt = Date.now();
 		let requestTimeoutMs;
 		let requestTimeoutSignal;
 		let activeSignal;
@@ -218,8 +224,9 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					websocketRequestSent = false;
 					try {
 						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), activeAttempt.request, websocketHeaders, output, stream, model, () => {
-							commitSemanticAttempt(activeAttempt);
 							websocketStarted = true;
+						}, () => {
+							commitSemanticAttempt(activeAttempt);
 						}, requestOptions, firstEventAbort.abort, observePromptEgress, activeAttempt.kind, () => {
 							websocketRequestSent = true;
 						});
@@ -337,7 +344,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				stream: mapCodexEvents(parseOpenAIChatGptResponsesSse(response)),
 				signal: firstEventAbort.signal,
 				abort: firstEventAbort.abort,
-				hook: createOpenAIResponseHook(options?.onResponse, response, model),
+				hook: createOpenAIProviderAcceptanceHook(options, response, model),
 				onReady: () => stream.push({
 					type: "start",
 					partial: output
@@ -364,9 +371,19 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			});
 			stream.end();
 		} catch (error) {
-			const normalizedError = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
+			const requestTimedOut = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0;
+			const normalizedError = requestTimedOut && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
 			for (const block of output.content) delete block.partialJson;
 			const terminal = projectProviderError(normalizedError, options?.signal);
+			getAiTransportHost().logWarn("openai-transport", "ChatGPT Responses stream terminated", {
+				provider: model.provider,
+				api: model.api,
+				model: model.id,
+				transport: options?.transport || "auto",
+				elapsedMs: Math.max(0, Date.now() - startedAt),
+				stopReason: terminal.stopReason,
+				failureKind: classifyStreamFailure(error, options?.signal, requestTimedOut)
+			});
 			Object.assign(output, terminal);
 			stream.push({
 				type: "error",
@@ -872,12 +889,14 @@ function buildCachedWebSocketRequestBody(entry, body) {
 		input: delta
 	};
 }
-async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart) {
+async function* startWebSocketOutputOnFirstEvent(events, output, stream, onFirstProviderEvent, reportStreamOpened, onStart) {
 	let started = false;
 	for await (const event of events) {
 		if (!started) {
 			started = true;
+			onFirstProviderEvent();
 			onStart();
+			await reportStreamOpened();
 			stream.push({
 				type: "start",
 				partial: output
@@ -886,7 +905,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent) {
+async function processWebSocketStream(url, body, headers, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent) {
 	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
@@ -903,7 +922,13 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 			...requestBody
 		}));
 		onRequestSent?.();
-		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onStart), output, stream, model, {
+		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onFirstProviderEvent, () => notifyProviderStreamOpened({
+			options,
+			cancelStream: () => {
+				keepConnection = false;
+				closeWebSocketSilently(socket);
+			}
+		}), onStart), output, stream, model, {
 			serviceTier: options?.serviceTier,
 			firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 			abortFirstEventStream,