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

package/dist/{mistral-Dx6VzNjf.mjs → mistral-D6hRXI7A.mjs}

@@ -1,19 +1,17 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
-import { b as isRecord, i as transformMessages, n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
-import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-Dau5dlgm.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { a as isImageWithMediaPayload, c as buildBaseOptions, h as stripSystemPromptCacheBoundary, l as clampMaxTokensToModel, o as truncateUtf16Safe, r as extractToolResultText, t as describeToolResultMediaPlaceholder } from "./tool-result-text-Dvkp2Dus.mjs";
-import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-CPNv7A3r.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { i as clampThinkingLevel, r as calculateCost, t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
+import { a as describeToolResultMediaPlaceholder, c as extractToolResultText, d as isImageWithMediaPayload, l as formatToolResultText, n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
+import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
+import { P as sortPromptCacheToolsByName, d as finalizeTerminalToolCallArguments, g as notifyProviderHttpResponse, j as stripSystemPromptCacheBoundary, n as buildBaseOptions, r as clampMaxTokensToModel, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
+import { n as parseStreamingJson } from "./json-parse-CDnesDM_.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
-import "./transform-messages-DfjpNXNQ.mjs";
+import { t as transformProviderMessages } from "./provider-transcript-transform--gtf0ZbR.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
 import { randomUUID } from "node:crypto";
 import { HTTPClient, Mistral } from "@mistralai/mistralai";
 //#region packages/ai/src/providers/mistral.ts
 const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
-const MAX_MISTRAL_ERROR_BODY_CHARS = 4e3;
 const MISTRAL_STREAM_BODY_MAX_BYTES = 16 * 1024 * 1024;
 /**
 * Builds a `Fetcher` that wraps the default `fetch` with a 16 MiB byte cap
@@ -64,13 +62,28 @@ 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, transformMessages(context.messages, model, (id) => normalizeMistralToolCallId(id)), options);
+			let payload = buildChatPayload(model, context, transformProviderMessages(context.messages, model, (id) => normalizeMistralToolCallId(id)), options);
 			const nextPayload = await options?.onPayload?.(payload, model);
 			if (nextPayload !== void 0) payload = nextPayload;
 			const headers = {
@@ -82,6 +95,12 @@ 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
@@ -97,11 +116,11 @@ const streamMistral = (model, context, options) => {
 			stream.end();
 		} catch (error) {
 			output.content = output.content.filter((block) => block.type !== "toolCall");
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = formatMistralError(error);
+			const terminal = projectProviderError(error, options?.signal);
+			Object.assign(output, terminal);
 			stream.push({
 				type: "error",
-				reason: output.stopReason,
+				reason: terminal.stopReason,
 				error: output
 			});
 			stream.end();
@@ -178,30 +197,6 @@ function deriveMistralToolCallId(id, attempt) {
 	const seedBase = normalized || id;
 	return shortHash(attempt === 0 ? seedBase : `${seedBase}:${attempt}`).replace(/[^a-zA-Z0-9]/g, "").padEnd(MISTRAL_TOOL_CALL_ID_LENGTH, "0").slice(0, MISTRAL_TOOL_CALL_ID_LENGTH);
 }
-function formatMistralError(error) {
-	if (error instanceof Error) {
-		const sdkError = error;
-		const statusCode = typeof sdkError.statusCode === "number" ? sdkError.statusCode : void 0;
-		const bodyText = typeof sdkError.body === "string" ? sdkError.body.trim() : void 0;
-		if (statusCode !== void 0 && bodyText) return `Mistral API error (${statusCode}): ${truncateErrorText(bodyText, MAX_MISTRAL_ERROR_BODY_CHARS)}`;
-		if (statusCode !== void 0) return `Mistral API error (${statusCode}): ${error.message}`;
-		return error.message;
-	}
-	return safeJsonStringify(error);
-}
-function truncateErrorText(text, maxChars) {
-	if (text.length <= maxChars) return text;
-	const truncated = truncateUtf16Safe(text, maxChars);
-	return `${truncated}... [truncated ${text.length - truncated.length} chars]`;
-}
-function safeJsonStringify(value) {
-	try {
-		const serialized = JSON.stringify(value);
-		return serialized === void 0 ? String(value) : serialized;
-	} catch {
-		return String(value);
-	}
-}
 function buildChatPayload(model, context, messages, options) {
 	const payload = {
 		model: model.id,
@@ -492,43 +487,46 @@ 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
 		});
 	}
 }
 function toFunctionTools(tools) {
-	return tools.flatMap((tool) => {
+	return sortPromptCacheToolsByName(tools.flatMap((tool) => {
 		try {
+			const name = tool.name;
+			const description = tool.description;
 			return {
-				type: "function",
-				function: {
-					name: tool.name,
-					description: tool.description,
-					parameters: stripSymbolKeys(tool.parameters),
-					strict: false
+				name,
+				description,
+				value: {
+					type: "function",
+					function: {
+						name,
+						description,
+						parameters: stripSymbolKeys(tool.parameters),
+						strict: false
+					}
 				}
 			};
 		} catch {
 			return [];
 		}
-	});
+	})).map(({ value }) => value);
 }
 function stripSymbolKeys(value) {
 	if (Array.isArray(value)) return value.map((item) => stripSymbolKeys(item));
@@ -611,7 +609,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
@@ -633,16 +638,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";
 }

package/dist/{number-coercion-1Miyb5MO.mjs → number-coercion-H9qHik3g.mjs}

@@ -1,7 +1,12 @@
 //#region packages/normalization-core/src/number-coercion.ts
 /** Returns a number only when the input is already finite. */
 function asFiniteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+	return Number.isFinite(value) ? value : void 0;
+}
+/** Returns a finite number only when it is zero or greater. */
+function asNonNegativeFiniteNumber(value) {
+	const number = asFiniteNumber(value);
+	return number && number < 0 ? void 0 : number;
 }
 /** Returns a finite number only when it satisfies the supplied inclusive/exclusive bounds. */
 function asFiniteNumberInRange(value, range) {
@@ -63,4 +68,4 @@ function parseStrictNonNegativeInteger(value) {
 	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
 }
 //#endregion
-export { parseStrictPositiveInteger as a, parseStrictNonNegativeInteger as i, clampTimerTimeoutMs as n, resolveTimerTimeoutMs as o, parseStrictFiniteNumber as r, asFiniteNumberInRange as t };
+export { parseStrictFiniteNumber as a, resolveTimerTimeoutMs as c, clampTimerTimeoutMs as i, asFiniteNumberInRange as n, parseStrictNonNegativeInteger as o, asNonNegativeFiniteNumber as r, parseStrictPositiveInteger as s, asFiniteNumber as t };

package/dist/openai-chatgpt-jwt-KWcgd0d_.mjs

@@ -0,0 +1,19 @@
+//#region packages/ai/src/utils/oauth/openai-chatgpt-jwt.ts
+const OPENAI_CODEX_AUTH_CLAIM = "https://api.openai.com/auth";
+function decodeOpenAICodexJwtPayload(token) {
+	const parts = token.split(".");
+	if (parts.length !== 3) return null;
+	try {
+		const decoded = Buffer.from(parts[1] ?? "", "base64url").toString("utf8");
+		const parsed = JSON.parse(decoded);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function resolveOpenAICodexAccountId(token) {
+	const accountId = decodeOpenAICodexJwtPayload(token)?.[OPENAI_CODEX_AUTH_CLAIM]?.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.length > 0 ? accountId : null;
+}
+//#endregion
+export { resolveOpenAICodexAccountId as n, decodeOpenAICodexJwtPayload as t };