@openclaw/ai 2026.10.5-beta.4 → 2026.10.10-beta.1

package/dist/anthropic-tool-projection-BdAS3rtJ.mjs

@@ -0,0 +1,165 @@
+import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
+import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-D_MeCQFI.mjs";
+import { _ as SCHEMA_MAP_KEYS, d as inheritToolSchemaTruncation, g as SCHEMA_ARRAY_KEYS, i as publishRuntimeToolInputSchema, r as projectRuntimeToolInputSchema, t as getPublishedRuntimeToolInputSchema, y as SCHEMA_OBJECT_KEYS } from "./tool-schema-json-projection-B0hHDV7N.mjs";
+//#region packages/ai/src/providers/anthropic-tool-projection.ts
+const CLAUDE_CODE_TOOL_LOOKUP = new Map([
+	"Read",
+	"Write",
+	"Edit",
+	"Bash",
+	"Grep",
+	"Glob",
+	"AskUserQuestion",
+	"EnterPlanMode",
+	"ExitPlanMode",
+	"KillShell",
+	"NotebookEdit",
+	"Skill",
+	"Task",
+	"TaskOutput",
+	"TodoWrite",
+	"WebFetch",
+	"WebSearch"
+].map((name) => [name.toLowerCase(), name]));
+/** Preserve Claude Code's canonical tool casing for subscription OAuth requests. */
+function toClaudeCodeToolName(name) {
+	return CLAUDE_CODE_TOOL_LOOKUP.get(name.toLowerCase()) ?? name;
+}
+/** Anthropic rejects forced tools while extended thinking is enabled. */
+function normalizeAnthropicToolChoice(thinkingEnabled, toolChoice) {
+	if (thinkingEnabled && (toolChoice === "any" || typeof toolChoice === "object" && toolChoice.type === "tool")) return { type: "auto" };
+	return typeof toolChoice === "string" ? { type: toolChoice } : toolChoice;
+}
+/** Anthropic tool identifiers accept only ASCII word characters and dashes. */
+function normalizeAnthropicToolCallId(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function isProviderSupportedViolation(violation) {
+	return violation.endsWith(".$dynamicRef") || violation.endsWith(".$dynamicAnchor");
+}
+/** Normalize the detached JSON projection and report tuple changes to enclosing schemas. */
+function normalizeAnthropicJsonSchema(schema) {
+	if (!isRecord(schema)) return false;
+	let changed = false;
+	for (const [key, value] of Object.entries(schema)) {
+		if (key !== "additionalItems" && SCHEMA_OBJECT_KEYS.has(key) && !Array.isArray(value)) {
+			changed = normalizeAnthropicJsonSchema(value) || changed;
+			continue;
+		}
+		if (key !== "items" && SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+			for (const entry of value) changed = normalizeAnthropicJsonSchema(entry) || changed;
+			continue;
+		}
+		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) for (const entry of Object.values(value)) changed = normalizeAnthropicJsonSchema(entry) || changed;
+	}
+	if (Array.isArray(schema.items)) {
+		for (const entry of schema.items) normalizeAnthropicJsonSchema(entry);
+		schema.prefixItems = schema.items;
+		const additionalItems = schema.additionalItems;
+		if (typeof additionalItems === "boolean" || isRecord(additionalItems)) {
+			normalizeAnthropicJsonSchema(additionalItems);
+			schema.items = additionalItems;
+		} else delete schema.items;
+		delete schema.additionalItems;
+		changed = true;
+	}
+	if (changed) delete schema.$schema;
+	return changed;
+}
+const publishedAnthropicSchemas = /* @__PURE__ */ new WeakMap();
+/** Prepare a detached JSON projection for Anthropic's tuple dialect. */
+function prepareAnthropicInputSchema(schema) {
+	const published = getPublishedRuntimeToolInputSchema(schema);
+	const cached = published ? publishedAnthropicSchemas.get(schema) : void 0;
+	if (cached !== void 0) return cached;
+	const normalized = published ? JSON.parse(published.json) : schema;
+	normalizeAnthropicJsonSchema(normalized);
+	const properties = normalized.properties;
+	const required = normalized.required;
+	if (properties !== void 0 && properties !== null && !isRecord(properties) || required !== void 0 && required !== null && (!Array.isArray(required) || required.some((entry) => typeof entry !== "string"))) {
+		if (published) publishedAnthropicSchemas.set(schema, null);
+		return null;
+	}
+	const inputSchema = {
+		...normalized,
+		type: "object",
+		properties: properties ?? {},
+		required: required ?? []
+	};
+	inheritToolSchemaTruncation(schema, inputSchema);
+	if (!published) return inputSchema;
+	const result = publishRuntimeToolInputSchema(inputSchema).schema;
+	publishedAnthropicSchemas.set(schema, result);
+	return result;
+}
+/** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
+function projectAnthropicTools(tools, toWireName) {
+	const projectedTools = [];
+	const originalNameByWireName = /* @__PURE__ */ new Map();
+	const unavailableOriginalNames = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		let projectedTool;
+		let originalName;
+		try {
+			const name = tool.name;
+			originalName = name;
+			if (!name) continue;
+			const schemaProjection = projectRuntimeToolInputSchema(tool.parameters, `${name}.parameters`, name);
+			if (!isRecord(schemaProjection.schema) || schemaProjection.violations.some((violation) => !isProviderSupportedViolation(violation))) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			const inputSchema = prepareAnthropicInputSchema(schemaProjection.schema);
+			if (!inputSchema) {
+				unavailableOriginalNames.add(name);
+				continue;
+			}
+			let description;
+			try {
+				description = typeof tool.description === "string" ? tool.description : void 0;
+			} catch {}
+			projectedTool = {
+				originalName: name,
+				wireName: toWireName(name),
+				...description ? { description } : {},
+				inputSchema
+			};
+		} catch {
+			if (originalName) unavailableOriginalNames.add(originalName);
+			continue;
+		}
+		const conflictingName = originalNameByWireName.get(projectedTool.wireName);
+		if (conflictingName !== void 0 && conflictingName !== projectedTool.originalName) throw new Error(`Anthropic tool names "${conflictingName}" and "${projectedTool.originalName}" both map to "${projectedTool.wireName}"`);
+		originalNameByWireName.set(projectedTool.wireName, projectedTool.originalName);
+		projectedTools.push(projectedTool);
+	}
+	return {
+		inputToolCount: tools.length,
+		unavailableOriginalNames,
+		tools: sortPromptCacheToolsByName(projectedTools)
+	};
+}
+/** Keeps forced Anthropic tool choices aligned with the projected wire names. */
+function reconcileAnthropicToolChoice(choice, projection) {
+	if (projection.inputToolCount === 0) return choice;
+	if (choice.type === "tool") {
+		const requestedName = choice.name;
+		const matchedTool = projection.tools.find((tool) => tool.originalName === requestedName) ?? (projection.unavailableOriginalNames.has(requestedName) ? void 0 : projection.tools.find((tool) => tool.wireName === requestedName));
+		if (!matchedTool) throw new Error(`Anthropic tool_choice requested unavailable tool "${requestedName}" after schema conversion`);
+		return {
+			...choice,
+			name: matchedTool.wireName
+		};
+	}
+	if (projection.tools.length === 0) {
+		if (choice.type === "auto") return;
+		if (choice.type === "any") throw new Error("Anthropic tool_choice requires a tool, but no tools survived schema conversion");
+	}
+	return choice;
+}
+/** Maps Claude Code wire names without trusting every direct/custom descriptor. */
+function resolveOriginalAnthropicToolName(name, projection) {
+	return projection?.tools.find((tool) => tool.wireName === name)?.originalName ?? name;
+}
+//#endregion
+export { reconcileAnthropicToolChoice as a, projectAnthropicTools as i, normalizeAnthropicToolChoice as n, resolveOriginalAnthropicToolName as o, prepareAnthropicInputSchema as r, toClaudeCodeToolName as s, normalizeAnthropicToolCallId as t };

