@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/api-registry-BXYnCOIR.d.mts

@@ -0,0 +1,33 @@
+import { E as Model, F as SimpleStreamOptions, R as StreamFunction, n as Api, o as AssistantMessageEventStreamContract, u as Context, z as StreamOptions } from "./types-DRgdPqaZ.mjs";
+
+//#region packages/ai/src/api-registry.d.ts
+/** Runtime stream adapter signature stored in the API provider registry. */
+type ApiStreamFunction = (model: Model, context: Context, options?: StreamOptions) => AssistantMessageEventStreamContract;
+/** Runtime simple-stream adapter signature stored in the API provider registry. */
+type ApiStreamSimpleFunction = (model: Model, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStreamContract;
+/** Provider implementation registered by core or plugins for a specific model API. */
+interface ApiProvider<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> {
+  /** Model API id this provider handles. */
+  api: TApi;
+  /** Full streaming adapter for callers that already own structured options. */
+  stream: StreamFunction<TApi, TOptions>;
+  /** Simple streaming adapter used by agent and plugin runtime defaults. */
+  streamSimple: StreamFunction<TApi, SimpleStreamOptions>;
+}
+/** Type-erased provider returned by a registry after API guards are installed. */
+interface RegisteredApiProvider {
+  api: Api;
+  stream: ApiStreamFunction;
+  streamSimple: ApiStreamSimpleFunction;
+}
+/** Creates an isolated provider registry for one runtime or tenant. */
+declare function createApiRegistry(): {
+  registerApiProvider: <TApi extends Api, TOptions extends StreamOptions>(provider: ApiProvider<TApi, TOptions>, sourceId?: string) => void;
+  getApiProvider: (api: Api) => RegisteredApiProvider | undefined;
+  getApiProviders: () => RegisteredApiProvider[];
+  unregisterApiProviders: (sourceId: string) => void;
+  clearApiProviders: () => void;
+};
+type ApiRegistry = ReturnType<typeof createApiRegistry>;
+//#endregion
+export { RegisteredApiProvider as a, ApiStreamSimpleFunction as i, ApiRegistry as n, createApiRegistry as o, ApiStreamFunction as r, ApiProvider as t };

package/dist/azure-openai-responses-DNoSk8Uy.mjs

@@ -0,0 +1,141 @@
+import { n as getEnvApiKey } from "./env-api-keys-CtMlqaQ4.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
+import { o as buildBaseOptions } from "./transform-messages-BhGF_fF4.mjs";
+import { a as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as runResponsesStreamLifecycle, r as createResponsesAssistantOutput, t as applyCommonResponsesParams } from "./openai-responses-shared-sj2YUPYc.mjs";
+import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-a_O_GVQV.mjs";
+import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-BknoV11q.mjs";
+import OpenAI, { AzureOpenAI } from "openai";
+//#region packages/ai/src/providers/azure-openai-responses.ts
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"opencode",
+	"azure-openai-responses"
+]);
+function resolveDeploymentName(model, options) {
+	if (options?.azureDeploymentName) return options.azureDeploymentName;
+	return resolveAzureDeploymentNameFromMap({
+		modelId: model.id,
+		deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
+	});
+}
+function formatAzureOpenAIError(error) {
+	if (error instanceof Error) {
+		const status = error.status;
+		const statusCode = typeof status === "number" ? status : void 0;
+		if (statusCode !== void 0) return `Azure OpenAI API error (${statusCode}): ${error.message}`;
+		return error.message;
+	}
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+/**
+* Generate function for Azure OpenAI Responses API
+*/
+const streamAzureOpenAIResponses = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	runResponsesStreamLifecycle({
+		stream,
+		model,
+		output: createResponsesAssistantOutput(model, "azure-openai-responses"),
+		options,
+		createClient: () => {
+			return createClient(model, options?.apiKey || getEnvApiKey(model.provider) || "", options);
+		},
+		buildParams: () => buildParams(model, context, options, resolveDeploymentName(model, options)),
+		formatError: formatAzureOpenAIError
+	});
+	return stream;
+};
+const streamSimpleAzureOpenAIResponses = (model, context, options) => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = buildBaseOptions(model, options, apiKey);
+	const reasoningEffort = resolveResponsesReasoningEffort(model, options?.reasoning);
+	return streamAzureOpenAIResponses(model, context, {
+		...base,
+		reasoningEffort: reasoningEffort === "max" ? "xhigh" : reasoningEffort
+	});
+};
+function normalizeAzureBaseUrl(baseUrl) {
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
+	}
+	const isAzureHost = url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+	if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
+		url.pathname = "/openai/v1";
+		url.search = "";
+	}
+	return url.toString().replace(/\/+$/, "");
+}
+function buildDefaultBaseUrl(resourceName) {
+	return `https://${resourceName}.openai.azure.com/openai/v1`;
+}
+function resolveAzureConfig(model, options) {
+	const apiVersion = options?.azureApiVersion || process.env.AZURE_OPENAI_API_VERSION || DEFAULT_AZURE_API_VERSION;
+	const baseUrl = options?.azureBaseUrl?.trim() || process.env.AZURE_OPENAI_BASE_URL?.trim() || void 0;
+	const resourceName = options?.azureResourceName || process.env.AZURE_OPENAI_RESOURCE_NAME;
+	let resolvedBaseUrl = baseUrl;
+	if (!resolvedBaseUrl && resourceName) resolvedBaseUrl = buildDefaultBaseUrl(resourceName);
+	if (!resolvedBaseUrl && model.baseUrl) resolvedBaseUrl = model.baseUrl;
+	if (!resolvedBaseUrl) throw new Error("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");
+	return {
+		baseUrl: normalizeAzureBaseUrl(resolvedBaseUrl),
+		apiVersion
+	};
+}
+function createClient(model, apiKeyInput, options) {
+	let apiKey = apiKeyInput;
+	if (!apiKey) {
+		if (!process.env.AZURE_OPENAI_API_KEY) throw new Error("Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.");
+		apiKey = process.env.AZURE_OPENAI_API_KEY;
+	}
+	const headers = { ...model.headers };
+	if (options?.headers) Object.assign(headers, options.headers);
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+	const guardedFetch = getAiTransportHost().buildModelFetch({
+		...model,
+		baseUrl
+	});
+	if (isOpenAICompatibleAzureResponsesBaseUrl(baseUrl)) return new OpenAI({
+		apiKey,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers,
+		baseURL: baseUrl,
+		fetch: guardedFetch
+	});
+	return new AzureOpenAI({
+		apiKey,
+		apiVersion,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers,
+		baseURL: baseUrl,
+		fetch: guardedFetch
+	});
+}
+function buildParams(model, context, options, deploymentName) {
+	const params = {
+		model: deploymentName,
+		input: convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS),
+		stream: true,
+		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
+	};
+	applyCommonResponsesParams(params, model, context, options);
+	return params;
+}
+const testing = {
+	isOpenAICompatibleAzureResponsesBaseUrl,
+	normalizeAzureBaseUrl,
+	resolveAzureConfig
+};
+//#endregion
+export { streamAzureOpenAIResponses, streamSimpleAzureOpenAIResponses, testing };

