@fased/fased 0.1.55 → 0.1.57

package/dist/agents/pi-embedded-runner/extra-params.js

@@ -1,5 +1,17 @@
+import { resolveFasedAgentAgentDir } from "../agent-paths.js";
+import { ensureAuthProfileStore } from "../auth-profiles/store.js";
+import { listProfilesForProvider } from "../auth-profiles/profiles.js";
+import { loadConfig, writeConfigFile } from "../../config/io.js";
+import "../../config/config.js";
+import { resolveApiKeyForProfile } from "../auth-profiles/oauth.js";
+import "../auth-profiles.js";
+import { createOpenAICodexAppServerStreamFn } from "../openai-codex-app-server.js";
+import { ensureOpenAICodexRuntimeComponent } from "../openai-codex-runtime-component.js";
 import { log } from "./logger.js";
+import { createMoonshotThinkingWrapper, resolveMoonshotThinkingType } from "./moonshot-stream-wrappers.js";
+import { createOpenAIResponsesContextManagementWrapper } from "./openai-stream-wrappers.js";
 import { streamSimple } from "@mariozechner/pi-ai/compat";
+import WebSocket$1 from "ws";
 
 //#region src/agents/pi-embedded-runner/extra-params.ts
 const OPENROUTER_APP_HEADERS = {
@@ -8,8 +20,6 @@ const OPENROUTER_APP_HEADERS = {
 };
 const ANTHROPIC_CONTEXT_1M_BETA = "context-1m-2025-08-07";
 const ANTHROPIC_1M_MODEL_PREFIXES = ["claude-opus-4", "claude-sonnet-4"];
-const OPENAI_RESPONSES_APIS = new Set(["openai-responses"]);
-const OPENAI_RESPONSES_PROVIDERS = new Set(["openai"]);
 const defaultProviderRuntimeDeps = {
 	prepareProviderExtraParams: ({ context }) => context.extraParams,
 	wrapProviderStreamFn: ({ context }) => context.streamFn
@@ -21,6 +31,30 @@ function sanitizeExtraParams(input) {
 	}
 	return Object.fromEntries(Object.entries(input).filter(([key, value]) => value !== undefined && key !== "__proto__" && key !== "constructor" && key !== "prototype"));
 }
+function normalizeExtraParamAliases(input) {
+	const normalized = sanitizeExtraParams(input);
+	if (Object.hasOwn(normalized, "parallelToolCalls")) {
+		normalized.parallel_tool_calls = normalized.parallelToolCalls;
+		delete normalized.parallelToolCalls;
+	}
+	if (Object.hasOwn(normalized, "textVerbosity")) {
+		normalized.text_verbosity = normalized.textVerbosity;
+		delete normalized.textVerbosity;
+	}
+	return normalized;
+}
+function defaultExtraParams(provider, modelId) {
+	const normalizedProvider = provider.trim().toLowerCase();
+	const normalizedModel = modelId.trim().toLowerCase();
+	if (normalizedProvider === "openai" && /^gpt-5(?:\.|$|-)/.test(normalizedModel)) {
+		return {
+			parallel_tool_calls: true,
+			text_verbosity: "low",
+			openaiWsWarmup: true
+		};
+	}
+	return {};
+}
 const testing = {
 	setProviderRuntimeDepsForTest(deps) {
 		providerRuntimeDeps.prepareProviderExtraParams = deps?.prepareProviderExtraParams ?? defaultProviderRuntimeDeps.prepareProviderExtraParams;
@@ -37,18 +71,35 @@ const testing = {
 *
 * @internal Exported for testing only
 */
-function resolveExtraParams(params) {
+function resolveConfiguredExtraParams(params) {
 	const modelKey = `${params.provider}/${params.modelId}`;
 	const modelConfig = params.cfg?.agents?.defaults?.models?.[modelKey];
-	const globalParams = modelConfig?.params ? { ...modelConfig.params } : undefined;
-	const agentParams = params.agentId && params.cfg?.agents?.list ? params.cfg.agents.list.find((agent) => agent.id === params.agentId)?.params : undefined;
-	if (!globalParams && !agentParams) {
+	const globalParams = modelConfig?.params ? normalizeExtraParamAliases(modelConfig.params) : undefined;
+	const rawAgentParams = params.agentId && params.cfg?.agents?.list ? params.cfg.agents.list.find((agent) => agent.id === params.agentId)?.params : undefined;
+	const agentParams = rawAgentParams ? normalizeExtraParamAliases(rawAgentParams) : undefined;
+	const defaults = defaultExtraParams(params.provider, params.modelId);
+	if (Object.keys(defaults).length === 0 && !globalParams && !agentParams) {
 		return undefined;
 	}
-	return Object.assign({}, globalParams, agentParams);
+	return Object.assign({}, defaults, globalParams, agentParams);
+}
+function resolveExtraParams(params) {
+	const configured = resolveConfiguredExtraParams(params);
+	const prepared = providerRuntimeDeps.prepareProviderExtraParams({
+		provider: params.provider,
+		modelId: params.modelId,
+		config: params.cfg,
+		context: {
+			config: params.cfg,
+			provider: params.provider,
+			modelId: params.modelId,
+			extraParams: configured
+		}
+	});
+	return prepared ?? configured;
 }
 function resolvePreparedExtraParams(params) {
-	const extraParams = resolveExtraParams({
+	const extraParams = resolveConfiguredExtraParams({
 		cfg: params.cfg,
 		provider: params.provider,
 		modelId: params.modelId,
@@ -56,7 +107,7 @@ function resolvePreparedExtraParams(params) {
 	});
 	const merged = {
 		...sanitizeExtraParams(extraParams),
-		...sanitizeExtraParams(params.extraParamsOverride)
+		...normalizeExtraParamAliases(params.extraParamsOverride)
 	};
 	const prepared = providerRuntimeDeps.prepareProviderExtraParams({
 		provider: params.provider,
@@ -101,10 +152,6 @@ function resolveAgentTransportOverride(params) {
 * Defaults to "short" for direct Anthropic when not explicitly configured.
 */
 function resolveCacheRetention(extraParams, provider) {
-	const isAnthropicDirect = provider === "anthropic";
-	if (!isAnthropicDirect) {
-		return undefined;
-	}
 	const newVal = extraParams?.cacheRetention;
 	if (newVal === "none" || newVal === "short" || newVal === "long") {
 		return newVal;
@@ -116,10 +163,7 @@ function resolveCacheRetention(extraParams, provider) {
 	if (legacy === "1h") {
 		return "long";
 	}
-	if (!isAnthropicDirect) {
-		return undefined;
-	}
-	return "short";
+	return provider === "anthropic" ? "short" : undefined;
 }
 function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider) {
 	if (!extraParams || Object.keys(extraParams).length === 0) {
@@ -132,6 +176,9 @@ function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider) {
 	if (typeof extraParams.maxTokens === "number") {
 		streamParams.maxTokens = extraParams.maxTokens;
 	}
+	if (typeof extraParams.openaiWsWarmup === "boolean") {
+		streamParams.openaiWsWarmup = extraParams.openaiWsWarmup;
+	}
 	const transport = extraParams.transport;
 	if (transport === "sse" || transport === "websocket" || transport === "auto") {
 		streamParams.transport = transport;
@@ -167,6 +214,36 @@ function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider) {
 	};
 	return wrappedStreamFn;
 }
+function createParallelToolCallsWrapper(baseStreamFn, value) {
+	if (value === undefined || value === null) {
+		return undefined;
+	}
+	if (typeof value !== "boolean") {
+		const rendered = typeof value === "string" || typeof value === "number" || typeof value === "bigint" ? String(value) : JSON.stringify(value) ?? typeof value;
+		log.warn(`ignoring invalid parallel_tool_calls param: ${rendered}`);
+		return undefined;
+	}
+	const underlying = baseStreamFn ?? streamSimple;
+	return (model, context, options) => {
+		const supported = model.api === "openai-completions" || model.api === "openai-responses" || model.api === "azure-openai-responses";
+		if (!supported) {
+			return underlying(model, context, options);
+		}
+		const originalOnPayload = options?.onPayload;
+		return underlying(model, context, {
+			...options,
+			onPayload: (payload) => {
+				if (payload && typeof payload === "object") {
+					payload.parallel_tool_calls = value;
+				}
+				return originalOnPayload?.(payload);
+			}
+		});
+	};
+}
+function isOllamaKimiCloudModel(provider, modelId) {
+	return provider === "ollama" && /^kimi(?:[-:]|$)/i.test(modelId) && /:cloud$/i.test(modelId);
+}
 function isDirectOpenAIBaseUrl(baseUrl) {
 	if (typeof baseUrl !== "string" || !baseUrl.trim()) {
 		return false;
@@ -179,21 +256,6 @@ function isDirectOpenAIBaseUrl(baseUrl) {
 		return normalized.includes("api.openai.com") || normalized.includes("chatgpt.com") || normalized.includes(".openai.azure.com");
 	}
 }
-function shouldForceResponsesStore(model) {
-	if (model.compat?.supportsStore === false) {
-		return false;
-	}
-	if (typeof model.api !== "string" || typeof model.provider !== "string") {
-		return false;
-	}
-	if (!OPENAI_RESPONSES_APIS.has(model.api)) {
-		return false;
-	}
-	if (!OPENAI_RESPONSES_PROVIDERS.has(model.provider)) {
-		return false;
-	}
-	return isDirectOpenAIBaseUrl(model.baseUrl);
-}
 function parsePositiveInteger(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
 		return Math.floor(value);
@@ -298,56 +360,6 @@ function resolveOpenRouterResponseCacheHeaders(params) {
 	}
 	return Object.keys(headers).length > 0 ? headers : undefined;
 }
-function resolveOpenAIResponsesCompactThreshold(model) {
-	const contextWindow = parsePositiveInteger(model.contextWindow);
-	if (contextWindow) {
-		return Math.max(1e3, Math.floor(contextWindow * .7));
-	}
-	return 8e4;
-}
-function shouldEnableOpenAIResponsesServerCompaction(model, extraParams) {
-	const configured = extraParams?.responsesServerCompaction;
-	if (configured === false) {
-		return false;
-	}
-	if (!shouldForceResponsesStore(model)) {
-		return false;
-	}
-	if (configured === true) {
-		return true;
-	}
-	return model.provider === "openai";
-}
-function createOpenAIResponsesContextManagementWrapper(baseStreamFn, extraParams) {
-	const underlying = baseStreamFn ?? streamSimple;
-	return (model, context, options) => {
-		const forceStore = shouldForceResponsesStore(model);
-		const useServerCompaction = shouldEnableOpenAIResponsesServerCompaction(model, extraParams);
-		if (!forceStore && !useServerCompaction) {
-			return underlying(model, context, options);
-		}
-		const compactThreshold = parsePositiveInteger(extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model);
-		const originalOnPayload = options?.onPayload;
-		return underlying(model, context, {
-			...options,
-			onPayload: (payload) => {
-				if (payload && typeof payload === "object") {
-					const payloadObj = payload;
-					if (forceStore) {
-						payloadObj.store = true;
-					}
-					if (useServerCompaction && payloadObj.context_management === undefined) {
-						payloadObj.context_management = [{
-							type: "compaction",
-							compact_threshold: compactThreshold
-						}];
-					}
-				}
-				originalOnPayload?.(payload);
-			}
-		});
-	};
-}
 function createOpenAIReasoningEffortWrapper(baseStreamFn, reasoningEffort) {
 	const underlying = baseStreamFn ?? streamSimple;
 	return (model, context, options) => {
@@ -374,10 +386,54 @@ function createOpenAIReasoningEffortWrapper(baseStreamFn, reasoningEffort) {
 }
 function createCodexDefaultTransportWrapper(baseStreamFn) {
 	const underlying = baseStreamFn ?? streamSimple;
-	return (model, context, options) => underlying(model, context, {
-		...options,
-		transport: options?.transport ?? "auto"
+	return (model, context, options) => {
+		if (typeof process !== "undefined" && process.versions?.node) {
+			globalThis.WebSocket = WebSocket$1;
+		}
+		return underlying(model, context, {
+			...options,
+			transport: options?.transport ?? "auto"
+		});
+	};
+}
+function usesCodexResponsesLite(model) {
+	const candidate = model;
+	return candidate.api === "openai-codex-responses" && candidate.compat?.responsesLite === true;
+}
+function createCodexResponsesLiteWrapper(baseStreamFn, params) {
+	const underlying = baseStreamFn ?? streamSimple;
+	const appServer = createOpenAICodexAppServerStreamFn({
+		resolveExecutable: async () => {
+			const runtime = await ensureOpenAICodexRuntimeComponent({ config: params?.cfg ?? loadConfig() });
+			if (runtime.installed) {
+				await writeConfigFile(runtime.config);
+			}
+			return runtime.executable;
+		},
+		resolveToken: async () => {
+			if (params?.resolvedApiKey?.trim()) {
+				return params.resolvedApiKey.trim();
+			}
+			const agentDir = params?.agentDir ?? resolveFasedAgentAgentDir();
+			const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
+			const profileId = listProfilesForProvider(store, "openai-codex")[0];
+			if (!profileId) {
+				return undefined;
+			}
+			return (await resolveApiKeyForProfile({
+				cfg: params?.cfg ?? {},
+				store,
+				profileId,
+				agentDir
+			}))?.apiKey;
+		}
 	});
+	return (model, context, options) => {
+		if (!usesCodexResponsesLite(model)) {
+			return underlying(model, context, options);
+		}
+		return appServer(model, context, options);
+	};
 }
 function isAnthropic1MModel(modelId) {
 	const normalized = modelId.trim().toLowerCase();
@@ -757,8 +813,8 @@ function createZaiToolStreamWrapper(baseStreamFn, enabled) {
 *
 * @internal Exported for testing
 */
-function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverride, thinkingLevel, agentId, agentDir, model) {
-	const extraParams = resolveExtraParams({
+function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverride, thinkingLevel, agentId, agentDir, model, resolvedApiKey) {
+	const extraParams = resolveConfiguredExtraParams({
 		cfg,
 		provider,
 		modelId,
@@ -766,8 +822,13 @@ function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverr
 	});
 	if (provider === "openai-codex") {
 		agent.streamFn = createCodexDefaultTransportWrapper(agent.streamFn);
+		agent.streamFn = createCodexResponsesLiteWrapper(agent.streamFn, {
+			cfg,
+			agentDir,
+			resolvedApiKey
+		});
 	}
-	const merged = Object.assign({}, sanitizeExtraParams(extraParams), sanitizeExtraParams(extraParamsOverride));
+	const merged = Object.assign({}, sanitizeExtraParams(extraParams), normalizeExtraParamAliases(extraParamsOverride));
 	const preparedProviderExtraParams = providerRuntimeDeps.prepareProviderExtraParams({
 		provider,
 		modelId,
@@ -783,6 +844,7 @@ function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverr
 		}
 	});
 	const effectiveProviderExtraParams = preparedProviderExtraParams ?? merged;
+	const streamFnBeforeProviderHook = agent.streamFn;
 	const providerWrappedStreamFn = providerRuntimeDeps.wrapProviderStreamFn({
 		provider,
 		config: cfg,
@@ -805,12 +867,17 @@ function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverr
 	if (providerWrappedStreamFn) {
 		agent.streamFn = providerWrappedStreamFn;
 	}
-	const wrappedStreamFn = createStreamFnWithExtraParams(agent.streamFn, merged, provider);
+	const providerRuntimeHandled = providerWrappedStreamFn !== undefined && providerWrappedStreamFn !== streamFnBeforeProviderHook;
+	const wrappedStreamFn = createStreamFnWithExtraParams(agent.streamFn, effectiveProviderExtraParams, provider);
 	if (wrappedStreamFn) {
 		log.debug(`applying extraParams to agent streamFn for ${provider}/${modelId}`);
 		agent.streamFn = wrappedStreamFn;
 	}
-	const anthropicBetas = resolveAnthropicBetas(merged, provider, modelId);
+	const parallelToolCalls = createParallelToolCallsWrapper(agent.streamFn, effectiveProviderExtraParams.parallel_tool_calls);
+	if (parallelToolCalls) {
+		agent.streamFn = parallelToolCalls;
+	}
+	const anthropicBetas = resolveAnthropicBetas(effectiveProviderExtraParams, provider, modelId);
 	if (anthropicBetas?.length) {
 		log.debug(`applying Anthropic beta header for ${provider}/${modelId}: ${anthropicBetas.join(",")}`);
 		agent.streamFn = createAnthropicBetaHeadersWrapper(agent.streamFn, anthropicBetas);
@@ -823,12 +890,21 @@ function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverr
 		log.debug(`normalizing thinking=off to thinking=null for SiliconFlow compatibility (${provider}/${modelId})`);
 		agent.streamFn = createSiliconFlowThinkingWrapper(agent.streamFn);
 	}
-	if (provider === "openrouter") {
+	if (provider === "openrouter" && !providerRuntimeHandled) {
 		log.debug(`applying OpenRouter app attribution headers for ${provider}/${modelId}`);
 		const openRouterThinkingLevel = modelId === "auto" ? undefined : thinkingLevel;
-		agent.streamFn = createOpenRouterWrapper(agent.streamFn, openRouterThinkingLevel, resolveOpenRouterResponseCacheConfig(merged));
+		agent.streamFn = createOpenRouterWrapper(agent.streamFn, openRouterThinkingLevel, resolveOpenRouterResponseCacheConfig(effectiveProviderExtraParams));
 		agent.streamFn = createOpenRouterSystemCacheWrapper(agent.streamFn);
 	}
+	if (provider === "moonshot" || isOllamaKimiCloudModel(provider, modelId)) {
+		const configuredThinking = effectiveProviderExtraParams.thinking;
+		const hasPinnedToolChoice = model && typeof model === "object" && "tool_choice" in model && typeof model.tool_choice === "object";
+		const thinkingType = hasPinnedToolChoice ? "disabled" : resolveMoonshotThinkingType({
+			configuredThinking,
+			thinkingLevel
+		});
+		agent.streamFn = createMoonshotThinkingWrapper(agent.streamFn, thinkingType);
+	}
 	if (provider === "zai" || provider === "z-ai") {
 		const toolStreamEnabled = merged?.tool_stream !== false;
 		if (toolStreamEnabled) {
@@ -837,9 +913,9 @@ function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraParamsOverr
 		}
 	}
 	agent.streamFn = createGoogleThinkingPayloadWrapper(agent.streamFn, thinkingLevel);
-	agent.streamFn = createOpenAIResponsesContextManagementWrapper(agent.streamFn, merged);
+	agent.streamFn = createOpenAIResponsesContextManagementWrapper(agent.streamFn, effectiveProviderExtraParams);
 	agent.streamFn = createOpenAIReasoningEffortWrapper(agent.streamFn, thinkingLevel);
 }
 
 //#endregion
-export { applyExtraParamsToAgent, resolveExtraParams };
+export { applyExtraParamsToAgent };

package/dist/agents/pi-embedded-runner/model.js

@@ -2,9 +2,13 @@ import { isOpenAISignInRuntimeModelSupported } from "../../providers/registry.js
 import { DEFAULT_CONTEXT_TOKENS } from "../defaults.js";
 import { isPrivateNetworkBaseUrl } from "../../utils/private-network-url.js";
 import { resolveFasedAgentAgentDir } from "../agent-paths.js";
+import { ensureAuthProfileStore } from "../auth-profiles/store.js";
+import "../auth-profiles.js";
 import { normalizeProviderId } from "../model-selection.js";
 import { discoverAuthStorage, discoverModels } from "../pi-model-discovery.js";
+import { resolveAuthenticatedModelCatalog } from "../authenticated-model-catalog.js";
 import { buildModelAliasLines } from "../model-alias-lines.js";
+import { loadModelCatalog } from "../model-catalog.js";
 import { normalizeModelCompat } from "../model-compat.js";
 import { resolveForwardCompatModel } from "../model-forward-compat.js";
 import { attachModelProviderRequestTransport, sanitizeConfiguredModelProviderRequest } from "../provider-request-config.js";
@@ -143,6 +147,63 @@ function resolveModel(provider, modelId, agentDir, cfg) {
 		modelRegistry
 	};
 }
+async function resolveModelForExecution(provider, modelId, agentDir, cfg) {
+	const resolvedAgentDir = agentDir ?? resolveFasedAgentAgentDir();
+	const fallback = resolveModel(provider, modelId, resolvedAgentDir, cfg);
+	if (!cfg) {
+		return fallback;
+	}
+	try {
+		const store = ensureAuthProfileStore(resolvedAgentDir, { allowKeychainPrompt: false });
+		const catalog = await loadModelCatalog({
+			config: cfg,
+			includeMetadata: true
+		});
+		const authenticated = await resolveAuthenticatedModelCatalog({
+			cfg,
+			store,
+			catalog,
+			defaultProvider: provider,
+			agentDir: resolvedAgentDir
+		});
+		const normalizedProvider = normalizeProviderId(provider);
+		const normalizedModelId = modelId.trim().toLowerCase();
+		const entry = authenticated.usableCatalog.find((candidate) => normalizeProviderId(candidate.provider) === normalizedProvider && candidate.id.trim().toLowerCase() === normalizedModelId);
+		if (!entry) {
+			return fallback;
+		}
+		const template = fallback.model;
+		const model = normalizeModelCompat({
+			...template,
+			id: entry.id,
+			name: entry.name,
+			provider: entry.provider,
+			api: entry.api ?? template?.api,
+			baseUrl: entry.baseUrl ?? template?.baseUrl,
+			reasoning: entry.reasoning ?? template?.reasoning ?? false,
+			input: entry.input ?? template?.input ?? ["text"],
+			contextWindow: entry.contextWindow ?? template?.contextWindow ?? DEFAULT_CONTEXT_TOKENS,
+			maxTokens: entry.maxTokens ?? template?.maxTokens ?? DEFAULT_CONTEXT_TOKENS,
+			cost: entry.cost ?? template?.cost ?? {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0
+			},
+			compat: {
+				...template?.compat,
+				...entry.compat
+			}
+		});
+		return {
+			...fallback,
+			model: attachConfiguredProviderRequest(model, cfg),
+			error: undefined
+		};
+	} catch {
+		return fallback;
+	}
+}
 function resolveModelWithRegistry(params) {
 	const normalizedProvider = normalizeProviderId(params.provider);
 	const runtimeModelId = params.modelId.trim();
@@ -174,4 +235,4 @@ function buildUnknownModelError(provider, modelId) {
 }
 
 //#endregion
-export { buildInlineProviderModels, buildModelAliasLines, resolveModel, resolveModelWithRegistry };
+export { buildInlineProviderModels, buildModelAliasLines, resolveModel, resolveModelForExecution, resolveModelWithRegistry };

package/dist/agents/pi-embedded-runner/moonshot-stream-wrappers.js

@@ -0,0 +1,46 @@
+import { streamSimple } from "@mariozechner/pi-ai/compat";
+
+//#region src/agents/pi-embedded-runner/moonshot-stream-wrappers.ts
+function resolveMoonshotThinkingType(params) {
+	if (params.configuredThinking && typeof params.configuredThinking === "object" && !Array.isArray(params.configuredThinking)) {
+		const type = params.configuredThinking.type;
+		if (type === "enabled" || type === "disabled") {
+			return type;
+		}
+	}
+	if (params.configuredThinking === "enabled" || params.configuredThinking === true) {
+		return "enabled";
+	}
+	if (params.configuredThinking === "disabled" || params.configuredThinking === false) {
+		return "disabled";
+	}
+	return params.thinkingLevel && params.thinkingLevel !== "off" ? "enabled" : "disabled";
+}
+function createMoonshotThinkingWrapper(baseStreamFn, thinkingType) {
+	const underlying = baseStreamFn ?? streamSimple;
+	return (model, context, options) => underlying(model, context, {
+		...options,
+		onPayload: (payload) => {
+			if (payload && typeof payload === "object") {
+				const payloadObj = payload;
+				const pinnedToolChoice = payloadObj.tool_choice && typeof payloadObj.tool_choice === "object" && !Array.isArray(payloadObj.tool_choice);
+				const effectiveThinkingType = pinnedToolChoice ? "disabled" : thinkingType;
+				payloadObj.thinking = { type: effectiveThinkingType };
+				if (effectiveThinkingType === "enabled" && (payloadObj.tool_choice === "required" || payloadObj.tool_choice && typeof payloadObj.tool_choice === "object" && !Array.isArray(payloadObj.tool_choice))) {
+					if (payloadObj.tool_choice === "required") {
+						payloadObj.tool_choice = "auto";
+					} else {
+						const toolChoice = payloadObj.tool_choice;
+						if (toolChoice.type === "any" || toolChoice.type === "auto") {
+							payloadObj.tool_choice = "auto";
+						}
+					}
+				}
+			}
+			return options?.onPayload?.(payload);
+		}
+	});
+}
+
+//#endregion
+export { createMoonshotThinkingWrapper, resolveMoonshotThinkingType };