@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/internal/runtime.mjs

@@ -0,0 +1,176 @@
+import { n as getEnvApiKey, t as findEnvKeys } from "../env-api-keys-CtMlqaQ4.mjs";
+import { n as createApiRegistry, t as createLlmRuntime } from "../stream-CREqxHgU.mjs";
+import { a as modelsAreEqual, i as getSupportedThinkingLevels, n as calculateCost, r as clampThinkingLevel, t as applyProviderReportedUsageCost } from "../model-utils-DgmOla96.mjs";
+import { n as onLlmRequestActivity, r as createDeferredEventBuffer, t as notifyLlmRequestActivity } from "../llm-request-activity-CehVkZP-.mjs";
+import { t as headersToRecord } from "../headers-B_e4-1J0.mjs";
+import { n as parseStreamingJson, r as repairJson, t as parseJsonWithRepair } from "../json-parse-DzNSIQBq.mjs";
+import { t as sanitizeSurrogates } from "../sanitize-unicode-DT5o51ur.mjs";
+import { t as createReasoningTagTextPartitioner } from "../reasoning-tag-text-partitioner-axhAdUwg.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, n as createFirstStreamEventTimeoutError, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "../stream-first-event-timeout-RjWszj8c.mjs";
+import { t as shortHash } from "../hash-CHgqbJmD.mjs";
+import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId, r as cleanupSessionResources, t as decodeOpenAICodexJwtPayload } from "../openai-chatgpt-jwt-DhAAzLkj.mjs";
+import { t as createSseByteGuard } from "../streaming-byte-guard-BrbkbwUu.mjs";
+//#region packages/ai/src/internal/default-runtime.ts
+const DEFAULT_RUNTIME_KEY = Symbol.for("openclaw.ai.defaultRuntime");
+function resolveDefaultRuntime() {
+	const globalStore = globalThis;
+	if (Object.hasOwn(globalStore, DEFAULT_RUNTIME_KEY)) return globalStore[DEFAULT_RUNTIME_KEY];
+	const registry = createApiRegistry();
+	const state = {
+		registry,
+		runtime: createLlmRuntime(registry)
+	};
+	globalStore[DEFAULT_RUNTIME_KEY] = state;
+	return state;
+}
+const defaultRuntime = resolveDefaultRuntime();
+const defaultApiRegistry = defaultRuntime.registry;
+const defaultLlmRuntime = defaultRuntime.runtime;
+const { registerApiProvider, getApiProvider, getApiProviders, unregisterApiProviders, clearApiProviders } = defaultApiRegistry;
+const { stream, complete, streamSimple, completeSimple } = defaultLlmRuntime;
+//#endregion
+//#region packages/ai/src/utils/overflow.ts
+const CONFIGURED_CONTEXT_SIZE_OVERFLOW_RE = /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i;
+/** Detects DS4-style raw token-count context overflow errors. */
+function isConfiguredContextSizeOverflowError(errorMessage) {
+	return CONFIGURED_CONTEXT_SIZE_OVERFLOW_RE.test(errorMessage);
+}
+/**
+* Regex patterns to detect context overflow errors from different providers.
+*
+* These patterns match error messages returned when the input exceeds
+* the model's context window.
+*
+* Provider-specific patterns (with example error messages):
+*
+* - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
+* - Anthropic: "413 {\"error\":{\"type\":\"request_too_large\",\"message\":\"Request exceeds the maximum size\"}}"
+* - OpenAI: "Your input exceeds the context window of this model"
+* - OpenAI/LiteLLM: "Requested token count exceeds the model's maximum context length of 131072 tokens"
+* - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
+* - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
+* - Groq: "Please reduce the length of the messages or completion"
+* - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "the request exceeds the available context size, try increasing it"
+* - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
+* - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
+* - MiniMax: "invalid params, context window exceeds limit"
+* - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
+* - Cerebras: "400/413 status code (no body)"
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
+* - Xiaomi MiMo: Truncates input to fill contextWindow exactly, then returns finish_reason "length"
+*   with output=0 (no room left to generate). Detected via stopReason "length" + zero output +
+*   input filling the context window.
+* - Ollama: Some deployments truncate silently, others return errors like "prompt too long; exceeded max context length by X tokens"
+*/
+const OVERFLOW_PATTERNS = [
+	/prompt is too long/i,
+	/request_too_large/i,
+	/input is too long for requested model/i,
+	/exceeds the context window/i,
+	/exceeds (?:the )?(?:model'?s )?maximum context length of [\d,]+ tokens?/i,
+	/input token count.*exceeds the maximum/i,
+	/maximum prompt length is \d+/i,
+	/reduce the length of the messages/i,
+	/maximum context length is \d+ tokens/i,
+	/input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+	/exceeds the limit of \d+/i,
+	/exceeds the available context size/i,
+	/greater than the context length/i,
+	/context window exceeds limit/i,
+	/exceeded model token limit/i,
+	/too large for model with \d+ maximum context length/i,
+	CONFIGURED_CONTEXT_SIZE_OVERFLOW_RE,
+	/model_context_window_exceeded/i,
+	/prompt too long; exceeded (?:max )?context length/i,
+	/context[_ ]length[_ ]exceeded/i,
+	/too many tokens/i,
+	/token limit exceeded/i,
+	/^4(?:00|13)\s*(?:status code)?\s*\(no body\)/i
+];
+/**
+* Patterns that indicate non-overflow errors (e.g. rate limiting, server errors).
+* Error messages matching unknown of these are excluded from overflow detection
+* even if they also match an OVERFLOW_PATTERN.
+*
+* Example: Bedrock formats throttling errors as "ThrottlingException: Too many tokens,
+* please wait before trying again." which would match the /too many tokens/i overflow
+* pattern without this exclusion.
+*/
+const NON_OVERFLOW_PATTERNS = [
+	/^(Throttling error|Service unavailable):/i,
+	/rate limit/i,
+	/too many requests/i
+];
+function resolveContextInputTokens(message) {
+	if (message.usage.contextUsage?.state === "available") return message.usage.contextUsage.promptTokens;
+	if (message.usage.contextUsage?.state === "unavailable") return;
+	return message.usage.input + message.usage.cacheRead;
+}
+/**
+* Check if an assistant message represents a context overflow error.
+*
+* This handles two cases:
+* 1. Error-based overflow: Most providers return stopReason "error" with a
+*    specific error message pattern.
+* 2. Silent overflow: Some providers accept overflow requests and return
+*    successfully. For these, we check if usage.input exceeds the context window.
+*
+* ## Reliability by Provider
+*
+* **Reliable detection (returns error with detectable message):**
+* - Anthropic: "prompt is too long: X tokens > Y maximum" or "request_too_large"
+* - OpenAI (Completions & Responses): "exceeds the context window" or "exceeds the model's maximum context length of X tokens"
+* - Google Gemini: "input token count exceeds the maximum"
+* - xAI (Grok): "maximum prompt length is X but request contains Y"
+* - Groq: "reduce the length of the messages"
+* - Cerebras: 400/413 status code (no body)
+* - Mistral: "Prompt contains X tokens ... too large for model with Y maximum context length"
+* - OpenRouter (all backends): "maximum context length is X tokens"
+* - Together AI: "The input (X tokens) is longer than the model's context length (Y tokens)."
+* - llama.cpp: "exceeds the available context size"
+* - LM Studio: "greater than the context length"
+* - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
+*
+* **Unreliable detection:**
+* - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
+*   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
+* - Xiaomi MiMo: Truncates input to fit contextWindow then returns stopReason "length" with
+*   output=0. Pass contextWindow param to detect via the "filled context + zero output" signal.
+* - Ollama: May truncate input silently for some setups, but may also return explicit
+*   overflow errors that match the patterns above. Silent truncation still cannot be
+*   detected here because we do not know the expected token count.
+*
+* ## Custom Providers
+*
+* If you've added custom models via settings.json, this function may not detect
+* overflow errors from those providers. To add support:
+*
+* 1. Send a request that exceeds the model's context window
+* 2. Check the errorMessage in the response
+* 3. Create a regex pattern that matches the error
+* 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
+*    check the errorMessage yourself before calling this function
+*
+* @param message - The assistant message to check
+* @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
+* @returns true if the message indicates a context overflow
+*/
+function isContextOverflow(message, contextWindow) {
+	if (message.stopReason === "error" && message.errorMessage) {
+		if (!NON_OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage)) && OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage))) return true;
+	}
+	if (contextWindow && message.stopReason === "stop") {
+		const inputTokens = resolveContextInputTokens(message);
+		if (inputTokens !== void 0 && inputTokens > contextWindow) return true;
+	}
+	if (contextWindow && message.stopReason === "length" && message.usage.output === 0) {
+		const inputTokens = resolveContextInputTokens(message);
+		if (inputTokens !== void 0 && inputTokens >= contextWindow * .99) return true;
+	}
+	return false;
+}
+//#endregion
+export { applyProviderReportedUsageCost, calculateCost, clampThinkingLevel, cleanupSessionResources, clearApiProviders, complete, completeSimple, createDeferredEventBuffer, createFirstStreamEventAbortController, createFirstStreamEventTimeoutError, createReasoningTagTextPartitioner, createSseByteGuard, decodeOpenAICodexJwtPayload, defaultApiRegistry, defaultLlmRuntime, findEnvKeys, getApiProvider, getApiProviders, getEnvApiKey, getFirstStreamEventTimeoutHandler, getFirstStreamEventTimeoutMs, getSupportedThinkingLevels, headersToRecord, isConfiguredContextSizeOverflowError, isContextOverflow, modelsAreEqual, notifyLlmRequestActivity, onLlmRequestActivity, parseJsonWithRepair, parseStreamingJson, registerApiProvider, registerSessionResourceCleanup, repairJson, resolveOpenAICodexAccountId, sanitizeSurrogates, shortHash, stream, streamSimple, unregisterApiProviders, withFirstStreamEventTimeout };