package/dist/azure-openai-responses-client-compat-a_O_GVQV.mjs

@@ -0,0 +1,41 @@
+//#region packages/ai/src/providers/azure-deployment-map.ts
+/** Parses AZURE_OPENAI_DEPLOYMENT_MAP-style model=deployment entries. */
+function parseAzureDeploymentNameMap(value) {
+	const map = /* @__PURE__ */ new Map();
+	if (!value) return map;
+	for (const entry of value.split(",")) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const separator = trimmed.indexOf("=");
+		if (separator <= 0) continue;
+		const modelId = trimmed.slice(0, separator).trim();
+		const deploymentName = trimmed.slice(separator + 1).trim();
+		if (!modelId || !deploymentName) continue;
+		map.set(modelId, deploymentName);
+	}
+	return map;
+}
+/** Resolves the Azure deployment name for a model id, falling back to the model id. */
+function resolveAzureDeploymentNameFromMap(params) {
+	return parseAzureDeploymentNameMap(params.deploymentMap).get(params.modelId) || params.modelId;
+}
+//#endregion
+//#region packages/ai/src/providers/azure-openai-responses-client-compat.ts
+function isTraditionalAzureOpenAIHost(hostname) {
+	return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
+}
+function isOpenAICompatibleAzureResponsesBaseUrl(baseUrl) {
+	let url;
+	try {
+		url = new URL(baseUrl);
+	} catch {
+		return false;
+	}
+	if (isTraditionalAzureOpenAIHost(url.hostname)) return false;
+	const hostname = url.hostname.toLowerCase();
+	if (!(hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".api.cognitive.microsoft.com"))) return false;
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+	return normalizedPath === "/openai/v1" || normalizedPath.endsWith("/openai/v1");
+}
+//#endregion
+export { resolveAzureDeploymentNameFromMap as i, isTraditionalAzureOpenAIHost as n, parseAzureDeploymentNameMap as r, isOpenAICompatibleAzureResponsesBaseUrl as t };

