openclaw
Version:
Multi-channel AI gateway with extensible messaging integrations
4,036 lines • 167 kB
JavaScript
import { a as normalizeLowercaseStringOrEmpty, p as readStringValue } from "./string-coerce-mnp54Vah.js";
import { c as redactSensitiveText } from "./redact-DduLliKq.js";
import { o as isRecord } from "./record-coerce-DHZ4bFlT.js";
import { _ as parseStrictFiniteNumber, b as parseStrictPositiveInteger, c as asFiniteNumberInRange, f as clampTimerTimeoutMs, y as parseStrictNonNegativeInteger } from "./number-coercion-CJQ8TR--.js";
import "./parse-finite-number-Z7n6tXLk.js";
import { _ as uniqueStrings, l as normalizeStringEntries } from "./string-normalization-WNUDCpXX.js";
import { t as createSubsystemLogger } from "./subsystem-BzXSmsuh.js";
import { d as isLinkLocalIpAddress, g as parseCanonicalIpAddress, o as isCloudMetadataIpAddress } from "./ip-0oQXo6_w.js";
import { r as createAssistantMessageEventStream } from "./event-stream-ReMmOTzX.js";
import { c as shouldUseEnvHttpProxyForUrl } from "./proxy-env-B9aW4MXJ.js";
import { b as ssrfPolicyFromHttpBaseUrlAllowedOrigin, m as mergeSsrFPolicies, x as ssrfPolicyFromHttpBaseUrlFakeIpHostnameAllowlist } from "./ssrf-CvPEXMGn.js";
import { o as withTrustedEnvProxyGuardedFetchMode, r as fetchWithSsrFGuard } from "./fetch-guard-BttkNCLm.js";
import { r as sanitizeInlineImageDataUrl } from "./inline-image-data-url-CwAAaSvc.js";
import { F as resolveProviderTransportTurnStateWithPlugin } from "./provider-runtime-CJtW0nDR.js";
import { t as asBoolean } from "./boolean-By0bZpFH.js";
import { c as hasCopilotVisionInput, o as buildCopilotDynamicHeaders } from "./copilot-dynamic-headers-CF9zPORX.js";
import { a as mergeModelProviderRequestOverrides, i as getModelProviderRequestTransport, l as resolveProviderRequestPolicyConfig, r as buildProviderRequestDispatcherPolicy } from "./provider-request-config-0Zg8QIAI.js";
import { t as redactIdentifier } from "./redact-identifier-CXp_wA0R.js";
import { n as repairToolUseResultPairing } from "./session-transcript-repair-B17NYGhL.js";
import { i as resolveModelBoundThinkingReplayMode, l as calculateCost } from "./sanitize-unicode-CgzZKr22.js";
import { n as getEnvApiKey } from "./env-api-keys-8q9bEA0v.js";
import { n as parseStreamingJson } from "./json-parse-CydVzlvP.js";
import { t as estimateStringChars } from "./cjk-chars-BtjJDifS.js";
import { l as detectOpenAICompletionsCompat } from "./provider-model-compat-DhKi-Qv5.js";
import { n as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-CgdMPTuU.js";
import { a as stripSystemPromptCacheBoundary } from "./system-prompt-cache-boundary-vl0D_wqS.js";
import { i as createReasoningTagTextPartitioner, t as convertMessages } from "./openai-completions-DObeyZ3K.js";
import { t as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-Bx1f-UHU.js";
import { c as isResponsesTextContentPartType, i as resolveOpenAIStrictToolSetting, l as isResponsesTextDeltaEventType, n as normalizeOpenAIStrictToolParameters, r as resolveOpenAIStrictToolFlagForInventory, t as findOpenAIStrictToolSchemaDiagnostics } from "./openai-tool-schema-CT6-f1IZ.js";
import { r as resolveDebugProxySettings } from "./env-ckWue_wY.js";
import { g as truncateErrorDetail, h as readResponseTextLimited, t as ProviderHttpError } from "./provider-http-errors-DqaqQLLZ.js";
import { n as ensureModelProviderLocalService } from "./provider-local-service-ZBHHbJ8A.js";
import { createHash, randomUUID } from "node:crypto";
import OpenAI, { AzureOpenAI } from "openai";
//#region src/agents/model-transport-debug.ts
function normalizeEnv(value) {
return typeof value === "string" ? value.trim().toLowerCase() : "";
}
function isTruthyEnv(value) {
const normalized = normalizeEnv(value);
return normalized.length > 0 && normalized !== "0" && normalized !== "false" && normalized !== "off" && normalized !== "no";
}
/** Resolves model payload debug verbosity from `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
function resolveModelPayloadDebugMode(env = process.env) {
const normalized = normalizeEnv(env.OPENCLAW_DEBUG_MODEL_PAYLOAD);
if (normalized === "tools" || normalized === "full-redacted") return normalized;
if (normalized === "summary") return "summary";
return "off";
}
/** Resolves SSE stream debug verbosity from `OPENCLAW_DEBUG_SSE`. */
function resolveModelSseDebugMode(env = process.env) {
const normalized = normalizeEnv(env.OPENCLAW_DEBUG_SSE);
if (normalized === "peek") return "peek";
if (normalized === "events" || isTruthyEnv(normalized)) return "events";
return "off";
}
/** Returns whether any model transport debug channel is enabled. */
function isModelTransportDebugEnabled(env = process.env) {
return isTruthyEnv(env.OPENCLAW_DEBUG_MODEL_TRANSPORT) || resolveModelPayloadDebugMode(env) !== "off" || resolveModelSseDebugMode(env) !== "off" || isTruthyEnv(env.OPENCLAW_DEBUG_CODE_MODE);
}
/** Emits transport diagnostics at info level only when debug env explicitly enables them. */
function emitModelTransportDebug(log, message) {
if (isModelTransportDebugEnabled()) {
log.info(message);
return;
}
log.debug(message);
}
//#endregion
//#region src/agents/openai-completions-string-content.ts
/**
* OpenAI Chat Completions compatibility helpers. Some providers only accept
* role/content messages with plain string content instead of text block arrays.
*/
function flattenStringOnlyCompletionContent(content) {
if (!Array.isArray(content)) return content;
const textParts = [];
for (const item of content) {
if (!item || typeof item !== "object" || item.type !== "text" || typeof item.text !== "string") return content;
textParts.push(item.text);
}
return textParts.join("\n");
}
/** Flatten string-only text block content arrays into newline-joined strings. */
function flattenCompletionMessagesToStringContent(messages) {
return messages.map((message) => {
if (!message || typeof message !== "object") return message;
const content = message.content;
const flattenedContent = flattenStringOnlyCompletionContent(content);
if (flattenedContent === content) return message;
return {
...message,
content: flattenedContent
};
});
}
/** Strip completion messages to role/content fields for strict providers. */
function stripCompletionMessagesToRoleContent(messages) {
return messages.map((message) => {
if (!message || typeof message !== "object" || Array.isArray(message)) return message;
const record = message;
const stripped = {};
if (Object.hasOwn(record, "role")) stripped.role = record.role;
if (Object.hasOwn(record, "content")) stripped.content = record.content;
return stripped;
});
}
//#endregion
//#region src/agents/openai-reasoning-effort.ts
/**
* OpenAI-compatible reasoning-effort normalization. Different GPT families
* expose different accepted effort enums, so callers map requested values here
* before constructing provider payloads.
*/
const GPT_5_REASONING_EFFORTS = [
"minimal",
"low",
"medium",
"high"
];
const GPT_51_REASONING_EFFORTS = [
"none",
"low",
"medium",
"high"
];
const GPT_52_REASONING_EFFORTS = [
"none",
"low",
"medium",
"high",
"xhigh"
];
const GPT_CODEX_REASONING_EFFORTS = [
"low",
"medium",
"high",
"xhigh"
];
const GPT_PRO_REASONING_EFFORTS = [
"medium",
"high",
"xhigh"
];
const GPT_5_PRO_REASONING_EFFORTS = ["high"];
const GPT_51_CODEX_MAX_REASONING_EFFORTS = [
"none",
"medium",
"high",
"xhigh"
];
const GPT_51_CODEX_MINI_REASONING_EFFORTS = ["medium"];
const GENERIC_REASONING_EFFORTS = [
"low",
"medium",
"high"
];
function normalizeModelId(id) {
return normalizeLowercaseStringOrEmpty(id ?? "").replace(/-\d{4}-\d{2}-\d{2}$/u, "");
}
/** Return whether a model is the GPT-5.4 mini family. */
function isOpenAIGpt54MiniModel(model) {
const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
return /^gpt-5\.4-mini(?:-|$)/u.test(id);
}
/** Normalize user-facing reasoning effort names to API effort names. */
function normalizeOpenAIReasoningEffort(effort) {
return effort === "minimal" ? "minimal" : effort;
}
function readCompatReasoningEfforts(compat) {
if (!compat || typeof compat !== "object") return;
if (compat.supportsReasoningEffort === false) return [];
const raw = compat.supportedReasoningEfforts;
if (!Array.isArray(raw)) return;
const supported = uniqueStrings(normalizeStringEntries(raw.filter((value) => typeof value === "string")));
return supported.length > 0 ? supported : void 0;
}
function isDisabledReasoningEffort(effort) {
return effort === "none" || effort === "off";
}
/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
function resolveOpenAISupportedReasoningEfforts(model) {
const compatEfforts = readCompatReasoningEfforts(model.compat);
if (compatEfforts) return compatEfforts;
const id = normalizeModelId(typeof model.id === "string" ? model.id : void 0);
if (id === "gpt-5.1-codex-mini") return GPT_51_CODEX_MINI_REASONING_EFFORTS;
if (id === "gpt-5.1-codex-max") return GPT_51_CODEX_MAX_REASONING_EFFORTS;
if (/^gpt-5(?:\.\d+)?-codex(?:-|$)/u.test(id)) return GPT_CODEX_REASONING_EFFORTS;
if (id === "gpt-5-pro") return GPT_5_PRO_REASONING_EFFORTS;
if (/^gpt-5\.[2-9](?:\.\d+)?-pro(?:-|$)/u.test(id)) return GPT_PRO_REASONING_EFFORTS;
if (/^gpt-5\.[2-9](?:\.\d+)?(?:-|$)/u.test(id)) return GPT_52_REASONING_EFFORTS;
if (/^gpt-5\.1(?:-|$)/u.test(id)) return GPT_51_REASONING_EFFORTS;
if (/^gpt-5(?:-|$)/u.test(id)) return GPT_5_REASONING_EFFORTS;
return GENERIC_REASONING_EFFORTS;
}
/** Return whether a model accepts a requested reasoning effort. */
function supportsOpenAIReasoningEffort(model, effort) {
return resolveOpenAISupportedReasoningEfforts(model).includes(normalizeOpenAIReasoningEffort(effort));
}
/** Resolve a requested reasoning effort to the closest value supported by the model. */
function resolveOpenAIReasoningEffortForModel(params) {
const requested = normalizeOpenAIReasoningEffort(params.effort);
const normalized = normalizeOpenAIReasoningEffort(params.fallbackMap?.[requested] ?? requested);
const supported = resolveOpenAISupportedReasoningEfforts(params.model);
if (supported.includes(normalized)) return normalized;
if (isDisabledReasoningEffort(requested) || isDisabledReasoningEffort(normalized)) return;
if (requested === "minimal" && supported.includes("low")) return "low";
if ((requested === "minimal" || requested === "low") && supported.includes("medium")) return "medium";
if (requested === "xhigh" && supported.includes("high")) return "high";
return supported.find((effort) => effort !== "none");
}
//#endregion
//#region src/agents/openai-responses-payload-policy.ts
/**
* OpenAI Responses payload policy.
* Classifies endpoint capabilities and applies store, prompt-cache,
* server-compaction, service-tier, and reasoning payload rules.
*/
const OPENAI_RESPONSES_APIS = new Set([
"openai-responses",
"azure-openai-responses",
"openai-chatgpt-responses",
"openclaw-openai-responses-transport"
]);
const OPENAI_RESPONSES_PROVIDERS = new Set([
"openai",
"azure-openai",
"azure-openai-responses"
]);
const LOCAL_ENDPOINT_HOSTS = new Set([
"localhost",
"127.0.0.1",
"::1",
"[::1]"
]);
const MODELSTUDIO_NATIVE_BASE_URLS = new Set([
"https://coding-intl.dashscope.aliyuncs.com/v1",
"https://coding.dashscope.aliyuncs.com/v1",
"https://dashscope.aliyuncs.com/compatible-mode/v1",
"https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
]);
const MOONSHOT_NATIVE_BASE_URLS = new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
function normalizeLowercaseString(value) {
const stringValue = readStringValue(value)?.trim().toLowerCase();
return stringValue ? stringValue : void 0;
}
function normalizeComparableBaseUrl(value) {
const trimmed = readStringValue(value)?.trim();
if (!trimmed) return;
const parsedValue = /^[a-z0-9.[\]-]+(?::\d+)?(?:[/?#].*)?$/i.test(trimmed) ? `https://${trimmed}` : trimmed;
try {
const url = new URL(parsedValue);
if (url.protocol !== "http:" && url.protocol !== "https:") return;
url.hash = "";
url.search = "";
return url.toString().replace(/\/+$/, "").toLowerCase();
} catch {
return;
}
}
function resolveUrlHostname(value) {
const trimmed = readStringValue(value)?.trim();
if (!trimmed) return;
try {
return new URL(trimmed).hostname.toLowerCase();
} catch {
try {
return new URL(`https://${trimmed}`).hostname.toLowerCase();
} catch {
return;
}
}
}
function hostMatchesSuffix(host, suffix) {
return suffix.startsWith(".") || suffix.startsWith("-") ? host.endsWith(suffix) : host === suffix || host.endsWith(`.${suffix}`);
}
function isLocalEndpointHost(host) {
return LOCAL_ENDPOINT_HOSTS.has(host) || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal");
}
function resolveBundledOpenAIResponsesEndpointClass(baseUrl) {
const trimmed = readStringValue(baseUrl)?.trim();
if (!trimmed) return "default";
const host = resolveUrlHostname(trimmed);
if (!host) return "invalid";
const comparableBaseUrl = normalizeComparableBaseUrl(trimmed);
switch (host) {
case "api.anthropic.com": return "anthropic-public";
case "api.cerebras.ai": return "cerebras-native";
case "llm.chutes.ai": return "chutes-native";
case "api.deepseek.com": return "deepseek-native";
case "api.groq.com": return "groq-native";
case "api.mistral.ai": return "mistral-public";
case "api.openai.com": return "openai-public";
case "chatgpt.com": return "openai";
case "generativelanguage.googleapis.com": return "google-generative-ai";
case "aiplatform.googleapis.com": return "google-vertex";
case "api.x.ai": return "xai-native";
case "api.z.ai": return "zai-native";
}
if (hostMatchesSuffix(host, ".githubcopilot.com")) return "github-copilot-native";
if (hostMatchesSuffix(host, ".openai.azure.com")) return "azure-openai";
if (hostMatchesSuffix(host, "openrouter.ai")) return "openrouter";
if (hostMatchesSuffix(host, "opencode.ai")) return "opencode-native";
if (hostMatchesSuffix(host, "-aiplatform.googleapis.com")) return "google-vertex";
if (comparableBaseUrl && MOONSHOT_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "moonshot-native";
if (comparableBaseUrl && MODELSTUDIO_NATIVE_BASE_URLS.has(comparableBaseUrl)) return "modelstudio-native";
if (isLocalEndpointHost(host)) return "local";
return "custom";
}
function isOpenAIResponsesApi(api) {
return api !== void 0 && OPENAI_RESPONSES_APIS.has(api);
}
function readCompatPayloadBoolean(compat, key) {
if (!compat || typeof compat !== "object") return;
return asBoolean(compat[key]);
}
function resolveOpenAIResponsesPayloadCapabilities(model) {
const provider = normalizeLowercaseString(model.provider);
const api = normalizeLowercaseString(model.api);
const isOpenAIProvider = provider === "openai";
const endpointClass = resolveBundledOpenAIResponsesEndpointClass(model.baseUrl);
const isResponsesApi = isOpenAIResponsesApi(api);
const usesConfiguredBaseUrl = endpointClass !== "default";
const usesKnownNativeOpenAIEndpoint = endpointClass === "openai-public" || endpointClass === "openai" || endpointClass === "azure-openai";
const usesKnownNativeOpenAIRoute = endpointClass === "default" ? provider === "openai" : usesKnownNativeOpenAIEndpoint;
const usesExplicitProxyLikeEndpoint = usesConfiguredBaseUrl && !usesKnownNativeOpenAIEndpoint;
const promptCacheKeySupport = readCompatPayloadBoolean(model.compat, "supportsPromptCacheKey");
const shouldStripResponsesPromptCache = promptCacheKeySupport === true ? false : promptCacheKeySupport === false ? isResponsesApi : isResponsesApi && usesExplicitProxyLikeEndpoint;
const supportsResponsesStoreField = readCompatPayloadBoolean(model.compat, "supportsStore") !== false && isResponsesApi;
return {
allowsOpenAIServiceTier: provider === "openai" && (api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai-public" || isOpenAIProvider && (api === "openai-chatgpt-responses" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && provider !== void 0 && OPENAI_RESPONSES_PROVIDERS.has(provider) && usesKnownNativeOpenAIEndpoint,
shouldStripResponsesPromptCache,
supportsResponsesStoreField,
usesKnownNativeOpenAIRoute
};
}
function parsePositiveInteger(value) {
if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
if (typeof value === "string") return parseStrictPositiveInteger(value);
}
function resolveOpenAIResponsesCompactThreshold(model) {
const contextWindow = parsePositiveInteger(model.contextWindow);
if (contextWindow) return Math.max(1e3, Math.floor(contextWindow * .7));
return 8e4;
}
function shouldEnableOpenAIResponsesServerCompaction(explicitStore, provider, extraParams) {
const configured = extraParams?.responsesServerCompaction;
if (configured === false) return false;
if (explicitStore !== true) return false;
if (configured === true) return true;
return provider === "openai";
}
function stripDisabledOpenAIReasoningPayload(payloadObj) {
const reasoning = payloadObj.reasoning;
if (reasoning === "none") {
delete payloadObj.reasoning;
return;
}
if (!reasoning || typeof reasoning !== "object" || Array.isArray(reasoning)) return;
if (reasoning.effort === "none") delete payloadObj.reasoning;
}
/** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */
function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
const capabilities = resolveOpenAIResponsesPayloadCapabilities(model);
const storeMode = options.storeMode ?? "provider-policy";
const explicitStore = storeMode === "preserve" ? void 0 : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : void 0 : capabilities.allowsResponsesStore ? true : void 0;
const isResponsesApi = isOpenAIResponsesApi(normalizeLowercaseString(model.api));
const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
return {
allowsServiceTier: capabilities.allowsOpenAIServiceTier,
compactThreshold: parsePositiveInteger(options.extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model),
explicitStore,
shouldStripDisabledReasoningPayload,
shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
shouldStripStore: explicitStore !== true && readCompatPayloadBoolean(model.compat, "supportsStore") === false && isResponsesApi,
useServerCompaction: options.enableServerCompaction === true && shouldEnableOpenAIResponsesServerCompaction(explicitStore, model.provider, options.extraParams)
};
}
/** Mutate a Responses request payload according to the resolved endpoint policy. */
function applyOpenAIResponsesPayloadPolicy(payloadObj, policy) {
if (policy.explicitStore !== void 0) payloadObj.store = policy.explicitStore;
if (policy.shouldStripStore) delete payloadObj.store;
if (policy.shouldStripPromptCache) {
delete payloadObj.prompt_cache_key;
delete payloadObj.prompt_cache_retention;
}
if (policy.useServerCompaction && payloadObj.context_management === void 0) payloadObj.context_management = [{
type: "compaction",
compact_threshold: policy.compactThreshold
}];
if (policy.shouldStripDisabledReasoningPayload) stripDisabledOpenAIReasoningPayload(payloadObj);
}
//#endregion
//#region src/agents/deepseek-text-filter.ts
/**
* DeepSeek DSML streaming text filter.
* Removes provider-emitted DSML tool markup while buffering split tag prefixes
* across streamed chunks.
*/
const DSML_KINDS = [
"tool_use_error",
"tool_calls",
"tool_call",
"function_calls"
];
const DSML_BARS = ["|", "｜"];
const DSML_OPEN_TOKENS = DSML_BARS.flatMap((bar) => DSML_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
const DSML_CLOSE_TOKENS = DSML_BARS.flatMap((bar) => DSML_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
const MAX_OPEN_TOKEN_LEN = Math.max(...DSML_OPEN_TOKENS.map((token) => token.length));
const MAX_CLOSE_TOKEN_LEN = Math.max(...DSML_CLOSE_TOKENS.map((token) => token.length));
/** Create an incremental text filter that strips DeepSeek DSML tool blocks. */
function createDeepSeekTextFilter() {
let buffer = "";
let insideDsml = false;
const consume = (final) => {
const output = [];
const emit = (text) => {
if (text) output.push(text);
};
while (buffer) {
if (insideDsml) {
const close = findEarliestToken(buffer, DSML_CLOSE_TOKENS);
if (close) {
buffer = buffer.slice(close.index + close.token.length);
insideDsml = false;
continue;
}
const keep = final ? 0 : Math.min(buffer.length, MAX_CLOSE_TOKEN_LEN - 1);
buffer = buffer.slice(buffer.length - keep);
if (final) insideDsml = false;
return output;
}
const open = findEarliestToken(buffer, DSML_OPEN_TOKENS);
if (open) {
emit(buffer.slice(0, open.index));
buffer = buffer.slice(open.index + open.token.length);
insideDsml = true;
continue;
}
if (final) {
emit(buffer);
buffer = "";
return output;
}
const keep = longestDsmlOpenPrefixSuffixLength(buffer);
const emitLength = buffer.length - keep;
if (emitLength <= 0) return output;
emit(buffer.slice(0, emitLength));
buffer = buffer.slice(emitLength);
return output;
}
return output;
};
return {
push(chunk) {
buffer += chunk;
return consume(false);
},
flush() {
return consume(true);
}
};
}
function findEarliestToken(text, tokens) {
let best = null;
for (const token of tokens) {
const index = text.indexOf(token);
if (index !== -1 && (!best || index < best.index)) best = {
index,
token
};
}
return best;
}
function longestDsmlOpenPrefixSuffixLength(text) {
const maxLength = Math.min(text.length, MAX_OPEN_TOKEN_LEN - 1);
for (let length = maxLength; length > 0; length--) {
const suffix = text.slice(text.length - length);
if (DSML_OPEN_TOKENS.some((token) => token.startsWith(suffix))) return length;
}
return 0;
}
//#endregion
//#region src/agents/model-max-tokens-params.ts
/**
* Max-token parameter normalization across provider/native naming variants.
* Callers canonicalize aliases before dispatch so payloads cannot carry
* conflicting limits.
*/
const MAX_TOKENS_PARAM_KEYS = [
"maxTokens",
"max_completion_tokens",
"max_tokens"
];
/** Return a finite non-negative max-token value, or undefined for invalid input. */
function resolveNonNegativeMaxTokensParam(value) {
return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
}
/** Resolve the first supported max-token parameter present in a params object. */
function resolveMaxTokensParam(params) {
if (!params) return;
for (const key of MAX_TOKENS_PARAM_KEYS) {
const resolved = resolveNonNegativeMaxTokensParam(params[key]);
if (resolved !== void 0) return resolved;
}
}
/**
* Canonicalize merged params to `maxTokens`, preserving source precedence from
* left to right across the provided source objects.
*/
function canonicalizeMaxTokensParam(params) {
let resolved;
for (const source of params.sources) {
const sourceValue = resolveMaxTokensParam(source);
if (sourceValue !== void 0) resolved = sourceValue;
}
if (resolved === void 0) return;
for (const key of MAX_TOKENS_PARAM_KEYS) delete params.merged[key];
params.merged.maxTokens = resolved;
}
//#endregion
//#region src/agents/model-tool-support.ts
/**
* Model capability helper for tool-use support.
*
* Provider catalogs can opt a model out via `compat.supportsTools === false`;
* absent metadata remains permissive for older catalog entries.
*/
/** Returns whether a catalog model should be offered tool calls. */
function supportsModelTools(model) {
return (model.compat && typeof model.compat === "object" ? model.compat : void 0)?.supportsTools !== false;
}
//#endregion
//#region src/agents/model-transport-url.ts
/**
* Debug formatting helpers for model transport endpoints.
* Keeps logs useful without exposing credentials, request params, or fragments.
*/
/** Return a sanitized URL suitable for logs and diagnostics. */
function formatModelTransportDebugUrl(rawUrl) {
try {
const parsed = new URL(rawUrl);
parsed.username = "";
parsed.password = "";
parsed.search = "";
parsed.hash = "";
return parsed.toString();
} catch {
return "<invalid-url>";
}
}
/** Format a configured base URL for debug output, or the implicit default. */
function formatModelTransportDebugBaseUrl(rawUrl) {
return rawUrl ? formatModelTransportDebugUrl(rawUrl) : "default";
}
//#endregion
//#region src/agents/openai-compatible-conversation-turn.ts
/**
* OpenAI-compatible conversation turn detector.
*
* Some providers reject requests without a non-empty user/assistant turn; this
* helper checks the loose message payload shape before transport submission.
*/
function hasNonEmptyString(value) {
return typeof value === "string" && value.trim().length > 0;
}
function hasNonEmptyContentPart(part) {
if (!part || typeof part !== "object") return false;
const record = part;
if (record.type === "text") return hasNonEmptyString(record.text);
return true;
}
function hasNonEmptyMessageContent(content) {
if (hasNonEmptyString(content)) return true;
if (!Array.isArray(content)) return false;
return content.some(hasNonEmptyContentPart);
}
function hasAssistantToolCall(message) {
const toolCalls = message.tool_calls;
return Array.isArray(toolCalls) && toolCalls.some((toolCall) => {
return Boolean(toolCall && typeof toolCall === "object");
});
}
/** Returns whether an OpenAI-compatible messages payload contains a usable turn. */
function hasOpenAICompatibleConversationTurn(messages) {
if (!Array.isArray(messages)) return false;
return messages.some((message) => {
if (!message || typeof message !== "object") return false;
const record = message;
if (record.role === "user") return hasNonEmptyMessageContent(record.content);
if (record.role === "assistant") return hasNonEmptyMessageContent(record.content) || hasAssistantToolCall(record);
return false;
});
}
//#endregion
//#region src/agents/openai-reasoning-compat.ts
/**
* OpenAI reasoning-effort compatibility helpers.
*
* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
*/
const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = new Set(["gpt-5.1-codex-mini"]);
function readCompatReasoningEffortMap(compat) {
if (!compat || typeof compat !== "object") return {};
const rawMap = compat.reasoningEffortMap;
if (!rawMap || typeof rawMap !== "object") return {};
return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
}
/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
minimal: "medium",
low: "medium"
} : {};
return {
...fallbackMap,
...builtinMap,
...readCompatReasoningEffortMap(model.compat)
};
}
//#endregion
//#region src/agents/openai-responses-replay.ts
/** Resolves the assistant message id that can be replayed to OpenAI Responses. */
function resolveReplayableResponsesMessageId(params) {
if (!params.replayResponsesItemIds) return;
if (!params.textSignatureId) return params.fallbackOrdinal === 0 ? params.fallbackId : `${params.fallbackId}_${params.fallbackOrdinal}`;
return params.previousReplayItemWasReasoning ? params.textSignatureId : void 0;
}
//#endregion
//#region src/agents/provider-transport-fetch.ts
/**
* Guarded provider fetch transport utilities.
*
* Applies request timeouts, proxy/TLS overrides, SSRF policy, local-service leases, retry hints, and SSE normalization.
*/
const DEFAULT_MAX_SDK_RETRY_WAIT_SECONDS = 60;
const OPENAI_SDK_STREAM_CONTENT_SNIFF_BYTES = 2 * 1024;
const log$1 = createSubsystemLogger("provider-transport-fetch");
const BLOCKED_EXACT_ORIGIN_TRUST_HOSTNAME_LABELS = new Set(["instance-data"]);
const PLAIN_DECIMAL_NUMBER_RE = /^\d+(?:\.\d+)?$/;
const RETRY_AFTER_HTTP_DATE_RE = /^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2} \d{2}:\d{2}:\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ \d]\d \d{2}:\d{2}:\d{2} \d{4})$/;
const HTTP_DATE_MONTH_INDEX = new Map([
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
].map((month, index) => [month, index]));
const OBSOLETE_ASCTIME_HTTP_DATE_RE = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([ \d]\d) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/;
function hasReadableSseData(block) {
const dataLines = block.split(/\r\n|\n|\r/).filter((line) => line === "data" || line.startsWith("data:")).map((line) => {
if (line === "data") return "";
const value = line.slice(5);
return value.startsWith(" ") ? value.slice(1) : value;
});
return dataLines.length > 0 && dataLines.join("\n").trim().length > 0;
}
function findSseEventBoundary(buffer) {
let best;
for (const delimiter of [
"\r\n\r\n",
"\n\n",
"\r\r"
]) {
const index = buffer.indexOf(delimiter);
if (index === -1) continue;
if (!best || index < best.index) best = {
index,
length: delimiter.length
};
}
return best;
}
function sanitizeOpenAISdkSseResponse(response, options) {
const contentType = response.headers.get("content-type") ?? "";
if (!response.ok || !response.body) return response;
if (options?.synthesizeJsonAsSse === true && (/\bapplication\/json\b/i.test(contentType) || /\+json\b/i.test(contentType))) {
const source = response.body;
const decoder = new TextDecoder();
const encoder = new TextEncoder();
let reader;
let buffer = "";
const sseBody = new ReadableStream({
start() {
reader = source.getReader();
},
async pull(controller) {
try {
for (;;) {
const chunk = await reader?.read();
if (!chunk || chunk.done) {
buffer += decoder.decode();
const data = buffer.trim();
if (data) controller.enqueue(encoder.encode(`data: ${data}\n\n`));
controller.enqueue(encoder.encode("data: [DONE]\n\n"));
controller.close();
return;
}
buffer += decoder.decode(chunk.value, { stream: true });
}
} catch (error) {
controller.error(error);
}
},
async cancel(reason) {
await reader?.cancel(reason);
}
});
const headers = new Headers(response.headers);
headers.set("content-type", "text/event-stream; charset=utf-8");
return new Response(sseBody, {
status: response.status,
statusText: response.statusText,
headers
});
}
if (!/\btext\/event-stream\b/i.test(contentType)) return response;
const source = response.body;
const decoder = new TextDecoder();
const encoder = new TextEncoder();
let reader;
let buffer = "";
const enqueueSanitized = (controller, text) => {
let enqueued = 0;
buffer += text;
for (;;) {
const boundary = findSseEventBoundary(buffer);
if (!boundary) return enqueued;
const block = buffer.slice(0, boundary.index);
const separator = buffer.slice(boundary.index, boundary.index + boundary.length);
buffer = buffer.slice(boundary.index + boundary.length);
if (hasReadableSseData(block)) {
controller.enqueue(encoder.encode(`${block}${separator}`));
enqueued += 1;
}
}
};
const sanitizedBody = new ReadableStream({
start() {
reader = source.getReader();
},
async pull(controller) {
try {
for (;;) {
const chunk = await reader?.read();
if (!chunk || chunk.done) {
const tail = decoder.decode();
if (tail) enqueueSanitized(controller, tail);
if (buffer && hasReadableSseData(buffer)) controller.enqueue(encoder.encode(buffer));
buffer = "";
controller.close();
return;
}
if (enqueueSanitized(controller, decoder.decode(chunk.value, { stream: true })) > 0) return;
}
} catch (error) {
controller.error(error);
}
},
async cancel(reason) {
await reader?.cancel(reason);
}
});
return new Response(sanitizedBody, {
status: response.status,
statusText: response.statusText,
headers: response.headers
});
}
function shouldSanitizeOpenAISdkSseResponse(model) {
if (model.provider !== "openai") return true;
try {
return new URL(model.baseUrl).hostname.toLowerCase() !== "api.openai.com";
} catch {
return true;
}
}
function isJsonContentType(contentType) {
return /\bapplication\/json\b/i.test(contentType) || /\+json\b/i.test(contentType);
}
function isOpenAISdkStreamContentType(contentType) {
return /\btext\/event-stream\b/i.test(contentType) || isJsonContentType(contentType);
}
function classifyOpenAISdkStreamBodyPrefix(text) {
const trimmed = text.replace(/^\uFEFF/u, "").trimStart();
if (!trimmed) return "unknown";
if (trimmed.startsWith("<")) return "html";
if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
if (/^(?::|(?:data|event|id|retry)(?::|\r?\n|\r))/u.test(trimmed)) return "sse";
const boundary = findSseEventBoundary(text);
if (boundary && hasReadableSseData(text.slice(0, boundary.index))) return "sse";
return "unknown";
}
async function classifyOpenAISdkStreamBody(response) {
const reader = response.clone().body?.getReader();
if (!reader) return "unknown";
const decoder = new TextDecoder();
let total = 0;
let text = "";
try {
while (total < OPENAI_SDK_STREAM_CONTENT_SNIFF_BYTES) {
const { value, done } = await reader.read();
if (done) break;
if (!value || value.byteLength === 0) continue;
const remaining = OPENAI_SDK_STREAM_CONTENT_SNIFF_BYTES - total;
const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;
total += chunk.byteLength;
text += decoder.decode(chunk, { stream: true });
const kind = classifyOpenAISdkStreamBodyPrefix(text);
if (kind !== "unknown") return kind;
}
text += decoder.decode();
return classifyOpenAISdkStreamBodyPrefix(text);
} finally {
reader.cancel().catch(() => void 0);
}
}
function withOpenAISdkStreamContentType(response, contentType) {
const headers = new Headers(response.headers);
headers.set("content-type", contentType);
return new Response(response.body, {
status: response.status,
statusText: response.statusText,
headers
});
}
async function normalizeOpenAISdkStreamContentType(params) {
const contentType = params.response.headers.get("content-type") ?? "";
if (!params.response.ok || !params.response.body || isOpenAISdkStreamContentType(contentType)) return params.response;
if (!contentType.trim()) {
const kind = await classifyOpenAISdkStreamBody(params.response).catch(() => "unknown");
if (kind === "sse") return withOpenAISdkStreamContentType(params.response, "text/event-stream; charset=utf-8");
if (kind === "json") return withOpenAISdkStreamContentType(params.response, "application/json; charset=utf-8");
}
const body = await readResponseTextLimited(params.response).catch(() => "");
await params.release().catch(() => void 0);
params.localServiceLease?.release();
const hint = `OpenAI-compatible streamed responses must be text/event-stream or JSON; got ${contentType || "missing content-type"}. Check the provider baseUrl; OpenAI-compatible APIs commonly require a /v1 path prefix.`;
throw new ProviderHttpError(`${params.model.provider}/${params.model.id}: ${hint}`, {
status: params.response.status,
code: "invalid_provider_content_type",
type: "invalid_response",
body
});
}
async function requestBodyHasStreamTrue(request, init) {
const method = request?.method ?? init?.method;
if (method && method.toUpperCase() !== "POST") return false;
const contentType = (request?.headers ?? new Headers(init?.headers)).get("content-type") ?? "";
if (contentType && !/\bapplication\/json\b/i.test(contentType)) return false;
let text;
if (typeof init?.body === "string") text = init.body;
if (!text) return false;
try {
return JSON.parse(text).stream === true;
} catch {
return false;
}
}
function parseRetryAfterSeconds(headers) {
const retryAfterMs = headers.get("retry-after-ms");
if (retryAfterMs) {
const trimmedRetryAfterMs = retryAfterMs.trim();
if (/^\d+(?:\.\d+)?$/.test(trimmedRetryAfterMs)) {
const milliseconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmedRetryAfterMs), {
min: 0,
max: Number.MAX_SAFE_INTEGER
});
return milliseconds === void 0 ? Number.POSITIVE_INFINITY : milliseconds / 1e3;
}
}
const retryAfter = headers.get("retry-after");
if (!retryAfter) return;
const trimmedRetryAfterSeconds = retryAfter.trim();
if (/^\d+$/.test(trimmedRetryAfterSeconds)) return parseStrictNonNegativeInteger(trimmedRetryAfterSeconds) ?? Number.POSITIVE_INFINITY;
const trimmedRetryAfter = trimmedRetryAfterSeconds;
if (!RETRY_AFTER_HTTP_DATE_RE.test(trimmedRetryAfter)) return;
const retryAt = parseRetryAfterHttpDateMs(trimmedRetryAfter);
if (Number.isNaN(retryAt)) return;
return Math.max(0, (retryAt - Date.now()) / 1e3);
}
function parseRetryAfterHttpDateMs(value) {
const match = OBSOLETE_ASCTIME_HTTP_DATE_RE.exec(value);
if (match) {
const month = HTTP_DATE_MONTH_INDEX.get(match[1] ?? "");
if (month === void 0) return NaN;
const year = Number.parseInt(match[6] ?? "", 10);
const day = Number.parseInt((match[2] ?? "").trim(), 10);
const hours = Number.parseInt(match[3] ?? "", 10);
const minutes = Number.parseInt(match[4] ?? "", 10);
const seconds = Number.parseInt(match[5] ?? "", 10);
if (day < 1 || day > 31 || hours > 23 || minutes > 59 || seconds > 59 || [
year,
day,
hours,
minutes,
seconds
].some((component) => !Number.isFinite(component))) return NaN;
const timestamp = Date.UTC(year, month, day, hours, minutes, seconds);
const parsedDate = new Date(timestamp);
return parsedDate.getUTCFullYear() === year && parsedDate.getUTCMonth() === month && parsedDate.getUTCDate() === day && parsedDate.getUTCHours() === hours && parsedDate.getUTCMinutes() === minutes && parsedDate.getUTCSeconds() === seconds ? timestamp : NaN;
}
const parsed = Date.parse(value);
if (!Number.isNaN(parsed)) return parsed;
return NaN;
}
function resolveMaxSdkRetryWaitSeconds() {
const raw = process.env.OPENCLAW_SDK_RETRY_MAX_WAIT_SECONDS?.trim();
if (!raw) return DEFAULT_MAX_SDK_RETRY_WAIT_SECONDS;
if (/^(?:0|false|off|none|disabled)$/i.test(raw)) return;
if (!PLAIN_DECIMAL_NUMBER_RE.test(raw)) return DEFAULT_MAX_SDK_RETRY_WAIT_SECONDS;
const seconds = asFiniteNumberInRange(parseStrictFiniteNumber(raw), {
min: 0,
minExclusive: true,
max: Number.MAX_SAFE_INTEGER
});
if (seconds !== void 0) return seconds;
return DEFAULT_MAX_SDK_RETRY_WAIT_SECONDS;
}
function shouldBypassLongSdkRetry(response) {
const maxWaitSeconds = resolveMaxSdkRetryWaitSeconds();
if (maxWaitSeconds === void 0) return false;
const status = response.status;
if (!(status === 408 || status === 409 || status === 429 || status >= 500)) return false;
const retryAfterSeconds = parseRetryAfterSeconds(response.headers);
if (retryAfterSeconds !== void 0) return retryAfterSeconds > maxWaitSeconds;
return status === 429;
}
const managedStreamCleanupRegistry = new FinalizationRegistry((held) => {
held.finalize();
});
function buildManagedResponse(response, release, refreshTimeout, localServiceLease) {
const finalizeLocalServiceLease = () => {
localServiceLease?.release();
};
if (!response.body) {
release().finally(finalizeLocalServiceLease);
return response;
}
const source = response.body;
let reader;
let released = false;
const cleanupRegistrationToken = {};
const finalize = async () => {
if (released) return;
released = true;
managedStreamCleanupRegistry.unregister(cleanupRegistrationToken);
try {
await reader?.cancel().catch(() => void 0);
await release().catch(() => void 0);
} finally {
finalizeLocalServiceLease();
}
};
const wrappedBody = new ReadableStream({
start() {
reader = source.getReader();
},
async pull(controller) {
try {
const chunk = await reader?.read();
if (!chunk || chunk.done) {
controller.close();
await finalize();
return;
}
refreshTimeout?.();
controller.enqueue(chunk.value);
} catch (error) {
controller.error(error);
await finalize();
}
},
async cancel(reason) {
try {
await reader?.cancel(reason);
} finally {
await finalize();
}
}
});
managedStreamCleanupRegistry.register(wrappedBody, { finalize }, cleanupRegistrationToken);
return new Response(wrappedBody, {
status: response.status,
statusText: response.statusText,
headers: response.headers
});
}
function resolveModelRequestPolicy(model) {
const debugProxy = resolveDebugProxySettings();
let explicitDebugProxyUrl;
if (debugProxy.enabled && debugProxy.proxyUrl) try {
if (new URL(model.baseUrl).protocol === "https:") explicitDebugProxyUrl = debugProxy.proxyUrl;
} catch {}
const request = mergeModelProviderRequestOverrides(getModelProviderRequestTransport(model), { proxy: explicitDebugProxyUrl ? {
mode: "explicit-proxy",
url: explicitDebugProxyUrl
} : void 0 });
return resolveProviderRequestPolicyConfig({
provider: model.provider,
api: model.api,
baseUrl: model.baseUrl,
capability: "llm",
transport: "stream",
request
});
}
function resolveModelRequestTimeoutMs(model, timeoutMs) {
if (timeoutMs !== void 0) return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? clampTimerTimeoutMs(timeoutMs) : void 0;
const modelTimeoutMs = model.requestTimeoutMs;
return typeof modelTimeoutMs === "number" && Number.isFinite(modelTimeoutMs) && modelTimeoutMs > 0 ? clampTimerTimeoutMs(modelTimeoutMs) : void 0;
}
function buildModelRequestSignal(baseSignal, timeoutMs) {
if (timeoutMs === void 0) return baseSignal;
const timeoutSignal = AbortSignal.timeout(timeoutMs);
if (!baseSignal) return timeoutSignal;
return AbortSignal.any([baseSignal, timeoutSignal]);
}
function resolveHttpOrigin(value) {
if (typeof value !== "string" || !value.trim()) return;
try {
const parsed = new URL(value);
if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
parsed.hostname = parsed.hostname.replace(/\.+$/, "");
return parsed.origin.toLowerCase();
} catch {
return;
}
}
function normalizeProviderOriginHostname(value) {
if (typeof value !== "string" || !value.trim()) return;
try {
const parsed = new URL(value);
if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
return parsed.hostname.trim().toLowerCase().replace(/\.+$/, "") || void 0;
} catch {
return;
}
}
function canImplicitlyTrustConfiguredBaseUrlOrigin(value) {
const hostname = normalizeProviderOriginHostname(value);
if (!hostname) return false;
return !hostname.split(".").filter(Boolean).some((label) => label.includes("metadata") || BLOCKED_EXACT_ORIGIN_TRUST_HOSTNAME_LABELS.has(label)) && !isLinkLocalIpAddress(hostname) && !isCloudMetadataIpAddress(hostname);
}
function canApplyFakeIpHostnamePolicy(value) {
const hostname = normalizeProviderOriginHostname(value);
if (!hostname) return false;
return !hostname.split(".").filter(Boolean).some((label) => label.includes("metadata") || BLOCKED_EXACT_ORIGIN_TRUST_HOSTNAME_LABELS.has(label)) && !parseCanonicalIpAddress(hostname);
}
function resolveModelTransportSsrFPolicy(params) {
const baseUrl = params.model.baseUrl;
const baseOrigin = resolveHttpOrigin(baseUrl);
const requestOrigin = resolveHttpOrigin(params.url);
const requestMatchesBaseOrigin = typeof baseUrl === "string" && Boolean(baseOrigin) && requestOrigin === baseOrigin;
return mergeSsrFPolicies(requestMatchesBaseOrigin && params.trustConfiguredBaseUrlOrigin && canImplicitlyTrustConfiguredBaseUrlOrigin(baseUrl) ? ssrfPolicyFromHttpBaseUrlAllowedOrigin(baseUrl) : void 0, requestMatchesBaseOrigin && canApplyFakeIpHostnamePolicy(baseUrl) ? ssrfPolicyFromHttpBaseUrlFakeIpHostnameAllowlist(baseUrl) : void 0, params.allowPrivateNetwork ? { allowPrivateNetwork: true } : void 0);
}
function buildGuardedModelFetch(model, timeoutMs, options) {
const requestConfig = resolveModelRequestPolicy(model);
const dispatcherPolicy = buildProviderRequestDispatcherPolicy(requestConfig);
const requestTimeoutMs = resolveModelRequestTimeoutMs(model, timeoutMs);
const summarizeError = (error) => {
if (!error || typeof error !== "object") return `type=${typeof error}`;
const record = error;
const cause = record.cause && typeof record.cause === "object" ? record.cause : void 0;
const read = (value) => typeof value === "string" ? value : typeof value;
return [
`name=${read(record.name)}`,
`code=${read(record.code)}`,
`causeName=${read(cause?.name)}`,
`causeCode=${read(cause?.code)}`,
`message=${error instanceof Error ? error.message : read(record.message)}`
].join(" ");
};
return async (input, init) => {
let localServiceLease;
const request = input instanceof Request ? new Request(input, init) : void 0;
const url = request?.url ?? (input instanceof URL ? input.toString() : typeof input === "string" ? input : (() => {
throw new Error("Unsupported fetch input for transport-aware model request");
})());
const policy = resolveModelTransportSsrFPolicy({
model,
url,
allowPrivateNetwork: requestConfig.allowPrivateNetwork,
trustConfiguredBaseUrlOrigin: !requestConfig.privateNetworkExplicitlyDenied && (requestConfig.policy?.endpointClass === "custom" || requestConfig.policy?.endpointClass === "local")
});
const baseInit = (request && {
method: request.method,
headers: request.headers,
body: request.body ?? void 0,
redirect: request.redirect,
signal: request.signal,
...request.body ? { duplex: "half" } : {}
}) ?? init;
const synthesizeJsonAsSse = await requestBodyHasStreamTrue(request, baseInit);
const baseSignal = baseInit?.signal ?? void 0;
const localServiceSignal = buildModelRequestSignal(baseSignal, requestTimeoutMs);
const guardedFetchOptions = {
url,
init: baseInit,
capture: { meta: {
provider: model.provider,
api: model.api,
model: model.id
} },
dispatcherPolicy,
timeoutMs: requestTimeoutMs,
...baseSignal ? { signal: baseSignal } : {},
allowCrossOriginUnsafeRedirectReplay: false,
...policy ? { policy } : {}
};
let result;
const fetchStartedAt = Date.now();
const useEnvProxy = !dispatcherPolicy && shouldUseEnvHttpProxyForUrl(url);
emitModelTransportDebug(log$1, `[model-fetch] start provider=${model.provider} api=${model.api} model=${model.id} method=${baseInit?.method ?? "GET"} url=${formatModelTransportDebugUrl(url)} timeoutMs=${requestTimeoutMs} proxy=${dispatcherPolicy ? "configured" : useEnvProxy ? "env" : "none"} policy=${policy ? "custom" : "default"}`);
try {
localServiceLease = await ensureModelProviderLocalService(model, baseInit?.headers, localServiceSignal);
result = await fetchWithSsrFGuard(useEnvProxy ? withTrustedEnvProxyGuardedFetchMode(guardedFetchOptions) : guardedFetchOptions);
} catch (error) {
log$1.warn(`[model-fetch] error provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - fetchStartedAt} ${summarizeError(error)}`);
localServiceLease?.release();
throw error;
}
let response = result.response;
emitModelTransportDebug(log$1, `[model-fetch] response provider=${model.provider} api=${model.api} model=${model.id} status=${response.status} elapsedMs=${Date.now() - fetchStartedAt} contentType=${response.headers.get("content-type") ?? ""}`);
if (shouldBypassLongSdkRetry(response)) {
const headers = new Headers(response.headers);
headers.set("x-should-retry", "false");
response = new Response(response.body, {
status: response.status,
statusText: response.statusText,
headers
});
}
if (synthesizeJsonAsSse && options?.sanitizeSse !== false) response = await normalizeOpenAISdkStreamContentType({
response,
model,
release: result.release,
localServiceLease
});
response = buildManagedResponse(response, result.release, result.refreshTimeout, localServiceLease);
return options?.sanitizeSse === false || !shouldSanitizeOpenAISdkSseResponse(model) ? response : sanitizeOpenAISdkSseResponse(response, { synthesizeJsonAsSse });
};
}
//#endregion
//#region src/agents/responses-image-payload-sanitizer.ts
/**
* Sanitizes OpenAI Responses payloads before transport. Invalid inline images
* are replaced with text placeholders so the request remains valid and
* auditable.
*/
const IMAGE_OMITTED_TEXT = "omitted image payload: invalid inline image data";
function invalidSnakeImage() {
return {
type: "input_text",
text: `[${IMAGE_OMITTED_TEXT}]`
};
}
function sanitizeValue(value) {
if (Array.isArray(value)) return value.map(sanitizeValue);
if (!isRecord(value)) return value;
if (value.type === "input_image" && typeof value.image_url === "string") {
const imageUrl = sanitizeInlineImageDataUrl(value.image_url);
return imageUrl ? {
...value,
image_url: imageUrl
} : invalidSnakeImage();
}
const next = {};
for (const [key, child] of Object.entries(value)) next[key] = sanitizeValue(child);
return next;
}
/** Sanitize inline image fields inside a Responses API payload. */
function sanitizeResponsesImagePayload(params) {
if (!Array.isArray(params.input)) return params;
return {
...params,
input: sanitizeValue(params.input)
};
}
//#endregion
//#region src/agents/transport-message-transform.ts
const SYNTHETIC_TOOL_RESULT_APIS = new Set([
"anthropic-messages",
"openclaw-anthropic-messages-transport",
"bedrock-converse-stream",
"google-generative-ai",
"openclaw-google-generative-ai-transport",
"openai-responses",
"openai-chatgpt-responses",
"azure-openai-responses",
"openclaw-openai-responses-transport",
"openclaw-azure-openai-responses-transport"
]);
const CODEX_STYLE_ABORTED_OUTPUT_APIS = new Set([
"openai-responses",
"openai-chatgpt-responses",
"azure-openai-responses",
"openclaw-openai-responses-transport",
"openclaw-azure-openai-responses-transport"
]);
function defaultAllowSyntheticToolResults(modelApi) {
return SYNTHETIC_TOOL_RESULT_APIS.has(modelApi);
}
function isFailedAssistantTurn(message) {
if (message.role !== "assistant") return false;
return message.stopReason === "error" || message.stopReason === "aborted";
}
/** Transforms transcript messages into a provider-safe replay context. */
function transformTransportMessages(messages, model, normalizeToolCallId, options) {
const allowSyntheticToolResults = defaultAllowSyntheticToolResults(model.api);
const syntheticToolResultText = CODEX_STYLE_ABORTED_OUTPUT_APIS.has(model.api) ? "aborted" : "No result provided";
const toolCallIdMap = /* @__PURE__ */ new Map();
const replayable = messages.map((msg) => {
if (msg.role === "user") return msg;
if (msg.role === "toolResult") {
const normalizedId = toolCallIdMap.get(msg.toolCallId);
return normalizedId && normalizedId !== msg.toolCallId ? {
...msg,
toolCallId: normalizedId
} : msg;
}
if (msg.role !== "assistant") return msg;
const modelBoundThinkingReplayMode = resolveModelBoundThinkingReplayMode({
source: {
provider: msg.provider,
api: msg.api,
modelId: msg.model,
responseModelId: msg.responseModel
},
target: {
provider: model.provider,
api: model.api,
modelId: model.id,
modelParams: model.params
}
});
const isSameModel = modelBoundThinkingReplayMode === "preserve" || msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
const sourceContent = Array.isArray(msg.content) ? msg.content : msg.content != null && typeof msg.content === "object" ? [msg.content] : [];
const content = [];
for (const block of sourceContent) {
if (block.type === "thinking") {
if (modelBoundThinkingReplayMode === "drop") continue;
if (block.redacted) {
if (isSameModel) content.push(block);
continue;
}
if (isSameModel && block.thinkingSignature) {
content.push(block);
continue;
}
if (!block.thinking.trim()) continue;
content.push(isSameModel ? block : {
type: "text",
text: block.thinking
});
continue;
}
if (block.type === "text") {
content.push(isSameModel ? block : {
type: "text",
text: block.text
});
continue;
}
if (block.type !== "toolCall") {
content.push(block);
continue;
}
let normalizedToolCall = block;
if (!isSameModel && block.thoughtSignature && options?.preserveCrossModelToolCallThoughtSignature !== true) {
normalizedToolCall = { ...normalizedToolCall };
delete normalizedToolCall.thoughtSignature;
}
if ((!isSameModel || options?.normalizeSameModelToolCallIds === true) && normalizeToolCallId) {
const normalizedId = normalizeToolCallId(block.id, model, msg);
if (normalizedId !== block.id) {
toolCallIdMap.set(block.id, normalizedId);
normalizedToolCall = {
...normalizedToolCall,
id: normalizedId
};
}
}
content.push(normalizedToolCall);
}
return {
...msg,
content
};
}).filter((msg) => !isFailedAssistantTurn(msg));
if (!allowSyntheticToolResults) return replayable;
return repairToolUseResultPairing(replayable, {
erroredAssistantResultPolicy: "drop",
missingToolResultText: syntheticToolResultText
}).messages;
}
//#endregion
//#region src/agents/transport-stream-shared.ts
/**
* Shared transport-stream normalization helpers.
*
* Sanitizes provider payloads, merges metadata, and formats streamed assistant events.
*/
const EMPTY_TOOL_RESULT_TEXT = "(no output)";
function sanitizeTransportPayloadText(text) {
if (typeof text !== "string") return "";
return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
}
function sanitizeNonEmptyTransportPayloadText(text, fallback = EMPTY_TOOL_RESULT_TEXT) {
const sanitized = sanitizeTransportPayloadText(text);
return sanitized.trim().length > 0 ? sanitized : fallback;
}
function coerceTransportToolCallArguments(argumentsValue) {
if (argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue)) return argumentsValue;
if (typeof argumentsValue === "string") try {
const parsed = JSON.parse(argumentsValue);
if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
} catch {}
return {};
}
function mergeTransportHeaders(...headerSources) {
const merged = {};
for (const headers of headerSources) if (headers) Object.assign(merged, headers);
return Object.keys(merged).length > 0 ? merged : void 0;
}
function mergeTransportMetadata(payload, metadata) {
if (!metadata || Object.keys(metadata).length === 0) return payload;
const existingMetadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : void 0;
return {
...payload,
metadata: {
...existingMetadata,
...metadata
}
};
}
function createEmptyTransportUsage() {
return {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
totalTokens: 0,
cost: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: 0
}
};
}
function createWritableTransportEventStream() {
const eventStream = createAssistantMessageEventStream();
return {
eventStream,
stream: eventStream
};
}
function finalizeTransportStream(params) {
const { stream, output, signal } = params;
if (signal?.aborted) throw new Error("Request was aborted");
if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
stream.push({
type: "done",
reason: output.stopReason,
message: output
});
stream.end();
}
function readStringLikeProperty(value, key) {
if (!value || typeof value !== "object") return;
const raw = value[key];
if (typeof raw === "string") return raw.trim() || void 0;
if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
}
function readObjectProperty(value, key) {
if (!value || typeof value !== "object") return;
const raw = value[key];
return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
}
function stringifyErrorBody(value) {
if (typeof value === "string") return value;
if (value === void 0 || value === null) return;
try {
return JSON.stringify(value);
} catch {
return;
}
}
function normalizeTransportErrorBody(value) {
const text = stringifyErrorBody(value);
if (!text?.trim()) return;
return truncateErrorDetail(redactSensitiveText(text), 500);
}
function extractTransportErrorDetails(error) {
const errorObject = error && typeof error === "object" ? error : void 0;
const nestedError = readObjectProperty(errorObject, "error");
const errorCode = readStringLikeProperty(errorObject, "errorCode") ?? readStringLikeProperty(errorObject, "code") ?? readStringLikeProperty(nestedError, "code");
const errorType = readStringLikeProperty(errorObject, "errorType") ?? readStringLikeProperty(errorObject, "type") ?? readStringLikeProperty(nestedError, "type");
const errorBody = normalizeTransportErrorBody(readStringLikeProperty(errorObject, "errorBody")) ?? normalizeTransportErrorBody(readStringLikeProperty(errorObject, "body")) ?? normalizeTransportErrorBody(readObjectProperty(errorObject, "body")) ?? normalizeTransportErrorBody(nestedError);
return {
...errorCode ? { errorCode } : {},
...errorType ? { errorType } : {},
...errorBody ? { errorBody } : {}
};
}
function assignTransportErrorDetails(output, error, signal) {
output.stopReason = signal?.aborted ? "aborted" : "error";
output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
Object.assign(output, extractTransportErrorDetails(error));
}
function failTransportStream(params) {
const { stream, output, signal, error, cleanup } = params;
cleanup?.();
assignTransportErrorDetails(output, error, signal);
stream.push({
type: "error",
reason: output.stopReason,
error: output
});
stream.end();
}
//#endregion
//#region src/agents/openai-transport-stream.ts
/**
* OpenAI-compatible streaming transport.
*
* Handles Chat Completions, Responses, Azure variants, tool-call replay, reasoning events, and
* provider-specific payload policy before converting SDK streams into OpenClaw assistant events.
*/
const DEFAULT_AZURE_OPENAI_API_VERSION = "preview";
const OPENAI_CODEX_RESPONSES_EMPTY_INPUT_TEXT = " ";
const OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS = "Follow the user request.";
const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
const AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS = 3e4;
const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
const RESPONSE_FAILED_NO_DETAILS_MESSAGE = "Unknown error (no error details in response)";
const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
const OPENAI_RESPONSES_REASONING_REPLAY_META_KEY = "__openclaw_replay";
const OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY = "openclawReasoningReplay";
const OPENAI_RESPONSES_REPLAY_ITEM_ID_MAX_LENGTH = 64;
const OPENAI_CODEX_RESPONSES_PROVIDERS = new Set(["openai"]);
const log = createSubsystemLogger("openai-transport");
const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
function throwIfModelStreamAborted(signal) {
if (signal?.aborted) throw new Error("Request was aborted");
}
function createModelStreamCooperativeScheduler(signal) {
let lastYieldedAt = Date.now();
let eventsSinceYield = 0;
return { async afterEvent() {
throwIfModelStreamAborted(signal);
eventsSinceYield += 1;
const now = Date.now();
if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
eventsSinceYield = 0;
lastYieldedAt = now;
await new Promise((resolve) => {
setTimeout(resolve, 0);
});
throwIfModelStreamAborted(signal);
} };
}
function stringifyUnknown(value, fallback = "") {
if (typeof value === "string") return value;
if (typeof value === "number" || typeof value === "boolean") return String(value);
return fallback;
}
function stringifyJsonLike(value, fallback = "") {
if (typeof value === "string") return value;
if (value && typeof value === "object") return JSON.stringify(value);
if (typeof value === "number" || typeof value === "boolean") return String(value);
return fallback;
}
function getServiceTierCostMultiplier(serviceTier) {
switch (serviceTier) {
case "flex": return .5;
case "priority": return 2;
default: return 1;
}
}
function applyServiceTierPricing(usage, serviceTier) {
const multiplier = getServiceTierCostMultiplier(serviceTier);
if (multiplier === 1) return;
usage.cost.input *= multiplier;
usage.cost.output *= multiplier;
usage.cost.cacheRead *= multiplier;
usage.cost.cacheWrite *= multiplier;
usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
}
function safeDebugValue(value) {
if (typeof value === "string") return value;
if (typeof value === "number" || typeof value === "boolean") return String(value);
if (value === null) return "null";
if (value === void 0) return "undefined";
return Array.isArray(value) ? "array" : typeof value;
}
function responseInputTextChars(input) {
if (typeof input === "string") return input.length;
if (Array.isArray(input)) return input.reduce((total, item) => total + responseInputTextChars(item), 0);
if (!input || typeof input !== "object") return 0;
const record = input;
let total = 0;
if (typeof record.text === "string") total += record.text.length;
if (typeof record.content === "string") total += record.content.length;
else if (Array.isArray(record.content)) total += responseInputTextChars(record.content);
return total;
}
function responseInputRoles(input) {
if (!Array.isArray(input)) return "";
const roles = /* @__PURE__ */ new Set();
for (const item of input) if (item && typeof item === "object") {
const role = item.role;
if (typeof role === "string" && role.trim()) roles.add(role.trim());
}
return [...roles].toSorted().join(",");
}
function readResponsesToolDisplayName(tool) {
if (!tool || typeof tool !== "object") return "";
const record = tool;
if (typeof record.name === "string") return record.name;
const fn = record.function;
if (fn && typeof fn === "object" && typeof fn.name === "string") return fn.name;
return typeof record.type === "string" ? record.type : "";
}
function summarizeResponsesTools(tools) {
if (!Array.isArray(tools)) return "count=0";
const names = tools.map(readResponsesToolDisplayName).filter(Boolean);
const mode = resolveModelPayloadDebugMode();
const maxNames = mode === "tools" || mode === "full-redacted" ? names.length : 12;
const label = maxNames >= names.length ? "names" : "sample";
const shown = names.slice(0, maxNames).join(",");
return `count=${tools.length}${shown ? ` ${label}=${shown}` : ""}`;
}
function responsesPayloadToolName(tool) {
if (!isRecord(tool)) return;
if (typeof tool.name === "string") return tool.name;
const fn = tool.function;
return isRecord(fn) && typeof fn.name === "string" ? fn.name : void 0;
}
function enforceCodeModeResponsesToolSurface(payload) {
if (!isRecord(payload) || !Array.isArray(payload.tools)) return;
payload.tools = payload.tools.filter((tool) => {
const name = responsesPayloadToolName(tool);
return name === "exec" || name === "wait";
});
}
function assertCodeModeResponsesToolSurface(payload) {
if (!isRecord(payload) || !Array.isArray(payload.tools)) throw new Error("Code mode payload tool surface violation: expected exec,wait; got no tools");
const names = payload.tools.map(responsesPayloadToolName).filter((name) => typeof name === "string" && name.length > 0).toSorted((a, b) => a.localeCompare(b));
if (names.length === 2 && names[0] === "exec" && names[1] === "wait") return;
throw new Error(`Code mode payload tool surface violation: expected exec,wait; got ${names.length > 0 ? names.join(",") : "none"}`);
}
function stringifyRedactedPayload(value) {
try {
const encoded = JSON.stringify(value);
if (!encoded) return "<empty>";
const redacted = redactSensitiveText(encoded, { mode: "tools" });
return redacted.length > 8e3 ? `${redacted.slice(0, 8e3)}…<truncated>` : redacted;
} catch {
return "<unserializable>";
}
}
function stringifyRedactedEvent(value) {
const redacted = stringifyRedactedPayload(value);
return redacted.length > 2e3 ? `${redacted.slice(0, 2e3)}…<truncated>` : redacted;
}
const RESPONSE_FAILED_FAILURE_FIELD_KEYS = [
"error",
"incomplete_details",
"status_details",
"failure_reason",
"last_error",
"provider_error",
"error_details"
];
function readResponseFailedString(record, key) {
return stringifyUnknown(record?.[key]);
}
function buildResponsesFailedEventSummary(message, responseId, observation) {
const summary = { message };
if (responseId) summary.responseId = responseId;
if (observation) summary.observation = observation;
return summary;
}
function isResponseFailedIdentifierKey(key) {
const normalized = key.replace(/[-_\s]/g, "").toLowerCase();
return normalized === "requestid" || normalized === "xrequestid" || normalized === "providerrequestid" || normalized === "providerresponseid" || normalized === "litellmrequestid" || normalized.includes("request") && normalized.endsWith("id") || normalized.includes("provider") && normalized.endsWith("id");
}
function collectResponseFailedIdentifierHashes(value, opts = {}) {
const path = opts.path ?? "";
const depth = opts.depth ?? 0;
const identifierKey = opts.identifierKey ?? "";
const out = opts.out ?? [];
const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
if (out.length >= 12 || depth > 4 || !value || typeof value !== "object") return out;
if (seen.has(value)) return out;
seen.add(value);
if (Array.isArray(value)) {
for (const [index, item] of value.entries()) {
if (index >= 8 || out.length >= 12) break;
const itemString = typeof item === "string" || typeof item === "number" ? String(item).trim() : "";
if (identifierKey && isResponseFailedIdentifierKey(identifierKey) && itemString) {
out.push(`${path}[${index}]=${redactIdentifier(itemString, { len: 12 })}`);
continue;
}
collectResponseFailedIdentifierHashes(item, {
path: `${path}[${index}]`,
depth: depth + 1,
identifierKey,
out,
seen
});
}
return out;
}
for (const [key, child] of Object.entries(value)) {
if (out.length >= 12) break;
const childPath = path ? `${path}.${key}` : key;
const childString = typeof child === "string" || typeof child === "number" ? String(child).trim() : "";
if (isResponseFailedIdentifierKey(key) && childString) {
out.push(`${childPath}=${redactIdentifier(childString, { len: 12 })}`);
continue;
}
collectResponseFailedIdentifierHashes(child, {
path: childPath,
depth: depth + 1,
identifierKey: isResponseFailedIdentifierKey(key) ? key : void 0,
out,
seen
});
}
return out;
}
function redactResponseFailedDiagnosticValue(value, opts = {}) {
const key = opts.key ?? "";
const depth = opts.depth ?? 0;
if (typeof value === "string" || typeof value === "number") return key && isResponseFailedIdentifierKey(key) ? redactIdentifier(String(value), { len: 12 }) : value;
if (depth > 6 || !value || typeof value !== "object") return value;
const seen = opts.seen ?? /* @__PURE__ */ new WeakSet();
if (seen.has(value)) return "<circular>";
seen.add(value);
if (Array.isArray(value)) return value.slice(0, 16).map((item) => redactResponseFailedDiagnosticValue(item, {
key,
depth: depth + 1,
seen
}));
const out = {};
for (const [childKey, child] of Object.entries(value)) out[childKey] = redactResponseFailedDiagnosticValue(child, {
key: childKey,
depth: depth + 1,
seen
});
return out;
}
function buildResponsesFailedFailureFields(response) {
if (!response) return {};
const fields = {};
for (const key of RESPONSE_FAILED_FAILURE_FIELD_KEYS) if (response[key] !== void 0 && response[key] !== null) fields[key] = response[key];
return fields;
}
function buildResponsesFailedNoDetailsObservation(event, model, response = isRecord(event.response) ? event.response : void 0) {
const failureFields = redactResponseFailedDiagnosticValue(buildResponsesFailedFailureFields(response));
const metadataKeys = isRecord(response?.metadata) ? Object.keys(response.metadata).toSorted() : [];
const responsePreview = {
id: readResponseFailedString(response, "id"),
status: readResponseFailedString(response, "status"),
model: readResponseFailedString(response, "model"),
object: readResponseFailedString(response, "object"),
failureFields,
metadataKeys
};
return {
event: "openai_responses_response_failed_without_details",
provider: model.provider,
api: model.api,
transportModel: model.id,
providerRuntimeFailureKind: "no_error_details",
responseId: responsePreview.id,
responseStatus: responsePreview.status,
responseModel: responsePreview.model,
responseObject: responsePreview.object,
metadataKeys,
requestIdHashes: collectResponseFailedIdentifierHashes(event),
failureFieldsPreview: stringifyRedactedEvent(failureFields),
responsePreview: stringifyRedactedEvent(responsePreview)
};
}
function summarizeResponsesFailedNoDetailsObservation(observation) {
const requestIds = observation.requestIdHashes.join(",");
const metadataKeys = observation.metadataKeys.join(",");
return `responseId=${safeDebugValue(observation.responseId || void 0)} responseStatus=${safeDebugValue(observation.responseStatus || void 0)} responseModel=${safeDebugValue(observation.responseModel || void 0)} requestIds=${requestIds || "none"} metadataKeys=${metadataKeys || "none"} failureFields=${observation.failureFieldsPreview}`;
}
function normalizeResponsesFailedEvent(event, model) {
const response = isRecord(event.response) ? event.response : void 0;
const responseId = readResponseFailedString(response, "id") || void 0;
const error = isRecord(response?.error) ? response.error : void 0;
if (error) {
const code = readResponseFailedString(error, "code").trim();
const message = readResponseFailedString(error, "message").trim();
if (code || message) return buildResponsesFailedEventSummary(`${code || "unknown"}: ${message || "no message"}`, responseId);
}
const incompleteReason = readResponseFailedString(isRecord(response?.incomplete_details) ? response.incomplete_details : void 0, "reason");
if (incompleteReason) return buildResponsesFailedEventSummary(`incomplete: ${incompleteReason}`, responseId);
return buildResponsesFailedEventSummary(RESPONSE_FAILED_NO_DETAILS_MESSAGE, responseId, buildResponsesFailedNoDetailsObservation(event, model, response));
}
function logResponsesFailedNoDetails(observation) {
log.warn(`[responses] response.failed missing error details provider=${observation.provider} api=${observation.api} model=${observation.transportModel} ` + summarizeResponsesFailedNoDetailsObservation(observation), observation);
}
function summarizeResponsesPayload(params) {
if (!params || typeof params !== "object") return "payload=non-object";
const record = params;
const input = record.input;
const reasoning = record.reasoning && typeof record.reasoning === "object" ? record.reasoning : void 0;
const text = record.text && typeof record.text === "object" ? record.text : void 0;
const parts = [
`fields=${Object.keys(record).toSorted().join(",")}`,
`model=${safeDebugValue(record.model)}`,
`stream=${safeDebugValue(record.stream)}`,
`inputItems=${Array.isArray(input) ? input.length : typeof input}`,
`inputRoles=${responseInputRoles(input) || "none"}`,
`inputTextChars=${responseInputTextChars(input)}`,
`tools=${summarizeResponsesTools(record.tools)}`,
`reasoningEffort=${safeDebugValue(reasoning?.effort)}`,
`reasoningSummary=${safeDebugValue(reasoning?.summary)}`,
`textVerbosity=${safeDebugValue(text?.verbosity)}`,
`serviceTier=${safeDebugValue(record.service_tier)}`,
`store=${safeDebugValue(record.store)}`,
`promptCacheKey=${record.prompt_cache_key === void 0 ? "absent" : "present"}`,
`metadataKeys=${record.metadata && typeof record.metadata === "object" ? Object.keys(record.metadata).toSorted().join(",") : "none"}`
];
if (resolveModelPayloadDebugMode() === "full-redacted") parts.push(`payload=${stringifyRedactedPayload(record)}`);
return parts.join(" ");
}
function summarizeOpenAITransportError(error) {
if (!error || typeof error !== "object") return `type=${typeof error} message=${safeDebugValue(error)}`;
const record = error;
const cause = record.cause && typeof record.cause === "object" ? record.cause : void 0;
return [
`name=${safeDebugValue(record.name)}`,
`status=${safeDebugValue(record.status)}`,
`code=${safeDebugValue(record.code)}`,
`type=${safeDebugValue(record.type)}`,
`causeName=${safeDebugValue(cause?.name)}`,
`causeCode=${safeDebugValue(cause?.code)}`,
`message=${error instanceof Error ? error.message : safeDebugValue(error)}`
].join(" ");
}
function isInvalidEncryptedContentError(error) {
if (!error || typeof error !== "object") return false;
const record = error;
if (record.code === "invalid_encrypted_content") return true;
return typeof record.message === "string" && record.message.includes("invalid_encrypted_content");
}
function stripEncryptedContentFields(value) {
if (!value || typeof value !== "object") return {
value,
changed: false
};
if (Array.isArray(value)) {
let changed = false;
const next = value.map((item) => {
const stripped = stripEncryptedContentFields(item);
changed ||= stripped.changed;
return stripped.value;
});
return changed ? {
value: next,
changed: true
} : {
value,
changed: false
};
}
let changed = false;
const next = {};
for (const [key, child] of Object.entries(value)) {
if (key === "encrypted_content") {
changed = true;
continue;
}
const stripped = stripEncryptedContentFields(child);
changed ||= stripped.changed;
next[key] = stripped.value;
}
return changed ? {
value: next,
changed: true
} : {
value,
changed: false
};
}
function stripResponsesRequestEncryptedContent(params) {
const stripped = stripEncryptedContentFields(params.input);
if (!stripped.changed) return params;
return {
...params,
input: stripped.value
};
}
function hashOptionalReplayContextValue(value) {
const normalized = value?.trim();
return normalized ? shortHash(normalized) : void 0;
}
function buildOpenAIResponsesReplayContext(model, options) {
return {
provider: model.provider,
api: model.api,
model: model.id,
baseUrlHash: hashOptionalReplayContextValue(model.baseUrl),
sessionHash: hashOptionalReplayContextValue(options?.sessionId),
authProfileHash: hashOptionalReplayContextValue(options?.authProfileId)
};
}
function buildOpenAIResponsesReasoningReplayMetadata(model, options) {
return {
v: 1,
source: "openai-responses",
...buildOpenAIResponsesReplayContext(model, options)
};
}
function isOpenAIResponsesReasoningReplayMetadata(value) {
if (!value || typeof value !== "object") return false;
const record = value;
return record.v === 1 && record.source === "openai-responses" && typeof record.provider === "string" && typeof record.api === "string" && typeof record.model === "string" && (record.baseUrlHash === void 0 || typeof record.baseUrlHash === "string") && (record.sessionHash === void 0 || typeof record.sessionHash === "string") && (record.authProfileHash === void 0 || typeof record.authProfileHash === "string");
}
function encryptedReasoningReplayMetadataMatches(metadata, context) {
if (!metadata) return false;
return metadata.provider === context.provider && metadata.api === context.api && metadata.model === context.model && metadata.baseUrlHash === context.baseUrlHash && metadata.sessionHash === context.sessionHash && metadata.authProfileHash === context.authProfileHash;
}
function readOpenAIResponsesReasoningReplayBlockMetadata(block) {
const value = block[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY];
return isOpenAIResponsesReasoningReplayMetadata(value) ? value : void 0;
}
function normalizeOpenAIResponsesReasoningReplayItem(item) {
const record = item;
if (record.type !== "reasoning" || Array.isArray(record.summary)) return item;
return {
...record,
summary: []
};
}
function prepareOpenAIResponsesReasoningItemForReplay(item, context, blockMetadata) {
const { [OPENAI_RESPONSES_REASONING_REPLAY_META_KEY]: rawMetadata, ...rest } = item;
if (!("encrypted_content" in rest)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
if (encryptedReasoningReplayMetadataMatches(blockMetadata ?? (isOpenAIResponsesReasoningReplayMetadata(rawMetadata) ? rawMetadata : void 0), context)) return normalizeOpenAIResponsesReasoningReplayItem(rest);
return normalizeOpenAIResponsesReasoningReplayItem(stripEncryptedContentFields(rest).value);
}
async function createResponsesStreamWithEncryptedContentRetry(params) {
try {
return await params.client.responses.create(params.request, params.requestOptions);
} catch (error) {
const retryRequest = stripResponsesRequestEncryptedContent(params.request);
if (!isInvalidEncryptedContentError(error) || retryRequest === params.request) throw error;
log.warn(`[responses] retrying without encrypted reasoning content provider=${params.model.provider} api=${params.model.api} model=${params.model.id}`);
return await params.client.responses.create(retryRequest, params.requestOptions);
}
}
function resolveAzureOpenAIApiVersion(env = process.env) {
return env.AZURE_OPENAI_API_VERSION?.trim() || DEFAULT_AZURE_OPENAI_API_VERSION;
}
function shortHash(value) {
return createHash("sha256").update(value).digest("hex").slice(0, 16);
}
function normalizeResponsesReplayItemId(id, prefix) {
if (!id) return;
if (id.length <= OPENAI_RESPONSES_REPLAY_ITEM_ID_MAX_LENGTH) return id;
return `${prefix}_${shortHash(id)}`;
}
function isSafeResponsesReplayItemId(id) {
return typeof id === "string" && id.length > 0 && id.length <= OPENAI_RESPONSES_REPLAY_ITEM_ID_MAX_LENGTH;
}
function encodeTextSignatureV1(id, phase) {
return JSON.stringify({
v: 1,
id,
...phase ? { phase } : {}
});
}
function parseTextSignature(signature) {
if (!signature) return;
if (signature.startsWith("{")) try {
const parsed = JSON.parse(signature);
if (parsed.v === 1) {
const id = typeof parsed.id === "string" ? parsed.id : void 0;
const phase = parsed.phase === "commentary" || parsed.phase === "final_answer" ? parsed.phase : void 0;
if (id !== void 0 || phase !== void 0) return {
id,
phase
};
return;
}
} catch {}
return { id: signature };
}
function buildResponsesInputMessage(role, content) {
return {
type: "message",
role,
content
};
}
function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
const messages = [];
const shouldReplayReasoningItems = options?.replayReasoningItems ?? true;
const shouldReplayResponsesItemIds = options?.replayResponsesItemIds ?? true;
const replayContext = buildOpenAIResponsesReplayContext(model, {
sessionId: options?.sessionId,
authProfileId: options?.authProfileId
});
const shouldNormalizeSameModelToolCallIds = model.provider === "github-copilot";
const sanitizeIdPart = (part) => part.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+$/, "");
const normalizeIdPart = (part) => {
const sanitized = sanitizeIdPart(part);
return (sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized).replace(/_+$/, "");
};
const buildForeignResponsesItemId = (itemId) => {
const normalized = `fc_${shortHash(itemId)}`;
return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
};
const buildSameProviderCopilotResponsesItemId = (itemId) => {
const sanitized = sanitizeIdPart(itemId);
const candidate = sanitized.startsWith("fc_") ? sanitized : `fc_${sanitized}`;
return candidate.length > 64 ? buildForeignResponsesItemId(itemId) : candidate;
};
const normalizeToolCallId = (id, _targetModel, source) => {
if (!allowedToolCallProviders.has(model.provider)) return normalizeIdPart(id);
if (!id.includes("|")) return normalizeIdPart(id);
const [callId, itemId] = id.split("|");
const normalizedCallId = normalizeIdPart(callId);
let normalizedItemId = source.provider !== model.provider || source.api !== model.api ? buildForeignResponsesItemId(itemId) : model.provider === "github-copilot" ? buildSameProviderCopilotResponsesItemId(itemId) : normalizeIdPart(itemId);
if (!normalizedItemId.startsWith("fc_")) normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
return `${normalizedCallId}|${normalizedItemId}`;
};
const transformedMessages = transformTransportMessages(context.messages, model, normalizeToolCallId, { normalizeSameModelToolCallIds: shouldNormalizeSameModelToolCallIds });
if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) messages.push(buildResponsesInputMessage(model.reasoning && options?.supportsDeveloperRole !== false ? "developer" : "system", [{
type: "input_text",
text: sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt))
}]));
let msgIndex = 0;
for (const msg of transformedMessages) {
if (msg.role === "user") if (typeof msg.content === "string") messages.push(buildResponsesInputMessage("user", [{
type: "input_text",
text: sanitizeTransportPayloadText(msg.content)
}]));
else {
const content = msg.content.map((item) => item.type === "text" ? {
type: "input_text",
text: sanitizeTransportPayloadText(item.text)
} : {
type: "input_image",
detail: "auto",
image_url: `data:${item.mimeType};base64,${item.data}`
}).filter((item) => model.input.includes("image") || item.type !== "input_image");
if (content.length > 0) messages.push(buildResponsesInputMessage("user", content));
}
else if (msg.role === "assistant") {
const output = [];
let textFallbackOrdinal = 0;
let previousReplayItemWasReasoning = false;
const isDifferentModel = msg.model !== model.id && msg.provider === model.provider && msg.api === model.api;
for (const block of msg.content) if (block.type === "thinking") {
if (shouldReplayReasoningItems && block.thinkingSignature && block.thinkingSignature.startsWith("{")) {
const replayableReasoningItem = prepareOpenAIResponsesReasoningItemForReplay(JSON.parse(block.thinkingSignature), replayContext, readOpenAIResponsesReasoningReplayBlockMetadata(block));
if (!shouldReplayResponsesItemIds) delete replayableReasoningItem.id;
if (shouldReplayResponsesItemIds && model.provider === "github-copilot" && !isSafeResponsesReplayItemId(replayableReasoningItem.id)) continue;
output.push(replayableReasoningItem);
previousReplayItemWasReasoning = true;
}
} else if (block.type === "text") {
const textSignature = parseTextSignature(block.textSignature);
let msgId = resolveReplayableResponsesMessageId({
replayResponsesItemIds: shouldReplayResponsesItemIds,
textSignatureId: textSignature?.id,
fallbackId: `msg_${msgIndex}`,
fallbackOrdinal: textFallbackOrdinal,
previousReplayItemWasReasoning
});
if (!textSignature?.id) textFallbackOrdinal += 1;
msgId = normalizeResponsesReplayItemId(msgId, "msg");
const messageItem = {
type: "message",
role: "assistant",
content: [{
type: "output_text",
text: sanitizeTransportPayloadText(block.text),
annotations: []
}],
status: "completed",
...msgId ? { id: msgId } : {},
phase: textSignature?.phase
};
output.push(messageItem);
previousReplayItemWasReasoning = false;
} else if (block.type === "toolCall") {
const [callId, itemIdRaw] = block.id.split("|");
const itemId = shouldReplayResponsesItemIds && !(isDifferentModel && itemIdRaw?.startsWith("fc_")) ? itemIdRaw : void 0;
output.push({
type: "function_call",
...itemId ? { id: itemId } : {},
call_id: callId,
name: block.name,
arguments: typeof block.arguments === "string" ? block.arguments : JSON.stringify(block.arguments ?? {})
});
previousReplayItemWasReasoning = false;
}
if (output.length > 0) messages.push(...output);
} else if (msg.role === "toolResult") {
const textResult = msg.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
const hasImages = msg.content.some((item) => item.type === "image");
const [callId] = msg.toolCallId.split("|");
messages.push({
type: "function_call_output",
call_id: callId,
output: hasImages && model.input.includes("image") ? [...textResult ? [{
type: "input_text",
text: sanitizeTransportPayloadText(textResult)
}] : [], ...msg.content.filter((item) => item.type === "image").map((item) => ({
type: "input_image",
detail: "auto",
image_url: `data:${item.mimeType};base64,${item.data}`
}))] : sanitizeTransportPayloadText(textResult || "(see attached image)")
});
}
msgIndex += 1;
}
return messages;
}
function convertResponsesTools(tools, model, options) {
const strict = resolveOpenAIStrictToolFlagWithDiagnostics(tools, options?.strict, {
transport: "responses",
model
});
return sortTransportToolsByName(tools).map((tool) => {
const result = {
type: "function",
name: tool.name,
description: tool.description,
parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
};
if (strict !== void 0) result.strict = strict;
return result;
});
}
function resolveOpenAIStrictToolFlagWithDiagnostics(tools, strictSetting, context) {
const strict = resolveOpenAIStrictToolFlagForInventory(tools, strictSetting);
if (strictSetting === true && strict === false && log.isEnabled("debug", "any")) {
const diagnostics = findOpenAIStrictToolSchemaDiagnostics(tools);
if (!shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context)) return strict;
const sample = diagnostics.slice(0, 5).map((entry) => ({
tool: entry.toolName ?? `tool[${entry.toolIndex}]`,
violations: entry.violations.slice(0, 8)
}));
log.debug(`OpenAI ${context.transport} tool schema strict mode downgraded to strict=false for ${context.model.provider ?? "unknown"}/${context.model.id ?? "unknown"} because ${diagnostics.length} tool schema(s) are not strict-compatible`, {
transport: context.transport,
provider: context.model.provider,
model: context.model.id,
incompatibleToolCount: diagnostics.length,
sample
});
}
return strict;
}
function buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context) {
return createHash("sha256").update(JSON.stringify({
transport: context.transport,
provider: context.model.provider ?? null,
model: context.model.id ?? null,
diagnostics: diagnostics.map((entry) => ({
toolIndex: entry.toolIndex,
toolName: entry.toolName ?? null,
violations: entry.violations
}))
})).digest("hex");
}
function shouldLogOpenAIStrictToolDowngradeDiagnostic(diagnostics, context) {
const key = buildOpenAIStrictToolDowngradeDiagnosticKey(diagnostics, context);
if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.has(key)) return false;
if (loggedOpenAIStrictToolDowngradeDiagnosticKeys.size >= MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS) loggedOpenAIStrictToolDowngradeDiagnosticKeys.clear();
loggedOpenAIStrictToolDowngradeDiagnosticKeys.add(key);
return true;
}
function createResponsesFirstEventTimeoutError(model, timeoutMs) {
return /* @__PURE__ */ new Error(`Azure OpenAI Responses stream did not deliver a first event within ${timeoutMs}ms after HTTP streaming headers. provider=${model.provider} model=${model.id}. The provider may be stalled while parsing the tool payload; retry with a smaller tool surface or enable OPENCLAW_DEBUG_MODEL_PAYLOAD=tools to inspect exposed tools.`);
}
function withResponsesFirstEventTimeout(openaiStream, model, timeoutMs) {
if (timeoutMs === void 0 || timeoutMs <= 0 || !Number.isFinite(timeoutMs)) return openaiStream;
return { async *[Symbol.asyncIterator]() {
const iterator = openaiStream[Symbol.asyncIterator]();
let timer;
const clear = () => {
if (timer) {
clearTimeout(timer);
timer = void 0;
}
};
try {
const first = await new Promise((resolve, reject) => {
timer = setTimeout(() => reject(createResponsesFirstEventTimeoutError(model, timeoutMs)), timeoutMs);
iterator.next().then(resolve, reject);
}).finally(clear);
if (first.done) return;
yield first.value;
for (;;) {
const next = await iterator.next();
if (next.done) return;
yield next.value;
}
} catch (error) {
iterator.return?.().catch(() => void 0);
throw error;
} finally {
clear();
}
} };
}
async function processResponsesStream(openaiStream, output, stream, model, options) {
let currentItem = null;
let currentBlock = null;
const streamStartedAt = Date.now();
let eventCount = 0;
const eventTypes = /* @__PURE__ */ new Map();
const sseDebugMode = resolveModelSseDebugMode();
const blockIndex = () => output.content.length - 1;
const appendCompletedResponseTextItem = (item) => {
const text = readResponsesOutputMessageText(item);
if (!text) return;
const block = {
type: "text",
text,
textSignature: encodeTextSignatureV1(stringifyUnknown(item.id), item.phase ?? void 0)
};
output.content.push(block);
stream.push({
type: "text_start",
contentIndex: blockIndex(),
partial: output
});
stream.push({
type: "text_end",
contentIndex: blockIndex(),
content: text,
partial: output
});
};
const appendCompletedResponseToolCallItem = (item) => {
const args = parseStreamingJson(stringifyJsonLike(item.arguments, "{}"));
const block = {
type: "toolCall",
id: `${stringifyUnknown(item.call_id)}|${stringifyUnknown(item.id)}`,
name: stringifyUnknown(item.name),
arguments: args,
partialJson: stringifyJsonLike(item.arguments, "{}")
};
output.content.push(block);
stream.push({
type: "toolcall_start",
contentIndex: blockIndex(),
partial: output
});
stream.push({
type: "toolcall_end",
contentIndex: blockIndex(),
toolCall: {
type: "toolCall",
id: block.id,
name: block.name,
arguments: args
},
partial: output
});
};
const backfillCompletedResponseOutput = (response) => {
if (output.content.length > 0 || !Array.isArray(response?.output)) return;
for (const rawItem of response.output) {
if (!isRecord(rawItem)) continue;
if (rawItem.type === "message") appendCompletedResponseTextItem(rawItem);
else if (rawItem.type === "function_call") appendCompletedResponseToolCallItem(rawItem);
}
};
const guardedStream = withResponsesFirstEventTimeout(openaiStream, model, options?.firstEventTimeoutMs);
const cooperativeScheduler = createModelStreamCooperativeScheduler(options?.signal);
for await (const rawEvent of guardedStream) {
throwIfModelStreamAborted(options?.signal);
const event = rawEvent;
const type = stringifyUnknown(event.type);
eventCount += 1;
eventTypes.set(type, (eventTypes.get(type) ?? 0) + 1);
if (eventCount === 1) emitModelTransportDebug(log, `[responses] first_event provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - streamStartedAt} type=${type}`);
if (sseDebugMode === "peek" && eventCount <= 5) emitModelTransportDebug(log, `[responses] event_peek provider=${model.provider} api=${model.api} model=${model.id} index=${eventCount} type=${type} event=${stringifyRedactedEvent(event)}`);
if (type === "response.created") output.responseId = stringifyUnknown(event.response?.id);
else if (type === "response.output_item.added") {
const item = event.item;
if (item.type === "reasoning") {
currentItem = item;
currentBlock = {
type: "thinking",
thinking: ""
};
output.content.push(currentBlock);
stream.push({
type: "thinking_start",
contentIndex: blockIndex(),
partial: output
});
} else if (item.type === "message") {
currentItem = item;
currentBlock = {
type: "text",
text: ""
};
output.content.push(currentBlock);
stream.push({
type: "text_start",
contentIndex: blockIndex(),
partial: output
});
} else if (item.type === "function_call") {
currentItem = item;
currentBlock = {
type: "toolCall",
id: `${stringifyUnknown(item.call_id)}|${stringifyUnknown(item.id)}`,
name: stringifyUnknown(item.name),
arguments: {},
partialJson: stringifyJsonLike(item.arguments)
};
output.content.push(currentBlock);
stream.push({
type: "toolcall_start",
contentIndex: blockIndex(),
partial: output
});
}
} else if (type === "response.reasoning_summary_text.delta") {
if (currentItem?.type === "reasoning" && currentBlock?.type === "thinking") {
currentBlock.thinking = `${stringifyUnknown(currentBlock.thinking)}${stringifyUnknown(event.delta)}`;
stream.push({
type: "thinking_delta",
contentIndex: blockIndex(),
delta: stringifyUnknown(event.delta),
partial: output
});
}
} else if (isResponsesTextDeltaEventType(type) || type === "response.refusal.delta") {
if (currentItem?.type === "message" && currentBlock?.type === "text") {
currentBlock.text = `${stringifyUnknown(currentBlock.text)}${stringifyUnknown(event.delta)}`;
stream.push({
type: "text_delta",
contentIndex: blockIndex(),
delta: stringifyUnknown(event.delta)
});
}
} else if (type === "response.function_call_arguments.delta") {
if (currentItem?.type === "function_call" && currentBlock?.type === "toolCall") {
currentBlock.partialJson = `${stringifyJsonLike(currentBlock.partialJson)}${stringifyJsonLike(event.delta)}`;
currentBlock.arguments = parseStreamingJson(stringifyJsonLike(currentBlock.partialJson));
stream.push({
type: "toolcall_delta",
contentIndex: blockIndex(),
delta: stringifyJsonLike(event.delta),
partial: output
});
}
} else if (type === "response.output_item.done") {
const item = event.item;
if (item.type === "reasoning" && currentBlock?.type === "thinking") {
const summary = Array.isArray(item.summary) ? item.summary.map((part) => {
return part.text ?? "";
}).join("\n\n") : "";
currentBlock.thinking = summary;
currentBlock.thinkingSignature = JSON.stringify(item);
if ("encrypted_content" in item) currentBlock[OPENAI_RESPONSES_REASONING_REPLAY_BLOCK_META_KEY] = buildOpenAIResponsesReasoningReplayMetadata(model, {
authProfileId: options?.authProfileId,
sessionId: options?.sessionId
});
stream.push({
type: "thinking_end",
contentIndex: blockIndex(),
content: stringifyUnknown(currentBlock.thinking),
partial: output
});
currentBlock = null;
} else if (item.type === "message" && currentBlock?.type === "text") {
const content = Array.isArray(item.content) ? item.content : [];
currentBlock.text = content.map((part) => {
const contentPart = part;
return isResponsesTextContentPartType(contentPart.type) ? contentPart.text ?? "" : contentPart.refusal ?? "";
}).join("");
currentBlock.textSignature = encodeTextSignatureV1(stringifyUnknown(item.id), item.phase ?? void 0);
stream.push({
type: "text_end",
contentIndex: blockIndex(),
content: stringifyUnknown(currentBlock.text),
partial: output
});
currentBlock = null;
} else if (item.type === "function_call") {
const args = currentBlock?.type === "toolCall" && currentBlock.partialJson ? parseStreamingJson(stringifyJsonLike(currentBlock.partialJson, "{}")) : parseStreamingJson(stringifyJsonLike(item.arguments, "{}"));
stream.push({
type: "toolcall_end",
contentIndex: blockIndex(),
toolCall: {
type: "toolCall",
id: `${stringifyUnknown(item.call_id)}|${stringifyUnknown(item.id)}`,
name: stringifyUnknown(item.name),
arguments: args
},
partial: output
});
currentBlock = null;
}
} else if (type === "response.completed") {
const response = event.response;
if (typeof response?.id === "string") output.responseId = response.id;
backfillCompletedResponseOutput(response);
const usage = response?.usage;
if (usage) {
const cachedTokens = usage.input_tokens_details?.cached_tokens || 0;
const inputTokens = usage.input_tokens || 0;
const outputTokens = usage.output_tokens || 0;
const reasoningTokens = usage.output_tokens_details?.reasoning_tokens;
const input = Math.max(0, inputTokens - cachedTokens);
output.usage = {
input,
output: outputTokens,
cacheRead: cachedTokens,
cacheWrite: 0,
...typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
totalTokens: input + outputTokens + cachedTokens,
cost: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: 0
}
};
}
calculateCost(model, output.usage);
if (options?.applyServiceTierPricing) options.applyServiceTierPricing(output.usage, response?.service_tier ?? options.serviceTier);
output.stopReason = mapResponsesStopReason(response?.status);
if (output.content.some((block) => block.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
} else if (type === "error") throw new Error(`Error Code ${stringifyUnknown(event.code, "unknown")}: ${stringifyUnknown(event.message, "Unknown error")}`);
else if (type === "response.failed") {
const failure = normalizeResponsesFailedEvent(event, model);
if (failure.responseId) output.responseId = failure.responseId;
if (failure.observation) logResponsesFailedNoDetails(failure.observation);
throw new Error(failure.message);
}
await cooperativeScheduler.afterEvent();
}
const eventTypeSummary = [...eventTypes.entries()].slice(0, 12).map(([eventType, count]) => `${eventType}:${count}`).join(",");
emitModelTransportDebug(log, `[responses] stream_done provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - streamStartedAt} events=${eventCount} types=${eventTypeSummary} stopReason=${output.stopReason ?? "unset"} contentBlocks=${output.content.length}`);
}
function mapResponsesStopReason(status) {
if (!status) return "stop";
switch (status) {
case "completed": return "stop";
case "incomplete": return "length";
case "failed":
case "cancelled": return "error";
case "in_progress":
case "queued": return "stop";
default: throw new Error(`Unhandled stop reason: ${status}`);
}
}
function readResponsesOutputMessageText(item) {
return (Array.isArray(item.content) ? item.content : []).map((part) => {
if (!isRecord(part)) return "";
if (part.type === "output_text" || part.type === "text") return stringifyUnknown(part.text);
if (part.type === "refusal") return stringifyUnknown(part.refusal);
return "";
}).join("");
}
function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders) {
const providerHeaders = { ...model.headers };
if (model.provider === "github-copilot") Object.assign(providerHeaders, buildCopilotDynamicHeaders({
messages: context.messages,
hasImages: hasCopilotVisionInput(context.messages)
}));
const callerHeaders = {
...optionHeaders,
...turnHeaders
};
return resolveProviderRequestPolicyConfig({
provider: model.provider,
api: model.api,
baseUrl: model.baseUrl,
capability: "llm",
transport: "stream",
providerHeaders,
callerHeaders: Object.keys(callerHeaders).length > 0 ? callerHeaders : void 0,
precedence: "caller-wins"
}).headers ?? {};
}
function resolveProviderTransportTurnState(model, params) {
const normalizedProvider = model.provider.trim().toLowerCase();
const allowRuntimePluginLoad = normalizedProvider === "openai" || normalizedProvider === "azure-openai" || normalizedProvider === "azure-openai-responses";
return resolveProviderTransportTurnStateWithPlugin({
provider: model.provider,
modelId: model.id,
allowRuntimePluginLoad,
context: {
provider: model.provider,
modelId: model.id,
model,
sessionId: params.sessionId,
turnId: params.turnId,
attempt: params.attempt,
transport: params.transport
}
});
}
function resolveOpenAISdkTimeoutMs(model) {
return resolveModelRequestTimeoutMs(model, void 0);
}
function buildOpenAISdkClientOptions(model) {
const timeout = resolveOpenAISdkTimeoutMs(model);
return timeout === void 0 ? {} : { timeout };
}
function buildOpenAISdkRequestOptions(model, signal) {
const timeout = resolveOpenAISdkTimeoutMs(model);
if (timeout === void 0 && !signal) return;
return {
...signal ? { signal } : {},
...timeout !== void 0 ? { timeout } : {}
};
}
function createOpenAIResponsesClient(model, context, apiKey, optionHeaders, turnHeaders) {
return new OpenAI({
apiKey,
baseURL: model.baseUrl,
dangerouslyAllowBrowser: true,
defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
fetch: buildGuardedModelFetch(model),
...buildOpenAISdkClientOptions(model)
});
}
function createOpenAIResponsesTransportStreamFn() {
return (model, context, options) => {
const responsesOptions = options;
const eventStream = createAssistantMessageEventStream();
const stream = eventStream;
(async () => {
const output = {
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: "stop",
timestamp: Date.now()
};
try {
const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
const turnState = resolveProviderTransportTurnState(model, {
sessionId: options?.sessionId,
turnId: randomUUID(),
attempt: 1,
transport: "stream"
});
const client = createOpenAIResponsesClient(model, context, apiKey, options?.headers, turnState?.headers);
let params = buildOpenAIResponsesParams(model, context, responsesOptions, turnState?.metadata);
const nextParams = await options?.onPayload?.(params, model);
if (nextParams !== void 0) params = nextParams;
if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
params = sanitizeOpenAICodexResponsesParams(model, params);
params = sanitizeResponsesImagePayload(params);
if (options?.openclawCodeModeToolSurface === true) {
enforceCodeModeResponsesToolSurface(params);
assertCodeModeResponsesToolSurface(params);
}
const requestStartedAt = Date.now();
const requestOptions = buildOpenAISdkRequestOptions(model, options?.signal);
emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
const responseStream = await createResponsesStreamWithEncryptedContentRetry({
client,
request: params,
requestOptions,
model
});
emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - requestStartedAt}`);
stream.push({
type: "start",
partial: output
});
await processResponsesStream(responseStream, output, stream, model, {
serviceTier: responsesOptions?.serviceTier,
applyServiceTierPricing,
signal: options?.signal,
authProfileId: responsesOptions?.authProfileId,
sessionId: options?.sessionId
});
if (options?.signal?.aborted) throw new Error("Request was aborted");
if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
stream.push({
type: "done",
reason: output.stopReason,
message: output
});
stream.end();
} catch (error) {
log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error));
assignTransportErrorDetails(output, error, options?.signal);
stream.push({
type: "error",
reason: output.stopReason,
error: output
});
stream.end();
}
})();
return eventStream;
};
}
function resolveCacheRetention(cacheRetention) {
if (cacheRetention === "short" || cacheRetention === "long" || cacheRetention === "none") return cacheRetention;
if (typeof process !== "undefined" && process.env.OPENCLAW_CACHE_RETENTION === "long") return "long";
return "short";
}
function resolvePromptCacheKey(options, cacheRetention) {
if (cacheRetention === "none") return;
return clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId);
}
function getPromptCacheRetention(baseUrl, cacheRetention) {
if (cacheRetention !== "long") return;
return baseUrl?.includes("api.openai.com") ? "24h" : void 0;
}
function resolveOpenAIReasoningEffort(options) {
return normalizeOpenAIReasoningEffort(options?.reasoningEffort ?? options?.reasoning ?? "high");
}
function hasResponsesWebSearchTool(tools) {
if (!Array.isArray(tools)) return false;
return tools.some((tool) => {
if (!isRecord(tool)) return false;
if (tool.type === "web_search") return true;
if (tool.type === "function" && tool.name === "web_search") return true;
const fn = tool.function;
return isRecord(fn) && fn.name === "web_search";
});
}
function raiseMinimalReasoningForResponsesWebSearch(params) {
if (params.effort !== "minimal" || !hasResponsesWebSearchTool(params.tools)) return params.effort;
for (const effort of [
"low",
"medium",
"high"
]) {
const resolved = resolveOpenAIReasoningEffortForModel({
model: params.model,
effort
});
if (resolved && resolved !== "none" && resolved !== "minimal") return resolved;
}
return params.effort;
}
function isOpenAICodexResponsesModel(model) {
return OPENAI_CODEX_RESPONSES_PROVIDERS.has(model.provider) && (model.api === "openai-chatgpt-responses" || model.api === "openclaw-openai-responses-transport");
}
function isNativeOpenAICodexResponsesBaseUrl(baseUrl) {
const trimmed = typeof baseUrl === "string" ? baseUrl.trim() : "";
if (!trimmed) return false;
try {
const url = new URL(trimmed);
if (url.protocol !== "http:" && url.protocol !== "https:") return false;
if (url.hostname.toLowerCase() !== "chatgpt.com") return false;
const pathname = url.pathname.replace(/\/+$/u, "").toLowerCase();
return [
"/backend-api",
"/backend-api/v1",
"/backend-api/codex",
"/backend-api/codex/v1"
].includes(pathname);
} catch {
return false;
}
}
function usesNativeOpenAICodexResponsesBackend(model) {
return isOpenAICodexResponsesModel(model) && isNativeOpenAICodexResponsesBaseUrl(model.baseUrl);
}
const OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS = [
"max_output_tokens",
"metadata",
"prompt_cache_retention",
"service_tier",
"temperature",
"top_p"
];
function stripOpenAICodexResponsesUnsupportedTextFields(params) {
const text = params.text;
if (!text || typeof text !== "object" || Array.isArray(text)) return;
const sanitizedText = { ...text };
delete sanitizedText.format;
if (Object.keys(sanitizedText).length > 0) params.text = sanitizedText;
else delete params.text;
}
function sanitizeOpenAICodexResponsesParams(model, params) {
if (!usesNativeOpenAICodexResponsesBackend(model)) return params;
for (const key of OPENAI_CODEX_RESPONSES_UNSUPPORTED_PARAMS) delete params[key];
stripOpenAICodexResponsesUnsupportedTextFields(params);
return params;
}
function buildOpenAICodexResponsesInstructions(context) {
if (!context.systemPrompt) return;
return sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(context.systemPrompt));
}
function resolveOpenAICodexResponsesInstructions(model, context) {
const instructions = buildOpenAICodexResponsesInstructions(context);
if (instructions && instructions.trim().length > 0) return instructions;
return usesNativeOpenAICodexResponsesBackend(model) ? OPENAI_CODEX_RESPONSES_DEFAULT_INSTRUCTIONS : void 0;
}
function ensureOpenAICodexResponsesInput(messages, context) {
if (messages.length > 0 || !context.systemPrompt) return;
if (!buildOpenAICodexResponsesInstructions(context)) throw new Error("OpenAI Codex Responses requires non-empty input when only systemPrompt is provided.");
messages.push(buildResponsesInputMessage("user", [{
type: "input_text",
text: OPENAI_CODEX_RESPONSES_EMPTY_INPUT_TEXT
}]));
}
function resolveOpenAIResponsesTextFormat(responseFormat) {
if (responseFormat.type === "json_schema" && responseFormat.json_schema && typeof responseFormat.json_schema === "object" && !Array.isArray(responseFormat.json_schema)) return {
...responseFormat.json_schema,
type: "json_schema"
};
return responseFormat;
}
function buildOpenAIResponsesParams(model, context, options, metadata) {
const isCodexResponses = isOpenAICodexResponsesModel(model);
const isNativeCodexResponses = usesNativeOpenAICodexResponsesBackend(model);
const compat = getCompat(model);
const supportsDeveloperRole = typeof compat.supportsDeveloperRole === "boolean" ? compat.supportsDeveloperRole : void 0;
const payloadPolicy = resolveOpenAIResponsesPayloadPolicy(model, { storeMode: "disable" });
const policyAllowsReplayIds = payloadPolicy.explicitStore !== false;
const replayResponsesItemIds = !isNativeCodexResponses && (options?.replayResponsesItemIds ?? policyAllowsReplayIds);
const messages = convertResponsesMessages(model, context, new Set([
"openai",
"opencode",
"azure-openai-responses",
"github-copilot"
]), {
includeSystemPrompt: !isCodexResponses,
supportsDeveloperRole,
replayReasoningItems: true,
replayResponsesItemIds,
authProfileId: options?.authProfileId,
sessionId: options?.sessionId
});
if (isCodexResponses) ensureOpenAICodexResponsesInput(messages, context);
const cacheRetention = resolveCacheRetention(options?.cacheRetention);
const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
const params = {
model: model.id,
input: messages,
stream: true,
prompt_cache_key: promptCacheKey,
prompt_cache_retention: getPromptCacheRetention(model.baseUrl, cacheRetention),
...isCodexResponses ? { instructions: resolveOpenAICodexResponsesInstructions(model, context) } : {},
...metadata ? { metadata } : {}
};
const effectiveMaxTokens = options?.maxTokens || model.maxTokens;
if (effectiveMaxTokens) params.max_output_tokens = effectiveMaxTokens;
if (options?.temperature !== void 0) params.temperature = options.temperature;
if (options?.topP !== void 0) params.top_p = options.topP;
if (options?.responseFormat !== void 0) params.text = {
...params.text,
format: resolveOpenAIResponsesTextFormat(options.responseFormat)
};
if (options?.serviceTier !== void 0 && payloadPolicy.allowsServiceTier) params.service_tier = options.serviceTier;
if (context.tools) {
params.tools = convertResponsesTools(context.tools, model, { strict: resolveOpenAIStrictToolSetting(model, { transport: "stream" }) });
if (options?.toolChoice) params.tool_choice = options.toolChoice;
}
if (model.reasoning) {
if (options?.reasoningEffort || options?.reasoning || options?.reasoningSummary) {
const resolvedReasoningEffort = resolveOpenAIReasoningEffortForModel({
model,
effort: resolveOpenAIReasoningEffort(options)
});
const reasoningEffort = resolvedReasoningEffort ? raiseMinimalReasoningForResponsesWebSearch({
model,
effort: resolvedReasoningEffort,
tools: params.tools
}) : void 0;
if (reasoningEffort) {
params.reasoning = {
effort: reasoningEffort,
...reasoningEffort === "none" ? {} : { summary: options?.reasoningSummary || "auto" }
};
if (reasoningEffort !== "none") params.include = ["reasoning.encrypted_content"];
}
} else if (model.provider !== "github-copilot") {
const reasoningEffort = resolveOpenAIReasoningEffortForModel({
model,
effort: "none"
});
if (reasoningEffort) params.reasoning = { effort: reasoningEffort };
}
}
applyOpenAIResponsesPayloadPolicy(params, payloadPolicy);
return sanitizeOpenAICodexResponsesParams(model, params);
}
function createAzureOpenAIResponsesTransportStreamFn() {
return (model, context, options) => {
const responsesOptions = options;
const eventStream = createAssistantMessageEventStream();
const stream = eventStream;
(async () => {
const output = {
role: "assistant",
content: [],
api: "azure-openai-responses",
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: "stop",
timestamp: Date.now()
};
try {
const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
const turnState = resolveProviderTransportTurnState(model, {
sessionId: options?.sessionId,
turnId: randomUUID(),
attempt: 1,
transport: "stream"
});
const client = createAzureOpenAIClient(model, context, apiKey, options?.headers, turnState?.headers);
let params = buildAzureOpenAIResponsesParams(model, context, responsesOptions, resolveAzureDeploymentName(model), turnState?.metadata);
const nextParams = await options?.onPayload?.(params, model);
if (nextParams !== void 0) params = nextParams;
if (!isOpenAICodexResponsesModel(model)) params = mergeTransportMetadata(params, turnState?.metadata);
params = sanitizeOpenAICodexResponsesParams(model, params);
params = sanitizeResponsesImagePayload(params);
if (options?.openclawCodeModeToolSurface === true) {
enforceCodeModeResponsesToolSurface(params);
assertCodeModeResponsesToolSurface(params);
}
const requestStartedAt = Date.now();
const requestOptions = buildOpenAISdkRequestOptions(model, options?.signal);
emitModelTransportDebug(log, `[responses] start provider=${model.provider} api=${model.api} model=${model.id} baseUrl=${formatModelTransportDebugBaseUrl(model.baseUrl)} timeoutMs=${safeDebugValue(requestOptions?.timeout)} apiKey=${apiKey ? "present" : "missing"} ${summarizeResponsesPayload(params)}`);
const responseStream = await client.responses.create(params, requestOptions);
emitModelTransportDebug(log, `[responses] headers provider=${model.provider} api=${model.api} model=${model.id} elapsedMs=${Date.now() - requestStartedAt}`);
stream.push({
type: "start",
partial: output
});
await processResponsesStream(responseStream, output, stream, model, {
firstEventTimeoutMs: AZURE_RESPONSES_FIRST_EVENT_TIMEOUT_MS,
signal: options?.signal,
authProfileId: responsesOptions?.authProfileId,
sessionId: options?.sessionId
});
if (options?.signal?.aborted) throw new Error("Request was aborted");
if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error("An unknown error occurred");
stream.push({
type: "done",
reason: output.stopReason,
message: output
});
stream.end();
} catch (error) {
log.warn(`[responses] error provider=${model.provider} api=${model.api} model=${model.id} ` + summarizeOpenAITransportError(error));
assignTransportErrorDetails(output, error, options?.signal);
stream.push({
type: "error",
reason: output.stopReason,
error: output
});
stream.end();
}
})();
return eventStream;
};
}
function normalizeAzureBaseUrl(baseUrl) {
return baseUrl.replace(/\/+$/, "");
}
function resolveAzureDeploymentName(model) {
return resolveAzureDeploymentNameFromMap({
modelId: model.id,
deploymentMap: process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP
});
}
function createAzureOpenAIClient(model, context, apiKey, optionHeaders, turnHeaders) {
const baseURL = normalizeAzureBaseUrl(model.baseUrl);
const clientOptions = {
apiKey,
dangerouslyAllowBrowser: true,
defaultHeaders: buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders),
baseURL,
fetch: buildGuardedModelFetch(model),
...buildOpenAISdkClientOptions(model)
};
if (isOpenAICompatibleAzureResponsesBaseUrl(baseURL)) return new OpenAI(clientOptions);
return new AzureOpenAI({
...clientOptions,
apiVersion: resolveAzureOpenAIApiVersion()
});
}
function buildAzureOpenAIResponsesParams(model, context, options, deploymentName, metadata) {
const params = buildOpenAIResponsesParams(model, context, options, metadata);
params.model = deploymentName;
delete params.store;
return params;
}
function hasToolHistory(messages) {
return messages.some((message) => message.role === "toolResult" || message.role === "assistant" && message.content.some((block) => block.type === "toolCall"));
}
function assertOpenAICompletionsPayloadHasConversationTurn(params, model) {
const messages = params.messages;
if (!Array.isArray(messages) || hasOpenAICompatibleConversationTurn(messages)) return;
throw new Error(`OpenAI-compatible chat payload for ${model.provider}/${model.id} contains no non-empty user or assistant messages after compaction and transport transforms; refusing to send a system/tool-only request. Start a new user turn or repair the compacted session history.`);
}
function createOpenAICompletionsClient(model, context, apiKey, optionHeaders) {
const clientConfig = buildOpenAICompletionsClientConfig(model, context, optionHeaders);
return new OpenAI({
apiKey,
baseURL: clientConfig.baseURL,
dangerouslyAllowBrowser: true,
defaultHeaders: clientConfig.defaultHeaders,
defaultQuery: clientConfig.defaultQuery,
fetch: buildGuardedModelFetch(model),
...buildOpenAISdkClientOptions(model)
});
}
function isAzureOpenAICompatibleHost(hostname) {
return hostname.endsWith(".openai.azure.com") || hostname.endsWith(".services.ai.azure.com") || hostname.endsWith(".cognitiveservices.azure.com");
}
function buildOpenAICompletionsClientConfig(model, context, optionHeaders) {
const headers = buildOpenAIClientHeaders(model, context, optionHeaders);
const defaultQuery = {};
let baseURL = model.baseUrl;
let isAzureHost = false;
try {
const parsed = new URL(model.baseUrl);
isAzureHost = isAzureOpenAICompatibleHost(parsed.hostname.toLowerCase());
parsed.searchParams.forEach((value, key) => {
if (value) defaultQuery[key] = value;
});
parsed.search = "";
baseURL = parsed.toString().replace(/\/$/, "");
} catch {}
if (isAzureHost) {
const apiVersionHeader = Object.keys(headers).find((key) => key.toLowerCase() === "api-version");
if (apiVersionHeader) {
const apiVersion = headers[apiVersionHeader]?.trim();
delete headers[apiVersionHeader];
if (apiVersion && !defaultQuery["api-version"]) defaultQuery["api-version"] = apiVersion;
}
}
return {
baseURL,
defaultHeaders: headers,
defaultQuery: Object.keys(defaultQuery).length > 0 ? defaultQuery : void 0
};
}
function createOpenAICompletionsTransportStreamFn() {
return (model, context, options) => {
const eventStream = createAssistantMessageEventStream();
const stream = eventStream;
(async () => {
const output = {
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: "stop",
timestamp: Date.now()
};
try {
const client = createOpenAICompletionsClient(model, context, options?.apiKey || getEnvApiKey(model.provider) || "", options?.headers);
let params = buildOpenAICompletionsParams(model, context, options);
const nextParams = await options?.onPayload?.(params, model);
if (nextParams !== void 0) params = nextParams;
if (options?.openclawCodeModeToolSurface === true) {
enforceCodeModeResponsesToolSurface(params);
assertCodeModeResponsesToolSurface(params);
}
if (getCompat(model).requiresNonEmptyUserOrAssistantMessage) assertOpenAICompletionsPayloadHasConversationTurn(params, model);
const emitReasoning = shouldEmitOpenAICompletionsReasoning(model, options);
const responseStream = await client.chat.completions.create(params, buildOpenAISdkRequestOptions(model, options?.signal));
stream.push({
type: "start",
partial: output
});
await processOpenAICompletionsStream(responseStream, output, model, stream, {
signal: options?.signal,
emitReasoning
});
if (options?.signal?.aborted) throw new Error("Request was aborted");
stream.push({
type: "done",
reason: output.stopReason,
message: output
});
stream.end();
} catch (error) {
assignTransportErrorDetails(output, error, options?.signal);
stream.push({
type: "error",
reason: output.stopReason,
error: output
});
stream.end();
}
})();
return eventStream;
};
}
async function processOpenAICompletionsStream(responseStream, output, model, stream, options) {
const MAX_POST_TOOL_CALL_BUFFER_BYTES = 256e3;
const MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES = 256e3;
const emitReasoning = options?.emitReasoning ?? true;
const compat = getCompat(model);
const deepSeekTextFilter = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekTextFilter() : null;
const deepSeekToolCallRecoverer = shouldFilterDeepSeekDsmlText(compat) ? createDeepSeekDsmlToolCallRecoverer() : null;
const reasoningTagTextPartitioner = createReasoningTagTextPartitioner();
let currentBlock = null;
let pendingPostToolCallDeltas = [];
let pendingPostToolCallBytes = 0;
let isFlushingPendingPostToolCallDeltas = false;
let recoveredDeepSeekToolCallIndex = 0;
const toolCallBlocksByIndex = /* @__PURE__ */ new Map();
const toolCallBlocksById = /* @__PURE__ */ new Map();
const toolCallBlockBytes = /* @__PURE__ */ new WeakMap();
let sawStopFinishReason = false;
const blockIndex = () => output.content.length - 1;
const measureUtf8Bytes = (text) => Buffer.byteLength(text, "utf8");
let chunkPushedEvent = false;
const pushStreamEvent = (event) => {
chunkPushedEvent = true;
stream.push(event);
};
const finishCurrentBlock = () => {
if (!currentBlock) return;
if (currentBlock.type === "toolCall") currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
};
const finishAllToolCallBlocks = () => {
for (const block of toolCallBlocksByIndex.values()) block.arguments = parseStreamingJson(block.partialArgs);
};
const queuePostToolCallDelta = (next) => {
const nextBytes = measureUtf8Bytes(next.text);
if (pendingPostToolCallBytes + nextBytes > MAX_POST_TOOL_CALL_BUFFER_BYTES) throw new Error("Exceeded post-tool-call delta buffer limit");
pendingPostToolCallBytes += nextBytes;
const previous = pendingPostToolCallDeltas[pendingPostToolCallDeltas.length - 1];
if (!previous || previous.kind !== next.kind) {
pendingPostToolCallDeltas.push(next);
return;
}
if (next.kind === "thinking" && previous.kind === "thinking") {
if (previous.signature !== next.signature) {
pendingPostToolCallDeltas.push(next);
return;
}
previous.text += next.text;
return;
}
previous.text += next.text;
};
const appendThinkingDeltaInternal = (reasoningDelta) => {
if (!currentBlock || currentBlock.type !== "thinking") {
finishCurrentBlock();
currentBlock = {
type: "thinking",
thinking: "",
...reasoningDelta.signature ? { thinkingSignature: reasoningDelta.signature } : {}
};
output.content.push(currentBlock);
pushStreamEvent({
type: "thinking_start",
contentIndex: blockIndex(),
partial: output
});
}
currentBlock.thinking += reasoningDelta.text;
pushStreamEvent({
type: "thinking_delta",
contentIndex: blockIndex(),
delta: reasoningDelta.text,
partial: output
});
};
const appendTextDeltaInternal = (text) => {
if (!currentBlock || currentBlock.type !== "text") {
finishCurrentBlock();
currentBlock = {
type: "text",
text: ""
};
output.content.push(currentBlock);
pushStreamEvent({
type: "text_start",
contentIndex: blockIndex(),
partial: output
});
}
currentBlock.text += text;
pushStreamEvent({
type: "text_delta",
contentIndex: blockIndex(),
delta: text
});
};
const flushPendingPostToolCallDeltas = () => {
if (isFlushingPendingPostToolCallDeltas || currentBlock?.type === "toolCall" || pendingPostToolCallDeltas.length === 0) return;
isFlushingPendingPostToolCallDeltas = true;
const bufferedDeltas = pendingPostToolCallDeltas;
pendingPostToolCallDeltas = [];
pendingPostToolCallBytes = 0;
for (const delta of bufferedDeltas) if (delta.kind === "text") appendTextDeltaInternal(delta.text);
else if (emitReasoning) appendThinkingDeltaInternal(delta);
isFlushingPendingPostToolCallDeltas = false;
};
const appendThinkingDelta = (reasoningDelta) => {
flushPendingPostToolCallDeltas();
appendThinkingDeltaInternal(reasoningDelta);
};
const appendTextDelta = (text) => {
flushPendingPostToolCallDeltas();
appendTextDeltaInternal(text);
};
const appendVisibleTextDelta = (text) => {
if (!text) return;
if (currentBlock?.type === "toolCall") queuePostToolCallDelta({
kind: "text",
text
});
else appendTextDelta(text);
};
const appendRecoveredToolCall = (toolCall) => {
const switchingToolCall = currentBlock?.type === "toolCall";
finishCurrentBlock();
if (switchingToolCall) {
currentBlock = null;
flushPendingPostToolCallDeltas();
}
output.stopReason = "toolUse";
recoveredDeepSeekToolCallIndex += 1;
const block = {
type: "toolCall",
id: `call_deepseek_dsml_${recoveredDeepSeekToolCallIndex}`,
name: toolCall.name,
arguments: toolCall.arguments,
partialArgs: toolCall.partialArgs
};
currentBlock = block;
output.content.push(block);
pushStreamEvent({
type: "toolcall_start",
contentIndex: output.content.indexOf(block),
partial: output
});
pushStreamEvent({
type: "toolcall_delta",
contentIndex: output.content.indexOf(block),
delta: toolCall.partialArgs,
partial: output
});
};
const appendFilteredVisibleTextDelta = (text) => {
const recoveredParts = deepSeekToolCallRecoverer?.push(text) ?? [{
kind: "text",
text
}];
for (const recoveredPart of recoveredParts) {
if (recoveredPart.kind === "toolCall") {
appendRecoveredToolCall(recoveredPart);
continue;
}
const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
for (const part of parts) appendVisibleTextDelta(part);
}
};
const flushDeepSeekToolCallRecovererAtEnd = () => {
const recoveredParts = deepSeekToolCallRecoverer?.flush();
if (!recoveredParts) return;
for (const recoveredPart of recoveredParts) {
if (recoveredPart.kind === "toolCall") {
appendRecoveredToolCall(recoveredPart);
continue;
}
const parts = deepSeekTextFilter?.push(recoveredPart.text) ?? [recoveredPart.text];
for (const part of parts) appendVisibleTextDelta(part);
}
};
const flushDeepSeekTextFilterAtEnd = () => {
const parts = deepSeekTextFilter?.flush();
if (!parts) return;
for (const part of parts) appendVisibleTextDelta(part);
};
const appendRoutedContentDelta = (delta) => {
if (delta.kind === "text") {
appendFilteredVisibleTextDelta(delta.text);
return;
}
if (!emitReasoning) return;
if (currentBlock?.type === "toolCall") queuePostToolCallDelta(delta);
else appendThinkingDelta(delta);
};
const appendPartitionedVisibleDelta = (delta) => {
if (delta.kind === "text") appendFilteredVisibleTextDelta(delta.text);
};
const emitReasoningUsageActivity = (hasReasoningUsageActivity) => {
if (!hasReasoningUsageActivity || chunkPushedEvent || !emitReasoning) return;
const latestBlock = output.content[output.content.length - 1];
if (currentBlock?.type === "text" || currentBlock?.type === "toolCall") return;
if (latestBlock?.type === "text" || latestBlock?.type === "toolCall") return;
appendThinkingDelta({
signature: "",
text: ""
});
};
const flushReasoningTagTextPartitionerAtEnd = () => {
for (const delta of reasoningTagTextPartitioner.flush()) appendPartitionedVisibleDelta(delta);
};
const cooperativeScheduler = createModelStreamCooperativeScheduler(options?.signal);
for await (const rawChunk of responseStream) {
throwIfModelStreamAborted(options?.signal);
chunkPushedEvent = false;
if (!rawChunk || typeof rawChunk !== "object") {
await cooperativeScheduler.afterEvent();
continue;
}
const chunk = rawChunk;
output.responseId ||= chunk.id;
let hasReasoningUsageActivity = false;
if (chunk.usage) {
output.usage = parseTransportChunkUsage(chunk.usage, model);
hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(chunk.usage);
}
const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
if (!choice) {
emitReasoningUsageActivity(hasReasoningUsageActivity);
await cooperativeScheduler.afterEvent();
continue;
}
const choiceUsage = choice.usage;
if (!chunk.usage && choiceUsage) {
output.usage = parseTransportChunkUsage(choiceUsage, model);
hasReasoningUsageActivity = hasOpenAICompletionsReasoningUsageActivity(choiceUsage);
}
if (choice.finish_reason) {
const finishReasonResult = mapStopReason(choice.finish_reason);
output.stopReason = finishReasonResult.stopReason;
if (finishReasonResult.stopReason === "stop") sawStopFinishReason = true;
if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
}
const choiceDelta = choice.delta ?? choice.message;
if (!choiceDelta) {
emitReasoningUsageActivity(hasReasoningUsageActivity);
await cooperativeScheduler.afterEvent();
continue;
}
const reasoningDeltas = getCompletionsReasoningDeltas(choiceDelta, compat.visibleReasoningDetailTypes);
const hasMirroredReasoning = reasoningDeltas.some((delta) => delta.kind === "thinking");
if (hasMirroredReasoning) reasoningTagTextPartitioner.markStrict();
if (choiceDelta.content) {
const contentDeltas = getCompletionsContentDeltas(choiceDelta.content);
for (const contentDelta of contentDeltas) if (contentDelta.kind === "text") {
const routedDeltas = hasMirroredReasoning ? reasoningTagTextPartitioner.push(contentDelta.text) : reasoningTagTextPartitioner.pushVisible(contentDelta.text);
for (const routedDelta of routedDeltas) appendPartitionedVisibleDelta(routedDelta);
} else {
reasoningTagTextPartitioner.markStrict();
appendRoutedContentDelta(contentDelta);
}
}
for (const reasoningDelta of reasoningDeltas) {
if (reasoningDelta.kind === "thinking" && !emitReasoning) continue;
if (currentBlock?.type === "toolCall") {
queuePostToolCallDelta({ ...reasoningDelta });
continue;
}
if (reasoningDelta.kind === "text") appendTextDelta(reasoningDelta.text);
else if (emitReasoning) appendThinkingDelta(reasoningDelta);
}
if (choiceDelta.tool_calls && choiceDelta.tool_calls.length > 0) {
flushReasoningTagTextPartitionerAtEnd();
for (const toolCall of choiceDelta.tool_calls) {
const streamIndex = typeof toolCall.index === "number" ? toolCall.index : void 0;
let block = streamIndex !== void 0 ? toolCallBlocksByIndex.get(streamIndex) : void 0;
if (!block && toolCall.id) block = toolCallBlocksById.get(toolCall.id);
if (!block) {
const switchingToolCall = currentBlock?.type === "toolCall";
finishCurrentBlock();
if (switchingToolCall) {
currentBlock = null;
flushPendingPostToolCallDeltas();
}
const initialSig = extractGoogleThoughtSignature(toolCall);
block = {
type: "toolCall",
id: toolCall.id || "",
name: toolCall.function?.name || "",
arguments: {},
partialArgs: "",
...initialSig ? { thoughtSignature: initialSig } : {}
};
output.content.push(block);
pushStreamEvent({
type: "toolcall_start",
contentIndex: output.content.indexOf(block),
partial: output
});
}
if (streamIndex !== void 0 && !toolCallBlocksByIndex.has(streamIndex)) toolCallBlocksByIndex.set(streamIndex, block);
if (toolCall.id) {
block.id = toolCall.id;
toolCallBlocksById.set(toolCall.id, block);
}
currentBlock = block;
if (toolCall.function?.name) block.name = toolCall.function.name;
const deltaSig = extractGoogleThoughtSignature(toolCall);
if (deltaSig) block.thoughtSignature = deltaSig;
if (toolCall.function?.arguments) {
const nextArgumentBytes = measureUtf8Bytes(toolCall.function.arguments);
const currentBlockArgBytes = toolCallBlockBytes.get(block) ?? 0;
if (currentBlockArgBytes + nextArgumentBytes > MAX_TOOL_CALL_ARGUMENT_BUFFER_BYTES) throw new Error("Exceeded tool-call argument buffer limit");
toolCallBlockBytes.set(block, currentBlockArgBytes + nextArgumentBytes);
block.partialArgs += toolCall.function.arguments;
block.arguments = parseStreamingJson(block.partialArgs);
pushStreamEvent({
type: "toolcall_delta",
contentIndex: output.content.indexOf(block),
delta: toolCall.function.arguments,
partial: output
});
}
}
}
flushPendingPostToolCallDeltas();
emitReasoningUsageActivity(hasReasoningUsageActivity);
await cooperativeScheduler.afterEvent();
}
flushReasoningTagTextPartitionerAtEnd();
flushDeepSeekToolCallRecovererAtEnd();
flushDeepSeekTextFilterAtEnd();
finishAllToolCallBlocks();
currentBlock = null;
flushPendingPostToolCallDeltas();
const hasToolCalls = output.content.some((block) => block.type === "toolCall");
const hasVisibleText = output.content.some((block) => block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0);
if (output.stopReason === "toolUse" && !hasToolCalls) output.stopReason = "stop";
if (sawStopFinishReason && output.stopReason === "stop" && hasToolCalls && !hasVisibleText) output.stopReason = "toolUse";
if (hasToolCalls && output.stopReason !== "toolUse") output.content = output.content.filter((block) => block.type !== "toolCall");
}
function shouldFilterDeepSeekDsmlText(compat) {
return compat.thinkingFormat === "deepseek";
}
const DEEPSEEK_DSML_BARS = ["|", "｜"];
const DEEPSEEK_DSML_TOOL_KINDS = [
"tool_calls",
"tool_call",
"function_calls"
];
const DEEPSEEK_DSML_TOOL_OPEN_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `<${bar}DSML${bar}${kind}>`));
const DEEPSEEK_DSML_TOOL_CLOSE_TOKENS = DEEPSEEK_DSML_BARS.flatMap((bar) => DEEPSEEK_DSML_TOOL_KINDS.map((kind) => `</${bar}DSML${bar}${kind}>`));
const DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN = Math.max(...DEEPSEEK_DSML_TOOL_OPEN_TOKENS.map((token) => token.length));
function createDeepSeekDsmlToolCallRecoverer() {
let buffer = "";
const consume = (final) => {
const output = [];
while (buffer) {
const open = findEarliestStringToken(buffer, DEEPSEEK_DSML_TOOL_OPEN_TOKENS);
if (!open) {
if (final) {
output.push({
kind: "text",
text: buffer
});
buffer = "";
return output;
}
const keep = longestDeepSeekDsmlToolOpenPrefixSuffixLength(buffer);
const emitLength = buffer.length - keep;
if (emitLength > 0) {
output.push({
kind: "text",
text: buffer.slice(0, emitLength)
});
buffer = buffer.slice(emitLength);
}
return output;
}
if (open.index > 0) {
output.push({
kind: "text",
text: buffer.slice(0, open.index)
});
buffer = buffer.slice(open.index);
}
const afterOpen = buffer.slice(open.token.length);
const close = findEarliestStringToken(afterOpen, DEEPSEEK_DSML_TOOL_CLOSE_TOKENS);
if (!close) {
if (final) {
output.push({
kind: "text",
text: buffer
});
buffer = "";
}
return output;
}
const body = afterOpen.slice(0, close.index);
const blockLength = open.token.length + close.index + close.token.length;
const recoveredToolCalls = parseDeepSeekDsmlToolCallBlock(body);
if (recoveredToolCalls.length > 0) output.push(...recoveredToolCalls);
else output.push({
kind: "text",
text: buffer.slice(0, blockLength)
});
buffer = buffer.slice(blockLength);
}
return output;
};
return {
push(chunk) {
buffer += chunk;
return consume(false);
},
flush() {
return consume(true);
}
};
}
function parseDeepSeekDsmlToolCallBlock(body) {
const toolCalls = [];
const invokeOpenRegex = /<[|｜]DSML[|｜]invoke\b([^>]*)>/g;
let openMatch;
while ((openMatch = invokeOpenRegex.exec(body)) !== null) {
const invokeName = parseXmlAttribute(openMatch[1] ?? "", "name");
if (!invokeName) continue;
const invokeBodyStart = openMatch.index + openMatch[0].length;
const invokeClose = findEarliestStringToken(body.slice(invokeBodyStart), ["</|DSML|invoke>", "</｜DSML｜invoke>"]);
if (!invokeClose) continue;
const invokeBody = body.slice(invokeBodyStart, invokeBodyStart + invokeClose.index);
invokeOpenRegex.lastIndex = invokeBodyStart + invokeClose.index + invokeClose.token.length;
const parsedArguments = parseDeepSeekDsmlInvokeArguments(invokeBody);
if (!parsedArguments) continue;
toolCalls.push({
kind: "toolCall",
name: invokeName,
arguments: parsedArguments,
partialArgs: JSON.stringify(parsedArguments)
});
}
return toolCalls;
}
function parseDeepSeekDsmlInvokeArguments(body) {
const args = {};
const parameterRegex = /<[|｜]DSML[|｜]parameter\b([^>]*)>([\s\S]*?)<\/[|｜]DSML[|｜]parameter>/g;
let parameterMatch;
while ((parameterMatch = parameterRegex.exec(body)) !== null) {
const name = parseXmlAttribute(parameterMatch[1] ?? "", "name");
if (!name) continue;
const rawValue = parameterMatch[2] ?? "";
if (rawValue.length === 0) continue;
args[name] = decodeDeepSeekDsmlText(rawValue);
}
if (Object.keys(args).length > 0) return args;
const trimmed = body.trim();
if (!trimmed.startsWith("{")) return null;
try {
const parsed = JSON.parse(trimmed);
if (isRecord(parsed) && Object.keys(parsed).length > 0) return parsed;
} catch {
return null;
}
return null;
}
const xmlAttributeRegexCache = /* @__PURE__ */ new Map();
function xmlAttributeRegex(name) {
const cached = xmlAttributeRegexCache.get(name);
if (cached) return cached;
const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
const pattern = new RegExp(`\\b${escaped}=("([^"]*)"|'([^']*)'|([^\\s>]+))`);
xmlAttributeRegexCache.set(name, pattern);
return pattern;
}
function parseXmlAttribute(attributes, name) {
const match = xmlAttributeRegex(name).exec(attributes);
const value = match?.[2] ?? match?.[3] ?? match?.[4];
return value ? decodeDeepSeekDsmlText(value) : null;
}
function decodeDeepSeekDsmlText(value) {
return value.replaceAll(""", "\"").replaceAll("'", "'").replaceAll("<", "<").replaceAll(">", ">").replaceAll("&", "&");
}
function findEarliestStringToken(text, tokens) {
let best = null;
for (const token of tokens) {
const index = text.indexOf(token);
if (index !== -1 && (!best || index < best.index)) best = {
index,
token
};
}
return best;
}
function longestDeepSeekDsmlToolOpenPrefixSuffixLength(text) {
const maxLength = Math.min(text.length, DEEPSEEK_DSML_TOOL_MAX_OPEN_TOKEN_LEN - 1);
for (let length = maxLength; length > 0; length -= 1) {
const suffix = text.slice(text.length - length);
if (DEEPSEEK_DSML_TOOL_OPEN_TOKENS.some((token) => token.startsWith(suffix))) return length;
}
return 0;
}
function getCompletionsContentDeltas(content) {
if (typeof content === "string") return content ? [{
kind: "text",
text: content
}] : [];
if (Array.isArray(content)) return content.flatMap((item) => getCompletionsContentDeltas(item));
if (!content || typeof content !== "object") return [];
const record = content;
const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
const extractText = (value) => {
if (typeof value === "string") return value;
if (Array.isArray(value)) return value.map((item) => extractText(item)).join("");
if (value && typeof value === "object") {
const nested = value;
return extractText(nested.text ?? nested.content ?? nested.thinking);
}
return "";
};
const text = extractText(record.text ?? record.content ?? record.thinking);
if (!text) return [];
if (type.includes("thinking") || type.includes("reasoning")) return [{
kind: "thinking",
signature: "content",
text
}];
if (type === "text" || type === "output_text" || type.endsWith(".output_text")) return [{
kind: "text",
text
}];
return [];
}
function getCompletionsReasoningDeltas(delta, visibleReasoningDetailTypes) {
const output = [];
const pushDelta = (next) => {
const previous = output[output.length - 1];
if (!previous || previous.kind !== next.kind) {
output.push(next);
return;
}
if (next.kind === "thinking" && previous.kind === "thinking") {
if (previous.signature !== next.signature) {
output.push(next);
return;
}
previous.text += next.text;
return;
}
previous.text += next.text;
};
const reasoningDetails = delta.reasoning_details;
let usedReasoningThinkingDetails = false;
if (Array.isArray(reasoningDetails)) {
const visibleTypes = new Set(visibleReasoningDetailTypes);
for (const item of reasoningDetails) {
const detail = item;
if (typeof detail.text !== "string" || !detail.text) continue;
if (detail.type === "reasoning.text") {
usedReasoningThinkingDetails = true;
pushDelta({
kind: "thinking",
signature: "reasoning_details",
text: detail.text
});
continue;
}
if (typeof detail.type === "string" && visibleTypes.has(detail.type)) pushDelta({
kind: "text",
text: detail.text
});
}
}
if (!usedReasoningThinkingDetails) for (const field of [
"reasoning_content",
"reasoning",
"reasoning_text"
]) {
const value = delta[field];
if (typeof value === "string" && value.length > 0) {
pushDelta({
kind: "thinking",
signature: field,
text: value
});
break;
}
}
return output;
}
function detectCompat(model) {
const { defaults: compatDefaults } = detectOpenAICompletionsCompat(model);
return {
supportsStore: compatDefaults.supportsStore,
supportsDeveloperRole: compatDefaults.supportsDeveloperRole,
supportsReasoningEffort: compatDefaults.supportsReasoningEffort,
reasoningEffortMap: {},
supportsUsageInStreaming: compatDefaults.supportsUsageInStreaming,
maxTokensField: compatDefaults.maxTokensField,
requiresToolResultName: false,
requiresAssistantAfterToolResult: false,
requiresThinkingAsText: false,
thinkingFormat: compatDefaults.thinkingFormat,
visibleReasoningDetailTypes: compatDefaults.visibleReasoningDetailTypes,
openRouterRouting: {},
vercelGatewayRouting: {},
supportsStrictMode: compatDefaults.supportsStrictMode,
requiresReasoningContentOnAssistantMessages: compatDefaults.requiresReasoningContentOnAssistantMessages,
requiresNonEmptyUserOrAssistantMessage: compatDefaults.requiresNonEmptyUserOrAssistantMessage
};
}
function getCompat(model) {
const detected = detectCompat(model);
const compat = model.compat ?? {};
const supportsStore = typeof compat.supportsStore === "boolean" ? compat.supportsStore : detected.supportsStore;
const supportsReasoningEffort = typeof compat.supportsReasoningEffort === "boolean" ? compat.supportsReasoningEffort : detected.supportsReasoningEffort;
return {
supportsStore,
supportsDeveloperRole: compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
supportsReasoningEffort,
reasoningEffortMap: resolveOpenAIReasoningEffortMap(model, detected.reasoningEffortMap),
supportsUsageInStreaming: compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
maxTokensField: compat.maxTokensField ?? detected.maxTokensField,
requiresToolResultName: compat.requiresToolResultName ?? detected.requiresToolResultName,
requiresAssistantAfterToolResult: compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
requiresThinkingAsText: compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
thinkingFormat: compat.thinkingFormat ?? detected.thinkingFormat,
openRouterRouting: compat.openRouterRouting ?? {},
vercelGatewayRouting: compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
supportsStrictMode: compat.supportsStrictMode ?? detected.supportsStrictMode,
supportsPromptCacheKey: compat.supportsPromptCacheKey === true,
supportsLongCacheRetention: compat.supportsLongCacheRetention !== false,
requiresStringContent: compat.requiresStringContent ?? false,
strictMessageKeys: compat.strictMessageKeys === true,
visibleReasoningDetailTypes: compat.visibleReasoningDetailTypes ?? detected.visibleReasoningDetailTypes,
requiresReasoningContentOnAssistantMessages: compat.requiresReasoningContentOnAssistantMessages ?? detected.requiresReasoningContentOnAssistantMessages,
requiresNonEmptyUserOrAssistantMessage: detected.requiresNonEmptyUserOrAssistantMessage
};
}
function resolveOpenAICompletionsReasoningEffort(options) {
return options?.reasoningEffort ?? options?.reasoning ?? "high";
}
function shouldEmitOpenAICompletionsReasoning(model, options) {
if (!model.reasoning) return false;
const effort = resolveOpenAICompletionsReasoningEffort(options);
if (!effort || !isOpenAICompletionsThinkingEnabled(effort)) return false;
return true;
}
function resolveOpenAICompletionsMaxTokens(model, options) {
if (options?.maxTokens) return {
maxTokens: options.maxTokens,
clampToModelMaxTokens: true
};
const paramsMaxTokens = resolveMaxTokensParam(model.params);
if (paramsMaxTokens) return {
maxTokens: paramsMaxTokens,
clampToModelMaxTokens: false
};
return {
maxTokens: model.maxTokens,
clampToModelMaxTokens: false
};
}
function resolveOpenAICompletionsModelMaxTokens(model) {
return typeof model.maxTokens === "number" && Number.isFinite(model.maxTokens) && model.maxTokens > 0 ? Math.floor(model.maxTokens) : void 0;
}
const OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN = 1.25;
const OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE = 8e3;
function estimateOpenAICompletionsInputTokens(payload) {
let adjustedChars = 0;
adjustedChars += estimateOpenAICompletionsMessagesChars(payload.messages);
if (Array.isArray(payload.tools) && payload.tools.length > 0) try {
adjustedChars += estimateStringChars(JSON.stringify(payload.tools));
} catch {
adjustedChars += 1024;
}
if (payload.response_format !== void 0) try {
adjustedChars += estimateStringChars(JSON.stringify(payload.response_format));
} catch {
adjustedChars += 256;
}
return Math.ceil(adjustedChars / 4 * OPENAI_COMPLETIONS_INPUT_TOKEN_SAFETY_MARGIN);
}
function estimateOpenAICompletionsMessagesChars(messages) {
if (!Array.isArray(messages)) return 0;
let adjustedChars = 0;
for (const message of messages) {
if (!message || typeof message !== "object") continue;
const record = message;
adjustedChars += estimateOpenAICompletionsContentChars(record.content);
for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) adjustedChars += estimateOpenAICompletionsContentChars(record[field]);
if (record.tool_calls !== void 0) try {
adjustedChars += estimateStringChars(JSON.stringify(record.tool_calls));
} catch {
adjustedChars += 256;
}
}
return adjustedChars;
}
function estimateOpenAICompletionsContentChars(value) {
if (typeof value === "string") return estimateStringChars(value);
if (!Array.isArray(value)) return 0;
let adjustedChars = 0;
for (const block of value) {
if (!block || typeof block !== "object") continue;
const record = block;
if (record.type === "image_url" || record.type === "input_image") {
adjustedChars += OPENAI_COMPLETIONS_IMAGE_CHAR_ESTIMATE;
continue;
}
const text = record.text;
if (typeof text === "string") {
adjustedChars += estimateStringChars(text);
continue;
}
try {
adjustedChars += estimateStringChars(JSON.stringify(block));
} catch {
adjustedChars += 256;
}
}
return adjustedChars;
}
function resolveOpenAICompletionsEffectiveContextTokens(model) {
const contextTokens = model.contextTokens;
if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens > 0) return contextTokens;
return typeof model.contextWindow === "number" && Number.isFinite(model.contextWindow) && model.contextWindow > 0 ? model.contextWindow : void 0;
}
function isQwenOpenAICompletionsThinkingFormat(format) {
return format === "qwen" || format === "qwen-chat-template";
}
function isOpenAICompletionsThinkingEnabled(effort) {
const normalized = effort.trim().toLowerCase();
return normalized !== "off" && normalized !== "none";
}
function setQwenChatTemplateThinking(params, enabled) {
const existing = params.chat_template_kwargs;
params.chat_template_kwargs = existing && typeof existing === "object" && !Array.isArray(existing) ? {
...existing,
enable_thinking: enabled
} : { enable_thinking: enabled };
}
function applyQwenOpenAICompletionsThinkingParams(params) {
if (!params.modelReasoning || !isQwenOpenAICompletionsThinkingFormat(params.compatThinkingFormat)) return false;
const enabled = isOpenAICompletionsThinkingEnabled(params.requestedEffort);
if (params.compatThinkingFormat === "qwen-chat-template") setQwenChatTemplateThinking(params.payload, enabled);
else params.payload.enable_thinking = enabled;
return true;
}
function applyTogetherOpenAICompletionsThinkingParams(params) {
if (!params.modelReasoning || params.compatThinkingFormat !== "together") return false;
params.payload.reasoning = { enabled: isOpenAICompletionsThinkingEnabled(params.requestedEffort) };
return true;
}
function convertTools(tools, compat, model) {
const strict = resolveOpenAIStrictToolFlagWithDiagnostics(tools, resolveOpenAIStrictToolSetting(model, {
transport: "stream",
supportsStrictMode: compat?.supportsStrictMode
}), {
transport: "completions",
model
});
return sortTransportToolsByName(tools).map((tool) => {
const functionTool = {
name: tool.name,
description: tool.description,
parameters: normalizeOpenAIStrictToolParameters(tool.parameters, strict === true, model.compat)
};
if (strict !== void 0) functionTool.strict = strict;
return {
type: "function",
function: functionTool
};
});
}
function compareTransportToolText(left, right) {
const leftText = left ?? "";
const rightText = right ?? "";
if (leftText < rightText) return -1;
if (leftText > rightText) return 1;
return 0;
}
function sortTransportToolsByName(tools) {
return tools.toSorted((left, right) => compareTransportToolText(left.name, right.name) || compareTransportToolText(left.description, right.description));
}
function extractGoogleThoughtSignature(toolCall) {
const tc = toolCall;
if (!tc) return;
const fromExtra = (tc.extra_content?.google)?.thought_signature;
if (typeof fromExtra === "string" && fromExtra.length > 0) return fromExtra;
const fromFunction = tc.function?.thought_signature;
return typeof fromFunction === "string" && fromFunction.length > 0 ? fromFunction : void 0;
}
function isGoogleOpenAICompatModel(model) {
const endpointClass = detectOpenAICompletionsCompat(model).capabilities.endpointClass;
return model.provider === "google" || endpointClass === "google-generative-ai" || endpointClass === "google-vertex";
}
function requiresGoogleCompatToolCallThoughtSignature(model) {
return model.id.toLowerCase().includes("gemini-3");
}
const GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE = /[\u2026]|\.\.\./;
const GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE = /^[A-Za-z0-9+/=]+$/;
function hasGoogleCompatThoughtSignatureTruncationFootprint(value) {
return GOOGLE_COMPAT_THOUGHT_SIGNATURE_ELLIPSIS_RE.test(value) || GOOGLE_COMPAT_THOUGHT_SIGNATURE_BASE64_RE.test(value) && value.length % 4 !== 0;
}
function injectToolCallThoughtSignatures(outgoingMessages, context, model) {
if (!isGoogleOpenAICompatModel(model)) return;
const sigById = /* @__PURE__ */ new Map();
const fallbackSig = requiresGoogleCompatToolCallThoughtSignature(model) ? GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP : void 0;
for (const msg of context.messages ?? []) {
if (msg.role !== "assistant") continue;
const source = msg;
if (!Array.isArray(source.content)) continue;
for (const block of source.content) {
if (block.type !== "toolCall") continue;
const id = block.id;
const sig = block.thoughtSignature;
if (typeof id === "string" && typeof sig === "string" && sig.length > 0) {
const isSameRoute = source.api === model.api && source.provider === model.provider && source.model === model.id;
if (!isSameRoute && !fallbackSig) continue;
sigById.set(id, isSameRoute ? sig : fallbackSig ?? sig);
}
}
}
if (sigById.size === 0 && !fallbackSig) return;
for (const message of outgoingMessages) {
const toolCalls = message.tool_calls;
if (!Array.isArray(toolCalls)) continue;
for (const toolCall of toolCalls) {
const id = toolCall.id;
if (typeof id !== "string") continue;
let sig = sigById.get(id) ?? fallbackSig;
if (typeof sig === "string" && sig.length > 0) {
if (hasGoogleCompatThoughtSignatureTruncationFootprint(sig.trim())) sig = fallbackSig;
}
if (typeof sig !== "string" || sig.length === 0) continue;
const extra = toolCall.extra_content && typeof toolCall.extra_content === "object" ? toolCall.extra_content : {};
toolCall.extra_content = extra;
const google = extra.google && typeof extra.google === "object" ? extra.google : {};
extra.google = google;
google.thought_signature = sig;
}
}
}
const COMPLETIONS_REASONING_REPLAY_FIELDS = [
"reasoning_details",
"reasoning_content",
"reasoning",
"reasoning_text"
];
function stripCompletionsReasoningReplayFields(record) {
for (const field of COMPLETIONS_REASONING_REPLAY_FIELDS) if (field in record) delete record[field];
}
function sanitizeOpenRouterReasoningReplayFields(record) {
const reasoningDetails = record.reasoning_details;
if (typeof reasoningDetails === "string") {
if (reasoningDetails.length > 0 && typeof record.reasoning !== "string") record.reasoning = reasoningDetails;
delete record.reasoning_details;
} else if (reasoningDetails !== void 0 && !Array.isArray(reasoningDetails)) delete record.reasoning_details;
if ("reasoning" in record && (typeof record.reasoning !== "string" || record.reasoning === "")) delete record.reasoning;
if ("reasoning_content" in record && (typeof record.reasoning_content !== "string" || record.reasoning_content === "")) delete record.reasoning_content;
const reasoningText = record.reasoning_text;
if (typeof reasoningText === "string" && reasoningText.length > 0 && typeof record.reasoning !== "string" && typeof record.reasoning_content !== "string") record.reasoning = reasoningText;
if ("reasoning_text" in record) delete record.reasoning_text;
}
function sanitizeReasoningContentReplayFields(record) {
if ("reasoning_content" in record && typeof record.reasoning_content !== "string") delete record.reasoning_content;
delete record.reasoning_details;
delete record.reasoning;
delete record.reasoning_text;
}
const REASONING_CONTENT_REPLAY_MODEL_IDS = new Set([
"deepseek-v4-flash",
"deepseek-v4-pro",
"kimi-for-coding",
"kimi-k2.5",
"kimi-k2.6",
"kimi-k2-thinking",
"kimi-k2-thinking-turbo",
"mimo-v2-pro",
"mimo-v2-omni",
"mimo-v2.5",
"mimo-v2.5-pro",
"mimo-v2.6-pro"
]);
const REASONING_CONTENT_REPLAY_TIER_SUFFIXES = [
"-free",
"-paid",
"-trial"
];
function stripReasoningContentReplayTierSuffix(modelId) {
for (const suffix of REASONING_CONTENT_REPLAY_TIER_SUFFIXES) if (modelId.length > suffix.length && modelId.endsWith(suffix)) return modelId.slice(0, -suffix.length);
return modelId;
}
function getReasoningContentReplayModelIdCandidates(modelId) {
if (typeof modelId !== "string") return [];
const normalized = modelId.trim().toLowerCase();
if (!normalized) return [];
const parts = normalized.split("/").filter(Boolean);
const finalPart = parts[parts.length - 1] ?? normalized;
const candidates = [finalPart];
const colonParts = finalPart.split(":").filter(Boolean);
if (colonParts.length > 1) candidates.push(colonParts[0] ?? "", colonParts[colonParts.length - 1] ?? "");
const baseCount = candidates.length;
for (let index = 0; index < baseCount; index += 1) {
const candidate = candidates[index];
if (typeof candidate !== "string") continue;
const stripped = stripReasoningContentReplayTierSuffix(candidate);
if (stripped !== candidate) candidates.push(stripped);
}
return uniqueStrings(candidates.filter(Boolean));
}
function shouldPreserveReasoningContentReplay(model, compat) {
if (compat.requiresReasoningContentOnAssistantMessages || compat.thinkingFormat === "deepseek" || compat.thinkingFormat === "zai" || shouldTrustReasoningContentReplayMetadata(model)) return true;
return getReasoningContentReplayModelIdCandidates(model.id).some((modelId) => REASONING_CONTENT_REPLAY_MODEL_IDS.has(modelId));
}
function shouldPreserveOpenRouterReasoningReplay(model) {
if (model.provider !== "openrouter") return true;
const normalizedModelId = model.id.trim().toLowerCase();
return !(normalizedModelId.startsWith("anthropic/") || normalizedModelId.startsWith("x-ai/"));
}
function shouldTrustReasoningContentReplayMetadata(model) {
if (!model.reasoning) return false;
if (model.provider.trim().toLowerCase() === "openai") return false;
return shouldPreserveOpenRouterReasoningReplay(model);
}
function sanitizeCompletionsReasoningReplayFields(messages, options) {
if (!Array.isArray(messages)) return;
for (const msg of messages) {
if (!msg || typeof msg !== "object") continue;
const record = msg;
if (record.role !== "assistant") continue;
if (options.preserveOpenRouterReasoning) sanitizeOpenRouterReasoningReplayFields(record);
else if (options.preserveReasoningContent) sanitizeReasoningContentReplayFields(record);
else stripCompletionsReasoningReplayFields(record);
}
}
function buildOpenAICompletionsParams(model, context, options) {
const compat = getCompat(model);
const compatDetection = detectOpenAICompletionsCompat(model);
let messages = convertMessages(model, context.systemPrompt ? {
...context,
systemPrompt: stripSystemPromptCacheBoundary(context.systemPrompt)
} : context, compat);
injectToolCallThoughtSignatures(messages, context, model);
sanitizeCompletionsReasoningReplayFields(messages, {
preserveOpenRouterReasoning: compat.thinkingFormat === "openrouter" && shouldPreserveOpenRouterReasoningReplay(model),
preserveReasoningContent: shouldPreserveReasoningContentReplay(model, compat)
});
if (compat.strictMessageKeys) messages = stripCompletionMessagesToRoleContent(messages);
const cacheRetention = resolveCacheRetention(options?.cacheRetention);
const promptCacheKey = resolvePromptCacheKey(options, cacheRetention);
const params = {
model: model.id,
messages: compat.requiresStringContent ? flattenCompletionMessagesToStringContent(messages) : messages,
stream: true
};
if (compat.supportsUsageInStreaming) params.stream_options = { include_usage: true };
if (compat.supportsStore) params.store = false;
if (compat.supportsPromptCacheKey && promptCacheKey) {
params.prompt_cache_key = promptCacheKey;
if (cacheRetention === "long" && compat.supportsLongCacheRetention) params.prompt_cache_retention = "24h";
}
if (options?.temperature !== void 0) params.temperature = options.temperature;
if (options?.topP !== void 0) params.top_p = options.topP;
if (options?.responseFormat !== void 0) params.response_format = options.responseFormat;
if (options?.frequencyPenalty !== void 0) params.frequency_penalty = options.frequencyPenalty;
if (options?.presencePenalty !== void 0) params.presence_penalty = options.presencePenalty;
if (options?.seed !== void 0) params.seed = options.seed;
if (options?.stop !== void 0 && options.stop.length > 0) params.stop = options.stop;
if (supportsModelTools(model)) {
if (context.tools) {
params.tools = convertTools(context.tools, compat, model);
if (options?.toolChoice) params.tool_choice = options.toolChoice;
else if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length > 0) params.tool_choice = "auto";
} else if (hasToolHistory(context.messages)) params.tools = [];
if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && Array.isArray(params.tools) && params.tools.length === 0) {
delete params.tools;
delete params.tool_choice;
}
}
{
const maxTokenBudget = resolveOpenAICompletionsMaxTokens(model, options);
const effectiveMaxTokens = maxTokenBudget.maxTokens;
const effectiveContextTokens = resolveOpenAICompletionsEffectiveContextTokens(model);
let clampedMaxTokens = effectiveMaxTokens;
const modelMaxTokens = resolveOpenAICompletionsModelMaxTokens(model);
if (maxTokenBudget.clampToModelMaxTokens && clampedMaxTokens !== void 0 && modelMaxTokens !== void 0 && clampedMaxTokens > modelMaxTokens) {
clampedMaxTokens = modelMaxTokens;
emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} modelMaxTokens=${modelMaxTokens}`);
}
if (compatDetection.capabilities.usesExplicitProxyLikeEndpoint && clampedMaxTokens !== void 0 && effectiveContextTokens !== void 0) {
const estimatedInputTokens = estimateOpenAICompletionsInputTokens(params);
const remainingBudget = Math.max(1, effectiveContextTokens - estimatedInputTokens - 1);
if (clampedMaxTokens > remainingBudget) {
clampedMaxTokens = remainingBudget;
emitModelTransportDebug(log, `[completions] clamp_max_tokens provider=${model.provider} api=${model.api} model=${model.id} requested=${effectiveMaxTokens} output=${clampedMaxTokens} effectiveContext=${effectiveContextTokens} estimatedInput=${estimatedInputTokens}`);
}
}
if (clampedMaxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = clampedMaxTokens;
else params.max_completion_tokens = clampedMaxTokens;
}
const completionsReasoningEffort = resolveOpenAICompletionsReasoningEffort(options);
const resolvedCompletionsReasoningEffort = completionsReasoningEffort ? resolveOpenAIReasoningEffortForModel({
model,
effort: completionsReasoningEffort,
fallbackMap: compat.reasoningEffortMap
}) : void 0;
const omitGpt54MiniToolReasoningEffort = isOpenAIGpt54MiniModel(model) && Array.isArray(params.tools) && params.tools.length > 0;
const handledQwenThinkingFormat = applyQwenOpenAICompletionsThinkingParams({
compatThinkingFormat: compat.thinkingFormat,
modelReasoning: model.reasoning,
payload: params,
requestedEffort: completionsReasoningEffort
});
applyTogetherOpenAICompletionsThinkingParams({
compatThinkingFormat: compat.thinkingFormat,
modelReasoning: model.reasoning,
payload: params,
requestedEffort: completionsReasoningEffort
});
if (compat.thinkingFormat === "openrouter" && model.reasoning && resolvedCompletionsReasoningEffort) params.reasoning = { effort: resolvedCompletionsReasoningEffort };
else if (resolvedCompletionsReasoningEffort && model.reasoning && compat.supportsReasoningEffort && !handledQwenThinkingFormat && !omitGpt54MiniToolReasoningEffort) params.reasoning_effort = resolvedCompletionsReasoningEffort;
return params;
}
function parseTransportChunkUsage(rawUsage, model) {
const cachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
const promptTokens = rawUsage.prompt_tokens || 0;
const input = Math.max(0, promptTokens - cachedTokens);
const outputTokens = rawUsage.completion_tokens || 0;
const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
const usage = {
input,
output: outputTokens,
cacheRead: cachedTokens,
cacheWrite: 0,
...typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? { reasoningTokens } : {},
totalTokens: input + outputTokens + cachedTokens,
cost: {
input: 0,
output: 0,
cacheRead: 0,
cacheWrite: 0,
total: 0
}
};
calculateCost(model, usage);
return usage;
}
function hasOpenAICompletionsReasoningUsageActivity(rawUsage) {
const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens;
return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) && reasoningTokens > 0;
}
function mapStopReason(reason) {
if (reason === null) return { stopReason: "stop" };
switch (reason) {
case "stop":
case "end": return { stopReason: "stop" };
case "length": return { stopReason: "length" };
case "function_call":
case "tool_call":
case "tool_calls": return { stopReason: "toolUse" };
case "content_filter": return {
stopReason: "error",
errorMessage: "Provider finish_reason: content_filter"
};
case "network_error": return {
stopReason: "error",
errorMessage: "Provider finish_reason: network_error"
};
default: return {
stopReason: "error",
errorMessage: `Provider finish_reason: ${reason}`
};
}
}
//#endregion
export { emitModelTransportDebug as C, stripCompletionMessagesToRoleContent as S, resolveMaxTokensParam as _, coerceTransportToolCallArguments as a, resolveOpenAIReasoningEffortForModel as b, failTransportStream as c, sanitizeNonEmptyTransportPayloadText as d, sanitizeTransportPayloadText as f, canonicalizeMaxTokensParam as g, supportsModelTools as h, createOpenAIResponsesTransportStreamFn as i, finalizeTransportStream as l, buildGuardedModelFetch as m, createAzureOpenAIResponsesTransportStreamFn as n, createEmptyTransportUsage as o, transformTransportMessages as p, createOpenAICompletionsTransportStreamFn as r, createWritableTransportEventStream as s, buildOpenAICompletionsParams as t, mergeTransportHeaders as u, applyOpenAIResponsesPayloadPolicy as v, flattenCompletionMessagesToStringContent as x, resolveOpenAIResponsesPayloadPolicy as y };