@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/openai-tool-projection-BknoV11q.mjs

@@ -0,0 +1,195 @@
+import { c as isRecord } from "./transform-messages-BhGF_fF4.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BXtBc_mD.mjs";
+//#region packages/ai/src/providers/openai-prompt-cache.ts
+/** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */
+const OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+/** Truncates a prompt cache key by Unicode code point count. */
+function clampOpenAIPromptCacheKey(key) {
+	if (key === void 0) return;
+	const chars = Array.from(key);
+	if (chars.length <= 64) return key;
+	return chars.slice(0, 64).join("");
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-projection.ts
+function unreadableToolDiagnostic(toolIndex) {
+	return {
+		toolIndex,
+		violations: [`tool[${toolIndex}] is unreadable`]
+	};
+}
+/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
+function projectOpenAITools(tools) {
+	let inputToolCount;
+	try {
+		inputToolCount = tools.length;
+	} catch {
+		return {
+			inputToolCount: 0,
+			tools: [],
+			diagnostics: [unreadableToolDiagnostic(0)]
+		};
+	}
+	const projectedTools = [];
+	const diagnostics = [];
+	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
+		let tool;
+		try {
+			tool = tools[toolIndex];
+		} catch {
+			diagnostics.push(unreadableToolDiagnostic(toolIndex));
+			continue;
+		}
+		let name;
+		try {
+			name = tool.name;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is unreadable`]
+			});
+			continue;
+		}
+		if (typeof name !== "string" || !name) {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is empty`]
+			});
+			continue;
+		}
+		let parameters;
+		try {
+			parameters = tool.parameters;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: [`${name}.parameters is unreadable`]
+			});
+			continue;
+		}
+		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
+		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
+			});
+			continue;
+		}
+		let descriptionValue;
+		try {
+			descriptionValue = tool.description;
+		} catch {}
+		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
+		projectedTools.push({
+			toolIndex,
+			name,
+			...description !== void 0 ? { description } : {},
+			parameters: schemaProjection.schema
+		});
+	}
+	return {
+		inputToolCount,
+		tools: projectedTools,
+		diagnostics
+	};
+}
+function requireProjectedFunction(name, projection, choiceLabel) {
+	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
+}
+/** Keeps Responses tool choices aligned with surviving function schemas. */
+function reconcileOpenAIResponsesToolChoice(choice, projection) {
+	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
+	if (choice === "required") {
+		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
+		return choice;
+	}
+	if (choice === "none" || !isRecord(choice)) return choice;
+	const choiceType = choice.type;
+	if (choiceType === "function") {
+		const functionName = choice.name;
+		if (typeof functionName !== "string") return choice;
+		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
+		return {
+			type: "function",
+			name: functionName
+		};
+	}
+	if (choiceType !== "allowed_tools") return choice;
+	const mode = choice.mode;
+	const tools = choice.tools;
+	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
+	const normalizedAllowedTools = [];
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool.type !== "function") {
+			normalizedAllowedTools.push(tool);
+			continue;
+		}
+		const functionName = tool.name;
+		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
+			type: "function",
+			name: functionName
+		});
+	}
+	if (normalizedAllowedTools.length === 0) {
+		if (mode === "auto") return "none";
+		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
+	}
+	return {
+		type: "allowed_tools",
+		mode,
+		tools: normalizedAllowedTools
+	};
+}
+/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
+function reconcileOpenAICompletionsToolChoice(choice, projection) {
+	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
+	if (choice === "required") {
+		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
+		return choice;
+	}
+	if (choice === "none" || !isRecord(choice)) return choice;
+	const choiceType = choice.type;
+	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
+	if (choiceType === "function") {
+		const functionChoice = choice.function;
+		if (!isRecord(functionChoice)) return choice;
+		const functionName = functionChoice.name;
+		if (typeof functionName !== "string") return choice;
+		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
+		return {
+			type: "function",
+			function: { name: functionName }
+		};
+	}
+	if (choiceType !== "allowed_tools") return choice;
+	const allowedConfig = choice.allowed_tools;
+	if (!isRecord(allowedConfig)) return choice;
+	const mode = allowedConfig.mode;
+	const tools = allowedConfig.tools;
+	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
+	const normalizedAllowedTools = [];
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool.type !== "function") continue;
+		const functionChoice = tool.function;
+		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
+		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
+			type: "function",
+			function: { name: functionName }
+		});
+	}
+	if (normalizedAllowedTools.length === 0) {
+		if (mode === "auto") return "none";
+		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
+	}
+	return {
+		type: "allowed_tools",
+		allowed_tools: {
+			mode,
+			tools: normalizedAllowedTools
+		}
+	};
+}
+//#endregion
+export { clampOpenAIPromptCacheKey as a, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH as i, reconcileOpenAICompletionsToolChoice as n, reconcileOpenAIResponsesToolChoice as r, projectOpenAITools as t };