package/dist/diagnostics-BaTA9eVl.d.mts

@@ -0,0 +1,25 @@
+//#region packages/llm-core/src/utils/diagnostics.d.ts
+interface DiagnosticErrorInfo {
+  name?: string;
+  message: string;
+  stack?: string;
+  code?: string | number;
+}
+interface AssistantMessageDiagnostic {
+  type: string;
+  timestamp: number;
+  error?: DiagnosticErrorInfo;
+  details?: Record<string, unknown>;
+}
+/** Formats arbitrary thrown values into diagnostic-safe text. */
+declare function formatThrownValue(value: unknown): string;
+/** Extracts serializable diagnostic error fields from Error and non-Error throws. */
+declare function extractDiagnosticError(error: unknown): DiagnosticErrorInfo;
+/** Creates a timestamped assistant-message diagnostic entry. */
+declare function createAssistantMessageDiagnostic(type: string, error: unknown, details?: Record<string, unknown>): AssistantMessageDiagnostic;
+/** Appends a diagnostic while preserving existing message diagnostics. */
+declare function appendAssistantMessageDiagnostic(message: {
+  diagnostics?: AssistantMessageDiagnostic[];
+}, diagnostic: AssistantMessageDiagnostic): void;
+//#endregion
+export { extractDiagnosticError as a, createAssistantMessageDiagnostic as i, DiagnosticErrorInfo as n, formatThrownValue as o, appendAssistantMessageDiagnostic as r, AssistantMessageDiagnostic as t };

package/dist/diagnostics-COpOtRwq.mjs

@@ -0,0 +1,36 @@
+//#region packages/llm-core/src/utils/diagnostics.ts
+/** Formats arbitrary thrown values into diagnostic-safe text. */
+function formatThrownValue(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	return String(value);
+}
+/** Extracts serializable diagnostic error fields from Error and non-Error throws. */
+function extractDiagnosticError(error) {
+	if (!(error instanceof Error)) return {
+		name: "ThrownValue",
+		message: formatThrownValue(error)
+	};
+	const code = error.code;
+	return {
+		name: error.name || void 0,
+		message: error.message || error.name,
+		stack: error.stack,
+		code: typeof code === "string" || typeof code === "number" ? code : void 0
+	};
+}
+/** Creates a timestamped assistant-message diagnostic entry. */
+function createAssistantMessageDiagnostic(type, error, details) {
+	return {
+		type,
+		timestamp: Date.now(),
+		error: extractDiagnosticError(error),
+		details
+	};
+}
+/** Appends a diagnostic while preserving existing message diagnostics. */
+function appendAssistantMessageDiagnostic(message, diagnostic) {
+	message.diagnostics = [...message.diagnostics ?? [], diagnostic];
+}
+//#endregion
+export { formatThrownValue as i, createAssistantMessageDiagnostic as n, extractDiagnosticError as r, appendAssistantMessageDiagnostic as t };

