@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/openai-responses-contracts-XpZJxrRG.d.mts

@@ -0,0 +1,68 @@
+import { n as Api } from "./types-BHNrPS1l.mjs";
+import { f as OpenAIApiReasoningEffort, i as BaseOpenAIStreamOptions, p as OpenAIReasoningEffort } from "./provider-options-B96RdNpH.mjs";
+import { FunctionTool, ResponseCompactionItem, ResponseCreateParamsStreaming, ResponseInput } from "openai/resources/responses/responses.js";
+
+//#region packages/ai/src/transports/openai-responses-contracts.d.ts
+declare const OPENAI_RESPONSES_APIS: ReadonlySet<Api>;
+type ReplayableResponseCompactionItem = Omit<ResponseCompactionItem, "id"> & {
+  id?: string;
+};
+type OpenAIResponsesReasoningReplayMetadata = {
+  v: 1;
+  source: "openai-responses";
+  provider: string;
+  api: Api;
+  model: string;
+  baseUrlHash?: string;
+  sessionHash?: string;
+  authProfileHash?: string;
+};
+type OpenAIResponsesOptions = BaseOpenAIStreamOptions & {
+  reasoning?: OpenAIReasoningEffort;
+  reasoningEffort?: OpenAIReasoningEffort;
+  reasoningSummary?: "auto" | "detailed" | "concise" | null;
+  replayResponsesItemIds?: boolean;
+  serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+  toolChoice?: ResponseCreateParamsStreaming["tool_choice"];
+};
+type ResponsesPromptObservation = {
+  egress: "responses-sdk" | "responses-websocket" | "native-codex-websocket" | "native-codex-sse";
+  payloadVariant: "initial" | "reasoning-stripped" | "compaction-stripped" | "continuation-rejected";
+  promptSource: "instructions" | "input.developer" | "input.system" | "missing";
+  expectedChars: number;
+  observedChars: number;
+  matchesAssembledPrompt: boolean;
+};
+type ResponsesPromptObserver = (observation: ResponsesPromptObservation) => void;
+declare const responsesPromptObserver: {
+  set(options: object, observer: ResponsesPromptObserver): void;
+  get(options: object): ResponsesPromptObserver | undefined;
+  copy(source: object | undefined, target: object): void;
+};
+type OpenAIResponsesRequestParams = {
+  model: string;
+  input: ResponseInput;
+  stream: true;
+  instructions?: string;
+  prompt_cache_key?: string;
+  prompt_cache_retention?: "24h";
+  metadata?: Record<string, string>;
+  previous_response_id?: string;
+  store?: boolean;
+  max_output_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  text?: ResponseCreateParamsStreaming["text"];
+  service_tier?: ResponseCreateParamsStreaming["service_tier"];
+  tools?: FunctionTool[];
+  tool_choice?: ResponseCreateParamsStreaming["tool_choice"];
+  reasoning?: {
+    effort: OpenAIApiReasoningEffort;
+  } | {
+    effort: OpenAIApiReasoningEffort;
+    summary: NonNullable<OpenAIResponsesOptions["reasoningSummary"]>;
+  };
+  include?: string[];
+};
+//#endregion
+export { ReplayableResponseCompactionItem as a, OpenAIResponsesRequestParams as i, OpenAIResponsesOptions as n, ResponsesPromptObservation as o, OpenAIResponsesReasoningReplayMetadata as r, responsesPromptObserver as s, OPENAI_RESPONSES_APIS as t };

package/dist/openai-responses-payload-policy-BDxV-W0c.mjs