package/dist/anthropic-tool-projection-DKH-aEWU.d.mts

@@ -0,0 +1,51 @@
+import { r as AnthropicOptions } from "./provider-options-DeYeaflL.mjs";
+import { Tool } from "@anthropic-ai/sdk/resources/messages.js";
+//#region packages/ai/src/providers/anthropic-tool-projection.d.ts
+type AnthropicToolDescriptor = {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: unknown;
+};
+type AnthropicProjectedTool = {
+  readonly originalName: string;
+  readonly wireName: string;
+  readonly description?: string;
+  readonly inputSchema: Tool["input_schema"] & {
+    readonly properties: Record<string, unknown>;
+    readonly required: string[];
+  };
+};
+type AnthropicToolProjection = {
+  readonly inputToolCount: number;
+  readonly unavailableOriginalNames: ReadonlySet<string>;
+  readonly tools: readonly AnthropicProjectedTool[];
+};
+type AnthropicParallelToolChoice = {
+  readonly disable_parallel_tool_use?: boolean;
+};
+type AnthropicProjectedToolChoice = ({
+  readonly type: "auto";
+} & AnthropicParallelToolChoice) | ({
+  readonly type: "any";
+} & AnthropicParallelToolChoice) | {
+  readonly type: "none";
+} | ({
+  readonly type: "tool";
+  readonly name: string;
+} & AnthropicParallelToolChoice);
+/** Preserve Claude Code's canonical tool casing for subscription OAuth requests. */
+declare function toClaudeCodeToolName(name: string): string;
+/** Anthropic rejects forced tools while extended thinking is enabled. */
+declare function normalizeAnthropicToolChoice(thinkingEnabled: boolean, toolChoice: NonNullable<AnthropicOptions["toolChoice"]>): AnthropicProjectedToolChoice;
+/** Anthropic tool identifiers accept only ASCII word characters and dashes. */
+declare function normalizeAnthropicToolCallId(id: string): string;
+/** Prepare a detached JSON projection for Anthropic's tuple dialect. */
+declare function prepareAnthropicInputSchema(schema: Record<string, unknown>): AnthropicProjectedTool["inputSchema"] | null;
+/** Snapshots direct/custom tool descriptors before Anthropic payload construction. */
+declare function projectAnthropicTools(tools: readonly AnthropicToolDescriptor[], toWireName: (name: string) => string): AnthropicToolProjection;
+/** Keeps forced Anthropic tool choices aligned with the projected wire names. */
+declare function reconcileAnthropicToolChoice(choice: AnthropicProjectedToolChoice, projection: AnthropicToolProjection): AnthropicProjectedToolChoice | undefined;
+/** Maps Claude Code wire names without trusting every direct/custom descriptor. */
+declare function resolveOriginalAnthropicToolName(name: string, projection: AnthropicToolProjection | undefined): string;
+//#endregion
+export { prepareAnthropicInputSchema as a, resolveOriginalAnthropicToolName as c, normalizeAnthropicToolChoice as i, toClaudeCodeToolName as l, AnthropicToolProjection as n, projectAnthropicTools as o, normalizeAnthropicToolCallId as r, reconcileAnthropicToolChoice as s, AnthropicProjectedToolChoice as t };