package/dist/diagnostics.d.mts

@@ -0,0 +1,2 @@
+import { a as extractDiagnosticError, i as createAssistantMessageDiagnostic, n as DiagnosticErrorInfo, o as formatThrownValue, r as appendAssistantMessageDiagnostic, t as AssistantMessageDiagnostic } from "./diagnostics-BaTA9eVl.mjs";
+export { AssistantMessageDiagnostic, DiagnosticErrorInfo, appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, extractDiagnosticError, formatThrownValue };

package/dist/diagnostics.mjs

@@ -0,0 +1,2 @@
+import { i as formatThrownValue, n as createAssistantMessageDiagnostic, r as extractDiagnosticError, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
+export { appendAssistantMessageDiagnostic, createAssistantMessageDiagnostic, extractDiagnosticError, formatThrownValue };

package/dist/env-api-keys-CtMlqaQ4.mjs

@@ -0,0 +1,171 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region packages/ai/src/env-api-keys.ts
+let existsSync = null;
+let homedir = null;
+let join = null;
+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);
+		existsSync ??= fsModule?.existsSync ?? null;
+		homedir ??= osModule?.homedir ?? null;
+		join ??= pathModule?.join ?? null;
+		if (!existsSync || !homedir || !join) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+	if (!loadNodeHelpersSync()) {
+		dynamicImport(NODE_FS_SPECIFIER).then((m) => {
+			existsSync = m.existsSync;
+		});
+		dynamicImport(NODE_OS_SPECIFIER).then((m) => {
+			homedir = m.homedir;
+		});
+		dynamicImport(NODE_PATH_SPECIFIER).then((m) => {
+			join = m.join;
+		});
+	}
+}
+let procEnvCache = null;
+function getProcessEnv() {
+	return typeof process === "undefined" ? void 0 : process.env;
+}
+/**
+* Fallback for https://github.com/oven-sh/bun/issues/27802
+* Bun compiled binaries have an empty `process.env` inside sandbox
+* environments on Linux. We can recover the env from `/proc/self/environ`.
+*/
+function getProcEnv(key) {
+	if (typeof process === "undefined" || !process.versions?.bun) return;
+	const env = getProcessEnv();
+	if (!env) return;
+	if (Object.keys(env).length > 0) return;
+	if (procEnvCache === null) {
+		procEnvCache = /* @__PURE__ */ new Map();
+		try {
+			const { readFileSync } = __require("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));
+			}
+		} catch {}
+	}
+	return procEnvCache.get(key);
+}
+function getEnvValue(key) {
+	return getProcessEnv()?.[key] || getProcEnv(key);
+}
+let cachedVertexAdcCredentialsExists = null;
+function hasVertexAdcCredentials() {
+	if (cachedVertexAdcCredentialsExists === null) {
+		if (!existsSync || !homedir || !join) {
+			if (!(typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) || !loadNodeHelpersSync()) return false;
+		}
+		const nodeExistsSync = existsSync;
+		const nodeHomedir = homedir;
+		const nodeJoin = join;
+		if (!nodeExistsSync || !nodeHomedir || !nodeJoin) return false;
+		const gacPath = getEnvValue("GOOGLE_APPLICATION_CREDENTIALS");
+		if (gacPath) cachedVertexAdcCredentialsExists = nodeExistsSync(gacPath) ? true : null;
+		else cachedVertexAdcCredentialsExists = nodeExistsSync(nodeJoin(nodeHomedir(), ".config", "gcloud", "application_default_credentials.json")) ? true : null;
+	}
+	return cachedVertexAdcCredentialsExists === true;
+}
+function getApiKeyEnvVars(provider) {
+	if (provider === "github-copilot") return ["COPILOT_GITHUB_TOKEN"];
+	if (provider === "anthropic") return ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"];
+	if (provider === "moonshot") return ["MOONSHOT_API_KEY", "KIMI_API_KEY"];
+	if (provider === "kimi" || provider === "kimi-coding") return ["KIMI_API_KEY", "KIMICODE_API_KEY"];
+	const envVar = {
+		openai: "OPENAI_API_KEY",
+		"meta": "MODEL_API_KEY",
+		"azure-openai-responses": "AZURE_OPENAI_API_KEY",
+		deepseek: "DEEPSEEK_API_KEY",
+		google: "GEMINI_API_KEY",
+		"google-vertex": "GOOGLE_CLOUD_API_KEY",
+		groq: "GROQ_API_KEY",
+		cerebras: "CEREBRAS_API_KEY",
+		xai: "XAI_API_KEY",
+		openrouter: "OPENROUTER_API_KEY",
+		"vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+		zai: "ZAI_API_KEY",
+		mistral: "MISTRAL_API_KEY",
+		minimax: "MINIMAX_API_KEY",
+		"minimax-cn": "MINIMAX_CN_API_KEY",
+		moonshotai: "MOONSHOT_API_KEY",
+		"moonshotai-cn": "MOONSHOT_API_KEY",
+		huggingface: "HF_TOKEN",
+		fireworks: "FIREWORKS_API_KEY",
+		together: "TOGETHER_API_KEY",
+		opencode: "OPENCODE_API_KEY",
+		"opencode-go": "OPENCODE_API_KEY",
+		"cloudflare-workers-ai": "CLOUDFLARE_API_KEY",
+		"cloudflare-ai-gateway": "CLOUDFLARE_API_KEY",
+		xiaomi: "XIAOMI_API_KEY",
+		"xiaomi-token-plan-cn": "XIAOMI_TOKEN_PLAN_CN_API_KEY",
+		"xiaomi-token-plan-ams": "XIAOMI_TOKEN_PLAN_AMS_API_KEY",
+		"xiaomi-token-plan-sgp": "XIAOMI_TOKEN_PLAN_SGP_API_KEY"
+	}[provider];
+	return envVar ? [envVar] : void 0;
+}
+/**
+* Find configured environment variables that can provide an API key for a provider.
+*
+* This only reports actual API key variables. It intentionally excludes ambient
+* credential sources such as AWS profiles, AWS IAM credentials, and Google
+* Application Default Credentials.
+*/
+function findEnvKeys(provider) {
+	const envVars = getApiKeyEnvVars(provider);
+	if (!envVars) return;
+	const found = envVars.filter((envVar) => Boolean(getEnvValue(envVar)));
+	return found.length > 0 ? found : void 0;
+}
+/**
+* Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+*
+* Will not return API keys for providers that require OAuth tokens.
+*/
+function getEnvApiKey(provider) {
+	const envKeys = findEnvKeys(provider);
+	if (envKeys?.[0]) return getEnvValue(envKeys[0]);
+	if (provider === "google-vertex") {
+		const hasCredentials = hasVertexAdcCredentials();
+		const hasProject = Boolean(getEnvValue("GOOGLE_CLOUD_PROJECT") || getEnvValue("GCLOUD_PROJECT"));
+		const hasLocation = Boolean(getEnvValue("GOOGLE_CLOUD_LOCATION"));
+		if (hasCredentials && hasProject && hasLocation) return "<authenticated>";
+	}
+	if (provider === "amazon-bedrock") {
+		if (getEnvValue("AWS_PROFILE") || getEnvValue("AWS_ACCESS_KEY_ID") && getEnvValue("AWS_SECRET_ACCESS_KEY") || getEnvValue("AWS_BEARER_TOKEN_BEDROCK") || getEnvValue("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") || getEnvValue("AWS_CONTAINER_CREDENTIALS_FULL_URI") || getEnvValue("AWS_WEB_IDENTITY_TOKEN_FILE")) return "<authenticated>";
+	}
+}
+//#endregion
+export { getEnvApiKey as n, __exportAll as r, findEnvKeys as t };