package/dist/providers.d.mts

@@ -0,0 +1,11 @@
+import { n as ApiRegistry } from "./api-registry-BXYnCOIR.mjs";
+
+//#region packages/ai/src/providers/register-builtins.d.ts
+/** Source id used for built-in API provider registrations. */
+declare const BUILT_IN_API_PROVIDER_SOURCE_ID = "core:built-in";
+/** Registers every built-in API provider in one runtime registry. */
+declare function registerBuiltInApiProviders(registry: ApiRegistry): void;
+/** Restores the built-in provider registry state for tests. */
+declare function resetApiProviders(registry: ApiRegistry): void;
+//#endregion
+export { BUILT_IN_API_PROVIDER_SOURCE_ID, registerBuiltInApiProviders, resetApiProviders };

package/dist/providers.mjs

@@ -0,0 +1,109 @@
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+//#region packages/ai/src/providers/register-builtins.ts
+/** Source id used for built-in API provider registrations. */
+const BUILT_IN_API_PROVIDER_SOURCE_ID = "core:built-in";
+function forwardStream(target, source) {
+	(async () => {
+		for await (const event of source) target.push(event);
+		target.end();
+	})();
+}
+function createLazyLoadErrorMessage(model, error) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now()
+	};
+}
+function createLazyStream(load, select) {
+	return (model, context, options) => {
+		const outer = new AssistantMessageEventStream();
+		load().then((streams) => forwardStream(outer, select(streams)(model, context, options))).catch((error) => {
+			const message = createLazyLoadErrorMessage(model, error);
+			outer.push({
+				type: "error",
+				reason: "error",
+				error: message
+			});
+			outer.end(message);
+		});
+		return outer;
+	};
+}
+function createLazyRegistration(api, importModule, select) {
+	let streamsPromise;
+	const load = () => streamsPromise ??= importModule().then(select);
+	const stream = createLazyStream(load, (streams) => streams.stream);
+	const streamSimple = createLazyStream(load, (streams) => streams.streamSimple);
+	return (registry) => {
+		registry.registerApiProvider({
+			api,
+			stream,
+			streamSimple
+		}, BUILT_IN_API_PROVIDER_SOURCE_ID);
+	};
+}
+const registerBuiltIns = [
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-B5gZQM5X.mjs").then((n) => n.t), (module) => ({
+		stream: module.streamAnthropic,
+		streamSimple: module.streamSimpleAnthropic
+	})),
+	createLazyRegistration("openai-completions", () => import("./openai-completions-B9QLIq2U.mjs").then((n) => n.n), (module) => ({
+		stream: module.streamOpenAICompletions,
+		streamSimple: module.streamSimpleOpenAICompletions
+	})),
+	createLazyRegistration("mistral-conversations", () => import("./mistral-CePVNdws.mjs"), (module) => ({
+		stream: module.streamMistral,
+		streamSimple: module.streamSimpleMistral
+	})),
+	createLazyRegistration("openai-responses", () => import("./openai-responses-B6LylGxM.mjs").then((n) => n.t), (module) => ({
+		stream: module.streamOpenAIResponses,
+		streamSimple: module.streamSimpleOpenAIResponses
+	})),
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-DNoSk8Uy.mjs"), (module) => ({
+		stream: module.streamAzureOpenAIResponses,
+		streamSimple: module.streamSimpleAzureOpenAIResponses
+	})),
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-DVC4Bk_A.mjs"), (module) => ({
+		stream: module.streamOpenAICodexResponses,
+		streamSimple: module.streamSimpleOpenAICodexResponses
+	})),
+	createLazyRegistration("google-generative-ai", () => import("./google-D6sIQ1bL.mjs"), (module) => ({
+		stream: module.streamGoogle,
+		streamSimple: module.streamSimpleGoogle
+	})),
+	createLazyRegistration("google-vertex", () => import("./google-vertex-rDGwkoZK.mjs"), (module) => ({
+		stream: module.streamGoogleVertex,
+		streamSimple: module.streamSimpleGoogleVertex
+	}))
+];
+/** Registers every built-in API provider in one runtime registry. */
+function registerBuiltInApiProviders(registry) {
+	for (const register of registerBuiltIns) register(registry);
+}
+/** Restores the built-in provider registry state for tests. */
+function resetApiProviders(registry) {
+	registry.unregisterApiProviders(BUILT_IN_API_PROVIDER_SOURCE_ID);
+	registerBuiltInApiProviders(registry);
+}
+//#endregion
+export { BUILT_IN_API_PROVIDER_SOURCE_ID, registerBuiltInApiProviders, resetApiProviders };