package/dist/{api-registry-BhXXYdRA.d.mts → api-registry-gDt0faai.d.mts}

@@ -1,5 +1,5 @@
-import "./index-BYDvopUB.mjs";
-import { Q as SimpleStreamOptions, n as Api, nt as StreamOptions, tt as StreamFunction } from "./types-Bd2T86VJ.mjs";
+import "./index-DSprYWaz.mjs";
+import { Q as SimpleStreamOptions, n as Api, nt as StreamOptions, tt as StreamFunction } from "./types-CVYzKrMl.mjs";
 //#region packages/ai/src/api-registry.d.ts
 /** Runtime stream adapter signature stored in the API provider registry. */
 type ApiStreamFunction = StreamFunction;

package/dist/{assistant-output-BuhRpLeD.mjs → assistant-output-6iFA1nbC.mjs}

@@ -1,5 +1,5 @@
-import { c as transformMessages } from "./host-Bf3NjYNj.mjs";
-import { a as createEmptyTransportUsage } from "./transport-stream-shared-CWGOuLcA.mjs";
+import { c as transformMessages } from "./host-B2gk-d1H.mjs";
+import { a as createEmptyTransportUsage } from "./transport-stream-shared-CzQlAzJH.mjs";
 //#region packages/ai/src/provider-transcript-transform.ts
 const IMAGE_OMISSION = "(image omitted: model does not support images)";
 const VIDEO_OMISSION = "(video omitted: provider does not support video input)";

package/dist/{azure-openai-responses-DfT9Ndd8.mjs → azure-openai-responses-0TqHwnlD.mjs}