package/dist/event-stream-0nZeBKl2.d.mts

@@ -0,0 +1,26 @@
+import { a as AssistantMessageEvent, i as AssistantMessage, o as AssistantMessageEventStreamContract } from "./types-DRgdPqaZ.mjs";
+
+//#region packages/llm-core/src/utils/event-stream.d.ts
+/** Generic async-iterable event stream with a separately awaited final result. */
+declare class EventStream<T, R = T> implements AsyncIterable<T> {
+  private queue;
+  private waiting;
+  private done;
+  private finalResultPromise;
+  private resolveFinalResult;
+  private isComplete;
+  private extractResult;
+  constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+  push(event: T): void;
+  end(result?: R): void;
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+  result(): Promise<R>;
+}
+/** Assistant-message event stream that resolves on done/error terminal events. */
+declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> implements AssistantMessageEventStreamContract {
+  constructor();
+}
+/** Creates an assistant-message stream for provider and plugin adapters. */
+declare function createAssistantMessageEventStream(): AssistantMessageEventStream;
+//#endregion
+export { EventStream as n, createAssistantMessageEventStream as r, AssistantMessageEventStream as t };

package/dist/event-stream-ReMmOTzX.mjs

@@ -0,0 +1,65 @@
+//#region packages/llm-core/src/utils/event-stream.ts
+/** Generic async-iterable event stream with a separately awaited final result. */
+var EventStream = class {
+	constructor(isComplete, extractResult) {
+		this.queue = [];
+		this.waiting = [];
+		this.done = false;
+		this.isComplete = isComplete;
+		this.extractResult = extractResult;
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveFinalResult = resolve;
+		});
+	}
+	push(event) {
+		if (this.done) return;
+		if (this.isComplete(event)) {
+			this.done = true;
+			this.resolveFinalResult(this.extractResult(event));
+		}
+		const waiter = this.waiting.shift();
+		if (waiter) waiter({
+			value: event,
+			done: false
+		});
+		else this.queue.push(event);
+	}
+	end(result) {
+		this.done = true;
+		if (result !== void 0) this.resolveFinalResult(result);
+		while (this.waiting.length > 0) this.waiting.shift()({
+			value: void 0,
+			done: true
+		});
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this.queue.length > 0) yield this.queue.shift();
+		else if (this.done) return;
+		else {
+			const result = await new Promise((resolve) => {
+				this.waiting.push(resolve);
+			});
+			if (result.done) return;
+			yield result.value;
+		}
+	}
+	result() {
+		return this.finalResultPromise;
+	}
+};
+/** Assistant-message event stream that resolves on done/error terminal events. */
+var AssistantMessageEventStream = class extends EventStream {
+	constructor() {
+		super((event) => event.type === "done" || event.type === "error", (event) => {
+			if (event.type === "done") return event.message;
+			else if (event.type === "error") return event.error;
+			throw new Error("Unexpected event type for final result");
+		});
+	}
+};
+/** Creates an assistant-message stream for provider and plugin adapters. */
+function createAssistantMessageEventStream() {
+	return new AssistantMessageEventStream();
+}
+//#endregion
+export { EventStream as n, createAssistantMessageEventStream as r, AssistantMessageEventStream as t };