package/dist/internal/shared.d.mts

@@ -0,0 +1,48 @@
+import { E as Model, F as SimpleStreamOptions, H as ThinkingBudgets, T as Message, W as ThinkingLevel, i as AssistantMessage, n as Api, z as StreamOptions } from "../types-DRgdPqaZ.mjs";
+import { t as sanitizeSurrogates } from "../sanitize-unicode-BZiVbGwK.mjs";
+
+//#region packages/ai/src/providers/simple-options.d.ts
+type FirstEventStreamOptions = {
+  firstEventTimeoutMs?: number;
+  onFirstEventTimeout?: (reason: Error) => void;
+};
+declare function buildBaseOptions(model: Model, options?: SimpleStreamOptions, apiKey?: string): StreamOptions & FirstEventStreamOptions;
+declare function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh"> | undefined;
+declare function adjustMaxTokensForThinking(baseMaxTokens: number | undefined, modelMaxTokens: number, reasoningLevel: ThinkingLevel, customBudgets?: ThinkingBudgets): {
+  maxTokens: number;
+  thinkingBudget: number;
+};
+//#endregion
+//#region packages/ai/src/providers/tool-result-text.d.ts
+declare function describeToolResultMediaPlaceholder(blocks: readonly unknown[]): string | undefined;
+declare function extractToolResultBlockText(block: unknown): string | undefined;
+declare function extractToolResultText(blocks: readonly unknown[]): string;
+//#endregion
+//#region packages/ai/src/providers/transform-messages.d.ts
+/**
+ * Normalize tool call ID for cross-provider compatibility.
+ * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+ * Anthropic APIs require IDs matching ^[a-zA-Z0-9_-]+$ (max 64 chars).
+ */
+declare function transformMessages<TApi extends Api>(messages: Message[], model: Model<TApi>, normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string): Message[];
+//#endregion
+//#region packages/ai/src/utils/prompt-cache-stability.d.ts
+/** Normalize structured prompt text before hashing or snapshot comparison. */
+declare function normalizeStructuredPromptSection(text: string): string;
+/** Normalize, de-dupe, and sort capability ids for stable prompt payloads. */
+declare function normalizePromptCapabilityIds(capabilities: ReadonlyArray<string>): string[];
+//#endregion
+//#region packages/ai/src/utils/system-prompt-cache-boundary.d.ts
+declare const SYSTEM_PROMPT_CACHE_BOUNDARY = "\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n";
+declare function stripSystemPromptCacheBoundary(text: string): string;
+declare function ensureSystemPromptCacheBoundary(systemPrompt: string): string;
+declare function splitSystemPromptCacheBoundary(text: string): {
+  stablePrefix: string;
+  dynamicSuffix: string;
+} | undefined;
+declare function prependSystemPromptAdditionAfterCacheBoundary(params: {
+  systemPrompt: string;
+  systemPromptAddition?: string;
+}): string;
+//#endregion
+export { SYSTEM_PROMPT_CACHE_BOUNDARY, adjustMaxTokensForThinking, buildBaseOptions, clampReasoning, describeToolResultMediaPlaceholder, ensureSystemPromptCacheBoundary, extractToolResultBlockText, extractToolResultText, normalizePromptCapabilityIds, normalizeStructuredPromptSection, prependSystemPromptAdditionAfterCacheBoundary, sanitizeSurrogates, splitSystemPromptCacheBoundary, stripSystemPromptCacheBoundary, transformMessages };