@@ -0,0 +1,206 @@
+import { i as normalizeOptionalLowercaseString, n as normalizeLowercaseStringOrEmpty, s as readStringValue } from "./string-coerce-fsri9iCu.mjs";
+import { s as parseStrictPositiveInteger } from "./number-coercion-H9qHik3g.mjs";
+import { i as OPENAI_RESPONSES_APIS, x as supportsOpenAIReasoningEffort } from "./openai-responses-contracts-CyfIkQi5.mjs";
+//#region packages/model-catalog-core/src/provider-id.ts
+function normalizeProviderId(provider) {
+	return normalizeLowercaseStringOrEmpty(provider);
+}
+//#endregion
+//#region packages/ai/src/transports/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_PROVIDERS = /* @__PURE__ */ new Set([
+	"openai",
+	"azure-openai",
+	"azure-openai-responses"
+]);
+const LOCAL_ENDPOINT_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1",
+	"[::1]"
+]);
+const MODELSTUDIO_NATIVE_BASE_URLS = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set(["https://api.moonshot.ai/v1", "https://api.moonshot.cn/v1"]);
+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 ([
+		".openai.azure.com",
+		".cognitiveservices.azure.com",
+		".services.ai.azure.com",
+		".api.cognitive.microsoft.com"
+	].some((suffix) => hostMatchesSuffix(host, suffix))) 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;
+	const value = compat[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function resolveOpenAIResponsesPayloadCapabilities(model) {
+	const provider = normalizeOptionalLowercaseString(model.provider);
+	const api = normalizeOptionalLowercaseString(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 === "openclaw-openai-chatgpt-responses-transport" || api === "openai-responses" || api === "openclaw-openai-responses-transport") && endpointClass === "openai",
+		allowsResponsesStore: supportsResponsesStoreField && api !== "openai-chatgpt-responses" && api !== "openclaw-openai-chatgpt-responses-transport" && 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;
+}
+/** Resolve the server-compaction gate and effective threshold for a Responses route. */
+function resolveOpenAIResponsesServerCompactionPlan(model, extraParams) {
+	const provider = normalizeOptionalLowercaseString(model.provider);
+	const allowsResponsesStore = resolveOpenAIResponsesPayloadCapabilities(model).allowsResponsesStore;
+	const configured = extraParams?.responsesServerCompaction;
+	const enabled = configured !== false && allowsResponsesStore && (configured === true || provider === "openai");
+	return {
+		enabled,
+		threshold: enabled ? parsePositiveInteger(extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model) : void 0
+	};
+}
+/** Resolve the manual Responses compact-endpoint gate for one route. */
+function resolveOpenAIResponsesCompactEndpointPlan(model, extraParams) {
+	const configured = extraParams?.responsesCompactEndpoint;
+	const provider = typeof model.provider === "string" ? normalizeProviderId(model.provider) : "";
+	return { enabled: isOpenAIResponsesApi(normalizeOptionalLowercaseString(model.api)) && (configured === true || configured !== false && (provider === "xai" || provider === "x-ai") && resolveBundledOpenAIResponsesEndpointClass(model.baseUrl) === "xai-native") };
+}
+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;
+}
+/** Strip returned-item metadata rejected by strict Responses-compatible endpoints. */
+function stripInputItemStatuses(input) {
+	if (!Array.isArray(input)) return;
+	for (const item of input) if (item && typeof item === "object" && !Array.isArray(item)) delete item.status;
+}
+/** 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(normalizeOptionalLowercaseString(model.api));
+	const shouldStripDisabledReasoningPayload = isResponsesApi && (!capabilities.usesKnownNativeOpenAIRoute || !supportsOpenAIReasoningEffort(model, "none"));
+	const shouldStripInputStatus = isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute;
+	const serverCompactionPlan = resolveOpenAIResponsesServerCompactionPlan(model, options.extraParams);
+	return {
+		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
+		compactThreshold: serverCompactionPlan.threshold,
+		explicitStore,
+		shouldStripDisabledReasoningPayload,
+		shouldStripInputStatus,
+		shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
+		shouldStripStore: explicitStore !== true && readCompatPayloadBoolean(model.compat, "supportsStore") === false && isResponsesApi,
+		useServerCompaction: options.enableServerCompaction === true && serverCompactionPlan.enabled
+	};
+}
+/** 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 && policy.compactThreshold !== void 0 && payloadObj.context_management === void 0) payloadObj.context_management = [{
+		type: "compaction",
+		compact_threshold: policy.compactThreshold
+	}];
+	if (policy.shouldStripDisabledReasoningPayload) stripDisabledOpenAIReasoningPayload(payloadObj);
+	if (policy.shouldStripInputStatus) stripInputItemStatuses(payloadObj.input);
+}
+//#endregion
+export { resolveOpenAIResponsesServerCompactionPlan as i, resolveOpenAIResponsesCompactEndpointPlan as n, resolveOpenAIResponsesPayloadPolicy as r, applyOpenAIResponsesPayloadPolicy as t };

package/dist/openai-responses-payload-policy-BSs371VM.d.mts

@@ -0,0 +1,40 @@
+//#region packages/ai/src/transports/openai-responses-payload-policy.d.ts
+type OpenAIResponsesPayloadModel = {
+  api?: unknown;
+  baseUrl?: unknown;
+  id?: unknown;
+  provider?: unknown;
+  contextWindow?: unknown;
+  compat?: unknown;
+};
+type OpenAIResponsesPayloadPolicyOptions = {
+  extraParams?: Record<string, unknown>;
+  storeMode?: "provider-policy" | "disable" | "preserve";
+  enablePromptCacheStripping?: boolean;
+  enableServerCompaction?: boolean;
+};
+type OpenAIResponsesPayloadPolicy = {
+  allowsServiceTier: boolean;
+  compactThreshold: number | undefined;
+  explicitStore: boolean | undefined;
+  shouldStripDisabledReasoningPayload: boolean;
+  shouldStripInputStatus: boolean;
+  shouldStripPromptCache: boolean;
+  shouldStripStore: boolean;
+  useServerCompaction: boolean;
+};
+/** Resolve the server-compaction gate and effective threshold for a Responses route. */
+declare function resolveOpenAIResponsesServerCompactionPlan(model: OpenAIResponsesPayloadModel, extraParams?: Record<string, unknown>): {
+  enabled: boolean;
+  threshold: number | undefined;
+};
+/** Resolve the manual Responses compact-endpoint gate for one route. */
+declare function resolveOpenAIResponsesCompactEndpointPlan(model: OpenAIResponsesPayloadModel, extraParams?: Record<string, unknown>): {
+  enabled: boolean;
+};
+/** Resolve payload mutation policy for one OpenAI Responses-style model endpoint. */
+declare function resolveOpenAIResponsesPayloadPolicy(model: OpenAIResponsesPayloadModel, options?: OpenAIResponsesPayloadPolicyOptions): OpenAIResponsesPayloadPolicy;
+/** Mutate a Responses request payload according to the resolved endpoint policy. */
+declare function applyOpenAIResponsesPayloadPolicy(payloadObj: Record<string, unknown>, policy: OpenAIResponsesPayloadPolicy): void;
+//#endregion
+export { resolveOpenAIResponsesServerCompactionPlan as i, resolveOpenAIResponsesCompactEndpointPlan as n, resolveOpenAIResponsesPayloadPolicy as r, applyOpenAIResponsesPayloadPolicy as t };