package/dist/event-stream.d.mts

@@ -0,0 +1,2 @@
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-0nZeBKl2.mjs";
+export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/event-stream.mjs

@@ -0,0 +1,2 @@
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/github-copilot-headers-BsH5cqGj.mjs

@@ -0,0 +1,48 @@
+//#region packages/ai/src/providers/cache-retention.ts
+/**
+* Resolve cache retention preference.
+* Defaults to "short" and uses OPENCLAW_CACHE_RETENTION for backward compatibility.
+*/
+function resolveCacheRetention(cacheRetention) {
+	if (cacheRetention) return cacheRetention;
+	if (typeof process !== "undefined" && process.env.OPENCLAW_CACHE_RETENTION === "long") return "long";
+	return "short";
+}
+//#endregion
+//#region packages/ai/src/providers/cloudflare.ts
+function isCloudflareProvider(provider) {
+	return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
+}
+/** Substitute `{VAR}` placeholders in a Cloudflare baseUrl from process.env. */
+function resolveCloudflareBaseUrl(model) {
+	const url = model.baseUrl;
+	if (!url.includes("{")) return url;
+	return url.replace(/\{([A-Z_][A-Z0-9_]*)\}/g, (_match, name) => {
+		const value = process.env[name];
+		if (!value) throw new Error(`${name} is required for provider ${model.provider} but is not set.`);
+		return value;
+	});
+}
+//#endregion
+//#region packages/ai/src/providers/github-copilot-headers.ts
+function inferCopilotInitiator(messages) {
+	const last = messages[messages.length - 1];
+	return last && last.role !== "user" ? "agent" : "user";
+}
+function hasCopilotVisionInput(messages) {
+	return messages.some((msg) => {
+		if (msg.role === "user" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		if (msg.role === "toolResult" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
+		return false;
+	});
+}
+function buildCopilotDynamicHeaders(params) {
+	const headers = {
+		"X-Initiator": inferCopilotInitiator(params.messages),
+		"Openai-Intent": "conversation-edits"
+	};
+	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";
+	return headers;
+}
+//#endregion
+export { resolveCacheRetention as a, resolveCloudflareBaseUrl as i, hasCopilotVisionInput as n, isCloudflareProvider as r, buildCopilotDynamicHeaders as t };

package/dist/google-D6sIQ1bL.mjs

@@ -0,0 +1,55 @@
+import { n as getEnvApiKey } from "./env-api-keys-CtMlqaQ4.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
+import { o as buildBaseOptions } from "./transform-messages-BhGF_fF4.mjs";
+import { a as runGoogleGenerateContentLifecycle, i as getDisabledGoogleThinkingConfig, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-ZPSl2qTi.mjs";
+import { GoogleGenAI } from "@google/genai";
+//#region packages/ai/src/providers/google.ts
+let toolCallCounter = 0;
+const streamGoogle = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	runGoogleGenerateContentLifecycle({
+		stream,
+		model,
+		output: createGoogleAssistantOutput(model, "google-generative-ai"),
+		options,
+		createClient: () => {
+			return createClient(model, options?.apiKey || getEnvApiKey(model.provider) || "", options?.headers);
+		},
+		buildParams: () => buildParams(model, context, options),
+		nextToolCallId: (name) => `${name}_${Date.now()}_${++toolCallCounter}`
+	});
+	return stream;
+};
+const streamSimpleGoogle = (model, context, options) => {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+	const base = buildBaseOptions(model, options, apiKey);
+	return streamGoogle(model, context, {
+		...base,
+		thinking: buildGoogleSimpleThinking(model, options, {
+			includeGemma4ThinkingLevel: true,
+			useFlashLiteBudgets: true
+		})
+	});
+};
+function createClient(model, apiKey, optionsHeaders) {
+	const httpOptions = {};
+	if (model.baseUrl) {
+		httpOptions.baseUrl = model.baseUrl;
+		httpOptions.apiVersion = "";
+	}
+	if (model.headers || optionsHeaders) httpOptions.headers = resolveAiTransportHeaderSentinels({
+		...model.headers,
+		...optionsHeaders
+	});
+	return new GoogleGenAI({
+		apiKey: apiKey ? getAiTransportHost().resolveSecretSentinel(apiKey) : void 0,
+		httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : void 0
+	});
+}
+function buildParams(model, context, options = {}) {
+	return buildGoogleGenerateContentParams(model, context, options, { getDisabledThinkingConfig: (modelLocal) => getDisabledGoogleThinkingConfig(modelLocal, { includeGemma4: true }) });
+}
+//#endregion
+export { streamGoogle, streamSimpleGoogle };