@@ -1,11 +1,11 @@
 import { t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
-import { r as getAiTransportHost } from "./host-Bf3NjYNj.mjs";
-import { n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
-import { F as convertProviderResponsesMessages, Ft as resolvePromptCacheKey, _t as resolveOpenAISimpleReasoningEffort, r as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-D-aDYAkJ.mjs";
-import { n as getEnvApiKey } from "./env-api-keys-CrxwdylR.mjs";
-import { t as createAssistantOutput } from "./assistant-output-BuhRpLeD.mjs";
+import { r as getAiTransportHost } from "./host-B2gk-d1H.mjs";
+import { n as buildBaseOptions } from "./simple-options-BYgC6kse.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-Xd8dm_aV.mjs";
+import { t as createAssistantOutput } from "./assistant-output-6iFA1nbC.mjs";
+import { F as convertProviderResponsesMessages, It as resolvePromptCacheKey, Lt as withOpenAIErrorResponseHook, r as runResponsesStreamLifecycle, t as applyCommonResponsesParams, vt as resolveOpenAISimpleReasoningEffort } from "./openai-responses-shared-Bv_1NtH9.mjs";
 import { i as resolveAzureDeploymentNameFromMap, n as isTraditionalAzureOpenAIHost, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-D0dvJMbZ.mjs";
-import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
+import { t as requireApiKey } from "./required-api-key-D088S4Cd.mjs";
 import OpenAI, { AzureOpenAI } from "openai";
 //#region packages/ai/src/providers/azure-openai-responses.ts
 const DEFAULT_AZURE_API_VERSION = "v1";
@@ -86,10 +86,10 @@ function createClient(model, apiKeyInput, options) {
 		dangerouslyAllowBrowser: true,
 		defaultHeaders: headers,
 		baseURL: baseUrl,
-		fetch: getAiTransportHost().buildModelFetch({
+		fetch: withOpenAIErrorResponseHook(getAiTransportHost().buildModelFetch({
 			...model,
 			baseUrl
-		}),
+		}) ?? globalThis.fetch, options?.onResponse, model),
 		maxRetries: 0
 	};
 	return isOpenAICompatibleAzureResponsesBaseUrl(baseUrl) ? new OpenAI(clientOptions) : new AzureOpenAI({

package/dist/{cloudflare-5qSGvIUH.mjs → cloudflare-Dttf8jKq.mjs}

@@ -1,4 +1,4 @@
-import { t as projectCopilotRequestFacts } from "./github-copilot-request-facts-DEE6gcB9.mjs";
+import { t as projectCopilotRequestFacts } from "./github-copilot-request-facts-F-EmvkpW.mjs";
 //#region packages/ai/src/providers/cache-retention.ts
 /**
 * Resolve cache retention preference.

package/dist/{credential-redaction-BHxruEH6.d.mts → credential-redaction-XvsPf7Yi.d.mts}

@@ -9,6 +9,7 @@ type DiagnosticMediaField = {
   source?: string | Uint8Array;
 };
 type DiagnosticProjectionPolicy = {
+  redactCredentials?: boolean;
   omitField?: (key: string) => boolean;
   propertyScope?: "enumerable" | "error";
   projectBinary?: (binary: Uint8Array) => unknown;

package/dist/{diagnostics-tQasYct1.mjs → diagnostics-Cv7cW3pS.mjs}

@@ -1,8 +1,8 @@
 import { a as isProviderRefusalAssistantError } from "./diagnostics-DzrF1h4J.mjs";
 import { i as asOptionalRecord, o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-CtgOVOSv.mjs";
-import { n as asNonNegativeFiniteNumber, t as asFiniteNumber } from "./number-coercion-C3hztWoY.mjs";
-import "./provider-error-CF9GWCs2.mjs";
+import { r as normalizeLowercaseStringOrEmpty } from "./string-coerce-Cj8sqWHx.mjs";
+import { n as asNonNegativeFiniteNumber, t as asFiniteNumber } from "./number-coercion-37gmNkuA.mjs";
+import "./provider-error-qtZD2inE.mjs";
 //#region packages/normalization-core/src/error-coercion.ts
 function readProperty(value, key) {
 	try {

package/dist/diagnostics.d.mts

@@ -1,9 +1,9 @@
-import { o as ProviderRefusalReview, s as readProviderRefusalReview } from "./index-BYDvopUB.mjs";
-import { At as extractDiagnosticError, Dt as DiagnosticErrorInfo, Et as AssistantMessageDiagnostic, Mt as isProviderRefusalAssistantError, Ot as appendAssistantMessageDiagnostic, a as AssistantMessage, jt as formatThrownValue, kt as createAssistantMessageDiagnostic } from "./types-Bd2T86VJ.mjs";
-import "./types-Kdfw_04V.mjs";
-import { n as isResponsesOutputLimitToolCallError } from "./openai-responses-terminal-usage-BygjiAdi.mjs";
-import { n as ProviderErrorRedactor, r as configureProviderErrorRedactor } from "./provider-error-xumb1V3F.mjs";
-import { i as projectDiagnosticValue, t as DiagnosticProjectionPolicy } from "./credential-redaction-BHxruEH6.mjs";
+import { o as ProviderRefusalReview, s as readProviderRefusalReview } from "./index-DSprYWaz.mjs";
+import { At as extractDiagnosticError, Dt as DiagnosticErrorInfo, Et as AssistantMessageDiagnostic, Mt as isProviderRefusalAssistantError, Ot as appendAssistantMessageDiagnostic, a as AssistantMessage, jt as formatThrownValue, kt as createAssistantMessageDiagnostic } from "./types-CVYzKrMl.mjs";
+import "./types-CBJthzJX.mjs";
+import { n as isResponsesOutputLimitToolCallError } from "./openai-responses-terminal-usage-CpVjkqn-.mjs";
+import { n as ProviderErrorRedactor, r as configureProviderErrorRedactor } from "./provider-error-CnaWYTRY.mjs";
+import { i as projectDiagnosticValue, t as DiagnosticProjectionPolicy } from "./credential-redaction-XvsPf7Yi.mjs";
 import { i as emitModelTransportError, n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./model-transport-url-BrsjjdjR.mjs";
 //#region packages/ai/src/transports/openai-responses-stream-errors.d.ts
 /** Resume only a response that could not have completed tools or exposed visible output. */

package/dist/diagnostics.mjs

@@ -1,4 +1,4 @@
 import { a as isProviderRefusalAssistantError, i as formatThrownValue, n as createAssistantMessageDiagnostic, o as readProviderRefusalReview, r as extractDiagnosticError, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
-import { a as projectDiagnosticValue, t as configureProviderErrorRedactor } from "./provider-error-CF9GWCs2.mjs";
-import { c as hasRetryableConnectionErrorCode, i as emitModelTransportError, l as isTransientNetworkError, m as isResponsesOutputLimitToolCallError, n as formatModelTransportDebugUrl, p as resolveResponsesOutputIdentityRetry, r as emitModelTransportDebug, s as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, t as formatModelTransportDebugBaseUrl } from "./diagnostics-tQasYct1.mjs";
+import { a as projectDiagnosticValue, t as configureProviderErrorRedactor } from "./provider-error-qtZD2inE.mjs";
+import { c as hasRetryableConnectionErrorCode, i as emitModelTransportError, l as isTransientNetworkError, m as isResponsesOutputLimitToolCallError, n as formatModelTransportDebugUrl, p as resolveResponsesOutputIdentityRetry, r as emitModelTransportDebug, s as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, t as formatModelTransportDebugBaseUrl } from "./diagnostics-Cv7cW3pS.mjs";
 export { WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, emitModelTransportDebug, emitModelTransportError, extractDiagnosticError, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, formatThrownValue, hasRetryableConnectionErrorCode, isProviderRefusalAssistantError, isResponsesOutputLimitToolCallError, isTransientNetworkError, projectDiagnosticValue, readProviderRefusalReview, resolveResponsesOutputIdentityRetry };

package/dist/{env-api-keys-CrxwdylR.mjs → env-api-keys-Xd8dm_aV.mjs}

@@ -1,42 +1,19 @@
-import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
 //#region packages/ai/src/env-api-keys.ts
 let nodeHelpers;
-const dynamicImport = (specifier) => import(specifier);
-const NODE_FS_SPECIFIER = "node:fs";
-const NODE_OS_SPECIFIER = "node:os";
-const NODE_PATH_SPECIFIER = "node:path";
-function loadNodeBuiltinModule(specifier) {
-	const getBuiltinModule = typeof process !== "undefined" ? process : void 0;
-	if (typeof getBuiltinModule?.getBuiltinModule === "function") return getBuiltinModule.getBuiltinModule(specifier);
-	if (typeof __require === "function") return __require(specifier);
-	return null;
-}
 function loadNodeHelpersSync() {
 	try {
-		const fsModule = loadNodeBuiltinModule(NODE_FS_SPECIFIER);
-		const osModule = loadNodeBuiltinModule(NODE_OS_SPECIFIER);
-		const pathModule = loadNodeBuiltinModule(NODE_PATH_SPECIFIER);
-		if (fsModule && osModule && pathModule) nodeHelpers = {
-			existsSync: fsModule.existsSync,
-			homedir: osModule.homedir,
-			join: pathModule.join
+		const { existsSync } = process.getBuiltinModule("node:fs");
+		const { homedir } = process.getBuiltinModule("node:os");
+		const { join } = process.getBuiltinModule("node:path");
+		nodeHelpers = {
+			existsSync,
+			homedir,
+			join
 		};
 	} catch {}
 	return nodeHelpers;
 }
-if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-	if (!loadNodeHelpersSync()) Promise.all([
-		dynamicImport(NODE_FS_SPECIFIER),
-		dynamicImport(NODE_OS_SPECIFIER),
-		dynamicImport(NODE_PATH_SPECIFIER)
-	]).then(([fsModule, osModule, pathModule]) => {
-		nodeHelpers = {
-			existsSync: fsModule.existsSync,
-			homedir: osModule.homedir,
-			join: pathModule.join
-		};
-	});
-}
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) loadNodeHelpersSync();
 let procEnvCache = null;
 function getProcessEnv() {
 	return typeof process === "undefined" ? void 0 : process.env;
@@ -52,9 +29,8 @@ function getProcEnv(key) {
 	if (procEnvCache === null) {
 		procEnvCache = /* @__PURE__ */ new Map();
 		try {
-			const fsModule = loadNodeBuiltinModule(NODE_FS_SPECIFIER);
-			if (!fsModule) return;
-			const data = fsModule.readFileSync("/proc/self/environ", "utf-8");
+			const { readFileSync } = process.getBuiltinModule("node:fs");
+			const data = readFileSync("/proc/self/environ", "utf-8");
 			for (const entry of data.split("\0")) {
 				const idx = entry.indexOf("=");
 				if (idx > 0) procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));

package/dist/event-stream-CDpFza-M.d.mts

@@ -0,0 +1 @@
+import "./event-stream-CzpE1g_o.mjs";

package/dist/{event-stream-BcqWLo_u.d.mts → event-stream-CzpE1g_o.d.mts}

@@ -1,4 +1,4 @@
-import { a as AssistantMessage, o as AssistantMessageEvent, ot as ThinkingContent, s as AssistantMessageEventStreamContract } from "./types-Bd2T86VJ.mjs";
+import { a as AssistantMessage, o as AssistantMessageEvent, ot as ThinkingContent, s as AssistantMessageEventStreamContract } from "./types-CVYzKrMl.mjs";
 //#region packages/llm-core/src/utils/event-stream.d.ts
 /** Returns only an append whose current and previously observed snapshots still match. */
 declare function readAssistantThinkingAppend(block: ThinkingContent, previous: string): string | undefined;

package/dist/event-stream.d.mts

@@ -1,3 +1,3 @@
-import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-BcqWLo_u.mjs";
-import "./event-stream-6UNs-AhN.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-CzpE1g_o.mjs";
+import "./event-stream-CDpFza-M.mjs";
 export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/{github-copilot-request-facts-DEE6gcB9.mjs → github-copilot-request-facts-F-EmvkpW.mjs}

@@ -1,4 +1,4 @@
-import { f as hasRuntimeContextMarker } from "./types-CQc6JNG4.mjs";
+import { f as hasRuntimeContextMarker } from "./types-BXd0kI8-.mjs";
 import "./types.mjs";
 //#region packages/ai/src/providers/github-copilot-request-facts.ts
 /** Request facts shared by Copilot transports; identity headers remain plugin-owned. */

package/dist/{google-interactions-9SSqsJg9.mjs → google-interactions-CTEBy9od.mjs}

@@ -1,40 +1,21 @@
 import { t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
 import { a as asRecord, i as asOptionalRecord, s as readStringField } from "./record-coerce-CNDovvft.mjs";
-import { O as calculateCost, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-Bf3NjYNj.mjs";
-import { t as buildGuardedModelFetch } from "./host-policy-BzZluO6_.mjs";
-import { P as sanitizeSurrogates, b as transportAbortError, c as failTransportStream, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, m as notifyProviderHttpResponse, w as parseJsonPreservingUnsafeIntegers } from "./transport-stream-shared-CWGOuLcA.mjs";
-import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
-import { n as getEnvApiKey } from "./env-api-keys-CrxwdylR.mjs";
-import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-BuhRpLeD.mjs";
-import { n as buildGoogleInteractionsSimpleThinking } from "./google-shared-zGR0QUyS.mjs";
-import { createRequire } from "node:module";
+import { O as calculateCost, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-B2gk-d1H.mjs";
+import { t as buildGuardedModelFetch } from "./host-policy-mpqGhbeM.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-CRGuMONI.mjs";
+import { n as buildBaseOptions, w as stripSystemPromptCacheBoundary } from "./simple-options-BYgC6kse.mjs";
+import { b as transportAbortError, c as failTransportStream, g as parseTerminalToolCallArguments, h as notifyProviderStreamOpened, m as notifyProviderHttpResponse, w as parseJsonPreservingUnsafeIntegers } from "./transport-stream-shared-CzQlAzJH.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-Xd8dm_aV.mjs";
+import { n as transformProviderMessages, t as createAssistantOutput } from "./assistant-output-6iFA1nbC.mjs";
+import { n as buildGoogleInteractionsSimpleThinking } from "./google-shared-VTcCJLW3.mjs";
+//#region packages/ai/package.json
+var version = "2026.10.10-beta.1";
+//#endregion
 //#region packages/ai/src/providers/google-interactions-request.ts
 const DEFAULT_GOOGLE_API_BASE_URL = "https://generativelanguage.googleapis.com";
 let packageVersionMemo;
 function resolvePackageVersion() {
-	if (packageVersionMemo) return packageVersionMemo;
-	if (typeof process !== "undefined" && process.env?.OPENCLAW_VERSION) {
-		packageVersionMemo = process.env.OPENCLAW_VERSION;
-		return packageVersionMemo;
-	}
-	try {
-		const require = createRequire(import.meta.url);
-		for (const candidate of [
-			"../package.json",
-			"../../package.json",
-			"../../../package.json",
-			"../../../../package.json"
-		]) try {
-			const parsed = asRecord(require(candidate));
-			const name = readStringField(parsed, "name");
-			const version = readStringField(parsed, "version");
-			if (version && (name === "openclaw" || name === "@openclaw/ai")) {
-				packageVersionMemo = version;
-				return packageVersionMemo;
-			}
-		} catch {}
-	} catch {}
-	packageVersionMemo = "0.0";
+	if (!packageVersionMemo) packageVersionMemo = typeof process !== "undefined" && process.env?.OPENCLAW_VERSION || version;
 	return packageVersionMemo;
 }
 function resolveGoogleApiClientHeaders(params) {
@@ -270,20 +251,19 @@ async function runGoogleInteractionsLifecycle(params) {
 		let buffer = "";
 		let currentBlock = null;
 		let currentBlockIndex = -1;
-		let currentToolArgs = "";
 		let latestThoughtSignature;
 		let latestUsage;
 		const endCurrentBlock = () => {
 			if (!currentBlock) return;
 			if (currentBlock.type === "toolCall") {
-				if (currentToolArgs.trim()) currentBlock.arguments = parseTerminalToolCallArguments(currentToolArgs);
+				if (currentBlock.partialJson?.trim()) currentBlock.arguments = parseTerminalToolCallArguments(currentBlock.partialJson);
+				delete currentBlock.partialJson;
 				stream.push({
 					type: "toolcall_end",
 					contentIndex: currentBlockIndex,
 					toolCall: currentBlock,
 					partial: output
 				});
-				currentToolArgs = "";
 			} else {
 				if (currentBlock.type === "thinking") {
 					if (!currentBlock.thinkingSignature && latestThoughtSignature) currentBlock.thinkingSignature = latestThoughtSignature;
@@ -344,9 +324,9 @@ async function runGoogleInteractionsLifecycle(params) {
 				type: "toolCall",
 				id: readStringField(source, "id") ?? nextToolCallId(name),
 				name,
-				arguments: args
+				arguments: args,
+				partialJson: Object.keys(args).length > 0 ? JSON.stringify(args) : ""
 			};
-			currentToolArgs = Object.keys(args).length > 0 ? JSON.stringify(args) : "";
 			output.content.push(toolCall);
 			stream.push({
 				type: "toolcall_start",
@@ -419,7 +399,7 @@ async function runGoogleInteractionsLifecycle(params) {
 						if (streamedToolName && (!currentBlock.name || currentBlock.name === "tool")) currentBlock.name = streamedToolName;
 						const streamedToolCallId = readStringField(delta, "id");
 						if (streamedToolCallId) currentBlock.id = streamedToolCallId;
-						currentToolArgs += argText;
+						currentBlock.partialJson = (currentBlock.partialJson ?? "") + argText;
 						stream.push({
 							type: "toolcall_delta",
 							contentIndex: currentBlockIndex,
@@ -451,6 +431,7 @@ async function runGoogleInteractionsLifecycle(params) {
 					const outputTokens = candidatesTokens + thoughtTokens;
 					const totalTokens = Number(usage.total_tokens ?? promptTokens + outputTokens + toolUseTokens);
 					output.usage = {
+						usageReport: { state: typeof usage.total_input_tokens === "number" && typeof usage.total_output_tokens === "number" ? "available" : "unavailable" },
 						input: Math.max(0, promptTokens - cacheRead) + toolUseTokens,
 						output: outputTokens,
 						cacheRead,
@@ -490,6 +471,7 @@ async function runGoogleInteractionsLifecycle(params) {
 		stream.end();
 	} catch (error) {
 		const failure = options?.signal?.aborted ? transportAbortError(options.signal) : error;
+		for (const block of output.content) if (block.type === "toolCall") delete block.partialJson;
 		failTransportStream({
 			stream,
 			output,

package/dist/{google-messages-DsB7fmoQ.mjs → google-messages-DfpHVTaD.mjs}

@@ -1,11 +1,15 @@
 import { r as appendAssistantThinking } from "./event-stream-X2gmsUWv.mjs";
-import { N as isImageWithMediaPayload, O as calculateCost } from "./host-Bf3NjYNj.mjs";
-import { P as sanitizeSurrogates, a as createEmptyTransportUsage, b as transportAbortError, r as coerceTransportToolCallArguments, v as sanitizeTransportPayloadText } from "./transport-stream-shared-CWGOuLcA.mjs";
-import { D as sortPromptCacheToolsByName, d as describeToolResultMediaPlaceholder, m as extractToolResultText } from "./simple-options-BAu4B54D.mjs";
+import { N as isImageWithMediaPayload, O as calculateCost } from "./host-B2gk-d1H.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-CRGuMONI.mjs";
+import { r as sortPromptCacheToolsByName } from "./prompt-cache-stability-D_MeCQFI.mjs";
+import { f as extractToolResultText, l as describeToolResultMediaPlaceholder } from "./simple-options-BYgC6kse.mjs";
+import { a as createEmptyTransportUsage, b as transportAbortError, r as coerceTransportToolCallArguments, v as sanitizeTransportPayloadText } from "./transport-stream-shared-CzQlAzJH.mjs";
 import { t as notifyLlmRequestActivity } from "./llm-request-activity-CfMuh5cC.mjs";
+import { isGoogleGemini4Model } from "./internal/google-model-family.mjs";
 //#region packages/ai/src/transports/google-thinking-level.ts
-/** Returns whether a Gemini Flash model accepts the MINIMAL thinking level. */
+/** Reports MINIMAL support for Gemini Flash and Gemini 4 models. */
 function googleFlashSupportsMinimalThinking(modelId) {
+	if (isGoogleGemini4Model(modelId)) return false;
 	const match = modelId.toLowerCase().match(/(?:^|\/)gemini-3\.(\d+)-flash(?:-|$)/);
 	if (!match) return true;
 	return Number.parseInt(match[1] ?? "0", 10) < 7;
@@ -97,6 +101,7 @@ async function consumeGoogleGenerateContentStream(params) {
 			const outputTokens = knownUsage.candidatesTokenCount + knownUsage.thoughtsTokenCount;
 			params.output.usage = {
 				...createEmptyTransportUsage(),
+				usageReport: { state: sawTerminalReason || chunk.candidates?.some((candidate) => candidate.finishReason && candidate.finishReason !== "FINISH_REASON_UNSPECIFIED") ? "available" : "unavailable" },
 				input: Math.max(0, promptTokens - cacheRead) + toolUsePromptTokens,
 				output: outputTokens,
 				cacheRead,
@@ -189,11 +194,18 @@ async function consumeGoogleGenerateContentStream(params) {
 					contentIndex: blockIndex(),
 					partial: params.output
 				});
+				const streamingCall = {
+					...toolCall,
+					partialJson: JSON.stringify(toolCall.arguments)
+				};
 				params.stream.push({
 					type: "toolcall_delta",
 					contentIndex: blockIndex(),
-					delta: JSON.stringify(toolCall.arguments),
-					partial: params.output
+					delta: streamingCall.partialJson,
+					partial: {
+						...params.output,
+						content: [...params.output.content.slice(0, -1), streamingCall]
+					}
 				});
 				params.stream.push({
 					type: "toolcall_end",

package/dist/{google-provider-stream-CcEI2-MC.mjs → google-provider-stream-DJ8ANfsS.mjs}

@@ -1,10 +1,10 @@
 import { t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
-import { a as resolveAiTransportHeaderSentinels } from "./host-Bf3NjYNj.mjs";
-import { n as buildManagedModelFetch } from "./host-policy-BzZluO6_.mjs";
-import { f as mergeTransportHeaders } from "./transport-stream-shared-CWGOuLcA.mjs";
-import { n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
-import { t as createAssistantOutput } from "./assistant-output-BuhRpLeD.mjs";
-import { i as runGoogleGenerateContentLifecycle, r as buildGoogleSimpleThinking, t as buildGoogleGenerateContentParams } from "./google-shared-zGR0QUyS.mjs";
+import { a as resolveAiTransportHeaderSentinels } from "./host-B2gk-d1H.mjs";
+import { n as buildManagedModelFetch } from "./host-policy-mpqGhbeM.mjs";
+import { n as buildBaseOptions } from "./simple-options-BYgC6kse.mjs";
+import { f as mergeTransportHeaders } from "./transport-stream-shared-CzQlAzJH.mjs";
+import { t as createAssistantOutput } from "./assistant-output-6iFA1nbC.mjs";
+import { i as runGoogleGenerateContentLifecycle, r as buildGoogleSimpleThinking, t as buildGoogleGenerateContentParams } from "./google-shared-VTcCJLW3.mjs";
 import { ResourceScope } from "@google/genai";
 //#region packages/ai/src/providers/google-http-options.ts
 function buildGoogleHttpOptions(model, optionsHeaders, profile) {