package/dist/internal/shared.mjs

@@ -0,0 +1,3 @@
+import { t as sanitizeSurrogates } from "../sanitize-unicode-DT5o51ur.mjs";
+import { S as normalizeStructuredPromptSection, _ as ensureSystemPromptCacheBoundary, a as adjustMaxTokensForThinking, b as stripSystemPromptCacheBoundary, g as SYSTEM_PROMPT_CACHE_BOUNDARY, i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as buildBaseOptions, r as extractToolResultBlockText, s as clampReasoning, t as transformMessages, v as prependSystemPromptAdditionAfterCacheBoundary, x as normalizePromptCapabilityIds, y as splitSystemPromptCacheBoundary } from "../transform-messages-BhGF_fF4.mjs";
+export { SYSTEM_PROMPT_CACHE_BOUNDARY, adjustMaxTokensForThinking, buildBaseOptions, clampReasoning, describeToolResultMediaPlaceholder, ensureSystemPromptCacheBoundary, extractToolResultBlockText, extractToolResultText, normalizePromptCapabilityIds, normalizeStructuredPromptSection, prependSystemPromptAdditionAfterCacheBoundary, sanitizeSurrogates, splitSystemPromptCacheBoundary, stripSystemPromptCacheBoundary, transformMessages };

package/dist/json-parse-DzNSIQBq.mjs