package/dist/openai-responses-prompt-observer-internal-DgNTYnRY.mjs

@@ -0,0 +1,46 @@
+import { m as responsesPromptObserver } from "./openai-responses-contracts-CyfIkQi5.mjs";
+import { l as stripSystemPromptCacheBoundary } from "./simple-options-D58D5Kvw.mjs";
+import { d as sanitizeTransportPayloadText } from "./provider-transcript-transform-ePx-Bbfr.mjs";
+//#region packages/normalization-core/src/error-coercion.ts
+/**
+* Normalizes an unknown thrown value into an Error. Non-Error objects become
+* the `cause` and have their enumerable fields copied so structured details
+* (codes, statuses) survive the coercion.
+*/
+function toErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#endregion
+//#region packages/ai/src/transports/openai-responses-prompt-observer-internal.ts
+function readFinalResponsesPrompt(request) {
+	if (typeof request.instructions === "string") return ["instructions", request.instructions];
+	const message = (Array.isArray(request.input) ? request.input : []).find((item) => {
+		const role = item.role;
+		return role === "developer" || role === "system";
+	});
+	if (!message) return ["missing", ""];
+	const content = message.content;
+	const observedPrompt = typeof content === "string" ? content : Array.isArray(content) ? content.flatMap((part) => part.type === "input_text" ? [part.text] : []).join("") : "";
+	return [message.role === "developer" ? "input.developer" : "input.system", observedPrompt];
+}
+function createResponsesPromptEgressObserver(options, assembledPrompt) {
+	const observer = options ? responsesPromptObserver.get(options) : void 0;
+	if (!observer) return;
+	const expectedPrompt = sanitizeTransportPayloadText(stripSystemPromptCacheBoundary(assembledPrompt ?? ""));
+	return (request, metadata) => {
+		const [promptSource, observedPrompt] = readFinalResponsesPrompt(request);
+		observer({
+			...metadata,
+			promptSource,
+			expectedChars: expectedPrompt.length,
+			observedChars: observedPrompt.length,
+			matchesAssembledPrompt: promptSource !== "missing" && observedPrompt === expectedPrompt
+		});
+	};
+}
+//#endregion
+export { toErrorObject as n, createResponsesPromptEgressObserver as t };