@@ -0,0 +1,134 @@
+import { parse } from "partial-json";
+//#region packages/ai/src/utils/json-parse.ts
+const VALID_JSON_ESCAPES = /* @__PURE__ */ new Set([
+	"\"",
+	"\\",
+	"/",
+	"b",
+	"f",
+	"n",
+	"r",
+	"t",
+	"u"
+]);
+const JSON_CONTROL_ESCAPES = /* @__PURE__ */ new Set([
+	"b",
+	"f",
+	"n",
+	"r",
+	"t"
+]);
+function isControlCharacter(char) {
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+	switch (char) {
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		default: return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+	}
+}
+/**
+* Repairs malformed JSON string literals by:
+* - escaping raw control characters inside strings
+* - doubling backslashes before invalid escape characters
+*/
+function repairJson(json) {
+	let repaired = "";
+	let inString = false;
+	let stringValuePrefix = "";
+	for (let index = 0; index < json.length; index++) {
+		const char = json[index];
+		if (!inString) {
+			repaired += char;
+			if (char === "\"") {
+				inString = true;
+				stringValuePrefix = "";
+			}
+			continue;
+		}
+		if (char === "\"") {
+			repaired += char;
+			inString = false;
+			stringValuePrefix = "";
+			continue;
+		}
+		if (char === "\\") {
+			const nextChar = json[index + 1];
+			if (nextChar === void 0) {
+				repaired += "\\\\";
+				continue;
+			}
+			if (nextChar === "u") {
+				const unicodeDigits = json.slice(index + 2, index + 6);
+				if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+					repaired += `\\u${unicodeDigits}`;
+					stringValuePrefix += `\\u${unicodeDigits}`;
+					index += 5;
+					continue;
+				}
+				repaired += "\\\\";
+				stringValuePrefix += "\\";
+				continue;
+			}
+			if (JSON_CONTROL_ESCAPES.has(nextChar) && looksLikeWindowsPathPrefix(stringValuePrefix)) {
+				repaired += "\\\\";
+				stringValuePrefix += "\\";
+				continue;
+			}
+			if (VALID_JSON_ESCAPES.has(nextChar)) {
+				repaired += `\\${nextChar}`;
+				stringValuePrefix += nextChar === "\\" ? "\\" : `\\${nextChar}`;
+				index += 1;
+				continue;
+			}
+			repaired += "\\\\";
+			stringValuePrefix += "\\";
+			continue;
+		}
+		repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+		stringValuePrefix += char;
+	}
+	return repaired;
+}
+function parseJsonWithRepair(json) {
+	const repairedJson = repairJson(json);
+	if (repairedJson !== json) return JSON.parse(repairedJson);
+	return JSON.parse(json);
+}
+function looksLikeWindowsPathPrefix(prefix) {
+	const tail = prefix.slice(-160);
+	return /(?:^|[^A-Za-z0-9])[A-Za-z]:(?:[\\/][^"\\/:*?<>|\r\n]*)*$/.test(tail);
+}
+function asStreamingJsonRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+/**
+* Attempts to parse potentially incomplete JSON during streaming.
+* Always returns a valid object, even if the JSON is incomplete.
+*
+* @param partialJson The partial JSON string from streaming
+* @returns Parsed object or empty object if parsing fails
+*/
+function parseStreamingJson(partialJson) {
+	if (!partialJson || partialJson.trim() === "") return {};
+	try {
+		return asStreamingJsonRecord(parseJsonWithRepair(partialJson));
+	} catch {
+		try {
+			return asStreamingJsonRecord(parse(partialJson));
+		} catch {
+			try {
+				return asStreamingJsonRecord(parse(repairJson(partialJson)));
+			} catch {
+				return {};
+			}
+		}
+	}
+}
+//#endregion
+export { parseStreamingJson as n, repairJson as r, parseJsonWithRepair as t };

package/dist/llm-request-activity-CehVkZP-.mjs

@@ -0,0 +1,35 @@
+//#region packages/ai/src/utils/deferred-event-buffer.ts
+function createDeferredEventBuffer(sink, onBufferedEvent) {
+	let events = [];
+	return {
+		push(event) {
+			events.push(event);
+			onBufferedEvent?.();
+		},
+		flush() {
+			for (const event of events) sink.push(event);
+			events = [];
+		},
+		discard() {
+			events = [];
+		}
+	};
+}
+//#endregion
+//#region packages/ai/src/utils/llm-request-activity.ts
+const requestActivityListeners = /* @__PURE__ */ new WeakMap();
+function notifyLlmRequestActivity(signal) {
+	if (!signal) return;
+	for (const listener of requestActivityListeners.get(signal) ?? []) listener();
+}
+function onLlmRequestActivity(signal, listener) {
+	const listeners = requestActivityListeners.get(signal) ?? /* @__PURE__ */ new Set();
+	listeners.add(listener);
+	requestActivityListeners.set(signal, listeners);
+	return () => {
+		listeners.delete(listener);
+		if (listeners.size === 0) requestActivityListeners.delete(signal);
+	};
+}
+//#endregion
+export { onLlmRequestActivity as n, createDeferredEventBuffer as r, notifyLlmRequestActivity as t };