openclaw/dist/agent-runner-utils-CMtTx2u1.mjs

Multi-channel AI gateway with extensible messaging integrations

import { c as normalizeOptionalLowercaseString, l as normalizeOptionalString, o as normalizeLowercaseStringOrEmpty } from "./string-coerce-1VuiLaaR.mjs";
import { s as normalizeOptionalTrimmedStringList } from "./string-normalization-D6DKCpwE.mjs";
import { r as normalizeProviderId } from "./provider-id-D1VImdKk.mjs";
import { t as normalizeChatType } from "./chat-type-qwvaeaJu.mjs";
import { i as normalizeChatChannelId } from "./ids-DY4OsKJc.mjs";
import { t as normalizeAnyChannelId } from "./registry-normalize-DKVgg-js.mjs";
import { a as modelFallbackOverrideFromAvailability, p as resolveModelFallbackAvailability } from "./agent-scope-bJOokm5r.mjs";
import { a as resolveMergedModelProviderConfig, r as findConfiguredProviderModel } from "./model-provider-config-BVE2xsBm.mjs";
import { i as resolveProviderIdForAuth } from "./provider-auth-aliases-CAzJGfWN.mjs";
import { n as modelTransportRoutesMatch } from "./model-compat-catalog-VI3Psdyr.mjs";
import { l as getRuntimeConfigSourceSnapshot, o as getRuntimeConfigSnapshot, w as selectApplicableRuntimeConfig } from "./runtime-snapshot-De_QxZI9.mjs";
import "./registry-DvTPWA3B.mjs";
import { i as prepareModelRunCapabilities, n as findModelInCatalog, r as modelSupportsInput } from "./model-catalog-lookup-_nlJdlgO.mjs";
import "./config-VnHbY_QV.mjs";
import { a as isInternalMessageChannel } from "./message-channel-AvA3r_Xp.mjs";
import { a as resolveCandidateThinkingLevel, r as normalizeThinkingCatalogProviders } from "./thinking-runtime-CveqpPq0.mjs";
import { t as getChannelPlugin } from "./registry-Bcrk1FVy.mjs";
import "./plugins-BXkKReMp.mjs";
import { t as hasInboundAudio } from "./inbound-media-D9dVgt41.mjs";
import { n as readChannelSourceTurnId } from "./source-turn-id-CdR123OU.mjs";
import { n as mintMessageActionTurnCapability, o as resolveMessageActionTurnCapabilityLifetime, t as isTrustedMessageActionTurnIngress } from "./message-action-turn-capability-DSDyQMdo.mjs";
import { t as resolveReplyRunTrigger } from "./reply-turn-kind-CGA3YPu0.mjs";
import { t as resolveOriginMessageProvider } from "./origin-routing-B3FgSjbD.mjs";
import { t as resolveFastModeState } from "./fast-mode-C1fXnIGu.mjs";
import { t as resolveCommandSecretRefsViaGateway } from "./command-secret-gateway--pob-Rhh.mjs";
import { n as getAgentRuntimeOptionalCommandSecretPaths, t as getAgentRuntimeCommandSecretTargetIds, u as getScopedChannelsCommandSecretTargets } from "./command-secret-targets-O0tjDCt3.mjs";
import { t as resolveMessageSecretScope } from "./message-secret-scope-C4DG00vs.mjs";
import { t as isReasoningTagProvider } from "./provider-utils-W0uriSp1.mjs";
//#region src/auto-reply/reply/agent-runner-run-params.ts
function resolveModelFallbackOptions(run, config = run.config) {
	const modelFallbackAvailability = resolveModelFallbackAvailability({
		cfg: config,
		agentId: run.agentId,
		sessionKey: run.sessionKey,
		hasSessionModelOverride: run.hasSessionModelOverride === true,
		modelOverrideSource: run.modelOverrideSource,
		hasAutoFallbackProvenance: run.hasAutoFallbackProvenance === true,
		modelSelectionLocked: run.modelSelectionLocked,
		subagentSpawnLineage: run.subagentSpawnLineage
	});
	return {
		cfg: config,
		provider: run.provider,
		model: run.model,
		requestedRouteResolution: run.requestedRouteResolution,
		agentDir: run.agentDir,
		agentId: run.agentId,
		sessionKey: run.runtimePolicySessionKey ?? run.sessionKey,
		modelFallbackAvailability,
		fallbacksOverride: modelFallbackOverrideFromAvailability(modelFallbackAvailability)
	};
}
function buildRunEntrySelection(selection, run) {
	return {
		cfg: selection.cfg,
		provider: selection.provider,
		model: selection.model,
		requestedRouteResolution: selection.requestedRouteResolution,
		agentDir: selection.agentDir,
		fallbacksOverride: selection.fallbacksOverride,
		userLockedAuthProfileId: run.authProfileIdSource === "user" ? run.authProfileId : void 0
	};
}
/** Prepare the selected candidate's input before placement can bypass local model resolution. */
async function resolveRunModelHasVision(params) {
	const { run, provider, model } = params;
	const providerConfig = resolveMergedModelProviderConfig(run.config, provider);
	const configured = findConfiguredProviderModel(providerConfig, provider, model, normalizeLowercaseStringOrEmpty);
	if (configured?.input !== void 0) return modelSupportsInput(configured, "image");
	const route = {
		api: configured?.api ?? providerConfig?.api,
		baseUrl: configured?.baseUrl ?? providerConfig?.baseUrl
	};
	const prepared = findModelInCatalog(run.thinkingCatalog ?? [], provider, model);
	if (prepared?.input !== void 0 && modelTransportRoutesMatch(prepared, route)) return modelSupportsInput(prepared, "image");
	const { loadProviderScopedThinkingCatalog } = await import("./agents/model-catalog.runtime.js");
	const catalog = await loadProviderScopedThinkingCatalog({
		config: run.config,
		provider,
		model,
		agentId: run.agentId,
		agentDir: run.agentDir,
		workspaceDir: run.workspaceDir,
		requiredInputRoute: route
	});
	return modelSupportsInput(findModelInCatalog(catalog, provider, model), "image");
}
/** Project prepared turn facts shared by the CLI and embedded runtime adapters. */
function buildFallbackCandidateTurnParams(params) {
	const { turn } = params;
	return {
		preparedTtsPreferences: turn.opts?.preparedTtsPreferences,
		preparedRunAdmission: params.preparedRunAdmission,
		messageActionTurnCapability: params.messageActionTurnCapability,
		trigger: resolveReplyRunTrigger(turn),
		lane: params.runLane,
		fastModeStartedAtMs: params.fastModeStartedAtMs,
		fastModeAutoProgressState: params.fastModeAutoProgressState,
		isFinalFallbackAttempt: params.isFinalFallbackAttempt,
		prompt: turn.commandBody,
		transcriptPrompt: turn.transcriptCommandBody,
		media: turn.followupRun.media,
		userTurnTranscriptRecorder: params.userTurnTranscriptRecorder,
		contextEngineLogicalTurnLease: params.contextEngineLogicalTurnLease,
		onContextEngineTurnCandidate: params.onContextEngineTurnCandidate,
		currentInboundEventKind: turn.followupRun.currentInboundEventKind,
		currentInboundContext: turn.followupRun.currentInboundContext,
		extraSystemPrompt: turn.followupRun.run.extraSystemPrompt,
		sourceReplyDeliveryMode: turn.followupRun.run.sourceReplyDeliveryMode,
		...turn.isHeartbeat ? { requireExplicitMessageTarget: true } : {},
		cleanupBundleMcpOnRunEnd: turn.opts?.cleanupBundleMcpOnRunEnd,
		silentReplyPromptMode: turn.followupRun.run.silentReplyPromptMode,
		suppressNextUserMessagePersistence: params.suppressQueuedUserPersistenceForCandidate,
		onUserMessagePersisted: params.notifyUserMessagePersisted,
		prepareAssistantTranscriptMessage: turn.opts?.prepareAssistantTranscriptMessage,
		toolsAllow: turn.opts?.toolsAllow,
		disableTools: turn.opts?.disableTools,
		continuesConversation: turn.opts?.continuesConversation,
		bootstrapContextMode: turn.opts?.bootstrapContextMode,
		bootstrapContextRunKind: params.bootstrapContextRunKind,
		images: params.currentTurnImages.images,
		imageOrder: params.currentTurnImages.imageOrder,
		abortSignal: params.runAbortSignal,
		replyOperation: turn.replyOperation,
		bootstrapPromptWarningSignaturesSeen: params.bootstrapPromptWarningSignaturesSeen,
		bootstrapPromptWarningSignature: params.bootstrapPromptWarningSignaturesSeen.at(-1)
	};
}
/** Carry the same session-selected facts while each adapter owns runtime and route overrides. */
function buildReplyRunStateParams(run) {
	return {
		sessionFile: run.sessionFile,
		workspaceDir: run.workspaceDir,
		cwd: run.cwd,
		toolOverrides: run.toolOverrides,
		skillsSnapshot: run.skillsSnapshot,
		ownerNumbers: run.ownerNumbers,
		inputProvenance: run.inputProvenance,
		senderIsOwner: run.senderIsOwner,
		conversationToolPolicy: run.conversationToolPolicy,
		channelContext: run.channelContext,
		approvalReviewerDeviceId: run.approvalReviewerDeviceId,
		terminalReplyExpectation: run.terminalReplyExpectation,
		clientCaps: run.clientCaps,
		bootstrapUserProfileId: run.bootstrapUserProfileId,
		gatewayUiCommandTarget: run.gatewayUiCommandTarget,
		taskSuggestionDeliveryMode: run.taskSuggestionDeliveryMode
	};
}
function buildReplyMediaContextParams({ run, originatingAccountId }, sessionKey, cfg) {
	return {
		cfg,
		agentId: run.agentId,
		sessionKey,
		workspaceDir: run.workspaceDir,
		mediaNormalizationOwner: run.mediaNormalizationOwner,
		messageProvider: run.messageProvider,
		accountId: originatingAccountId ?? run.agentAccountId,
		groupId: run.groupId,
		groupChannel: run.groupChannel,
		groupSpace: run.groupSpace,
		requesterSenderId: run.senderId,
		requesterSenderName: run.senderName,
		requesterSenderUsername: run.senderUsername,
		requesterSenderE164: run.senderE164
	};
}
//#endregion
//#region src/auto-reply/reply/agent-runner-auth-profile.ts
/** Keeps an auth profile only when the current provider shares the primary auth scope. */
function resolveRunAuthProfile(run, provider, params) {
	const { provider: primaryProvider, authProfileId: requestedAuthProfileId, authProfileIdSource } = run;
	const aliasParams = {
		config: params?.config ?? run.config,
		workspaceDir: run.workspaceDir
	};
	const providerId = normalizeProviderId(provider);
	const primaryProviderId = normalizeProviderId(primaryProvider);
	const authProfileId = providerId !== "" && providerId === primaryProviderId || resolveProviderIdForAuth(provider, aliasParams) === resolveProviderIdForAuth(primaryProvider, aliasParams) ? requestedAuthProfileId : void 0;
	return {
		authProfileId,
		authProfileIdSource: authProfileId ? authProfileIdSource : void 0
	};
}
/** Applies an auto-fallback probe's pinned auth to its fallback candidate. */
function resolveFallbackCandidateRun(run, provider, model) {
	const probe = run.autoFallbackPrimaryProbe;
	const isPrimaryProbeCandidate = probe && provider === probe.provider && model === probe.model;
	if (!probe || provider !== probe.fallbackProvider || isPrimaryProbeCandidate || !probe.fallbackAuthProfileId) return run;
	const candidateRun = {
		...run,
		provider,
		model,
		authProfileId: probe.fallbackAuthProfileId
	};
	if (probe.fallbackAuthProfileIdSource) candidateRun.authProfileIdSource = probe.fallbackAuthProfileIdSource;
	else delete candidateRun.authProfileIdSource;
	return candidateRun;
}
//#endregion
//#region src/auto-reply/reply/agent-runner-utils.ts
function resolveQueuedReplyRuntimeConfig(config) {
	return selectApplicableRuntimeConfig({
		inputConfig: config,
		runtimeConfig: getRuntimeConfigSnapshot(),
		runtimeSourceConfig: getRuntimeConfigSourceSnapshot()
	}) ?? config;
}
async function resolveQueuedReplyExecutionConfig(config, params) {
	const runtimeConfig = resolveQueuedReplyRuntimeConfig(config);
	const { resolvedConfig } = await resolveCommandSecretRefsViaGateway({
		config: runtimeConfig,
		commandName: "reply",
		targetIds: getAgentRuntimeCommandSecretTargetIds({ config: runtimeConfig }),
		optionalActivePaths: getAgentRuntimeOptionalCommandSecretPaths(runtimeConfig)
	});
	const baseResolvedConfig = resolvedConfig ?? runtimeConfig;
	const scope = resolveMessageSecretScope({
		channel: params?.originatingChannel,
		fallbackChannel: params?.messageProvider,
		accountId: params?.originatingAccountId,
		fallbackAccountId: params?.agentAccountId
	});
	if (!scope.channel) return baseResolvedConfig;
	const scopedTargets = getScopedChannelsCommandSecretTargets({
		config: baseResolvedConfig,
		channel: scope.channel,
		accountId: scope.accountId
	});
	if (scopedTargets.targetIds.size === 0) return baseResolvedConfig;
	return (await resolveCommandSecretRefsViaGateway({
		config: baseResolvedConfig,
		commandName: "reply",
		targetIds: scopedTargets.targetIds,
		...scopedTargets.allowedPaths ? { allowedPaths: scopedTargets.allowedPaths } : {}
	})).resolvedConfig ?? baseResolvedConfig;
}
function buildThreadingToolContext(params) {
	const { sessionCtx, config, hasRepliedRef } = params;
	const currentMessageId = sessionCtx.InputProvenance?.kind === "internal_system" && sessionCtx.InputProvenance.sourceTool === "restart-sentinel" ? sessionCtx.ReplyToId : isInternalMessageChannel(sessionCtx.Provider ?? sessionCtx.Surface) ? void 0 : sessionCtx.MessageSidFull ?? sessionCtx.MessageSid;
	const currentSourceTurnId = readChannelSourceTurnId(sessionCtx);
	const originProvider = resolveOriginMessageProvider({
		originatingChannel: sessionCtx.OriginatingChannel,
		provider: sessionCtx.Provider
	});
	const originTo = sessionCtx.OriginatingTo ?? sessionCtx.To;
	const rawProvider = config ? normalizeOptionalLowercaseString(originProvider) : void 0;
	if (!config || !rawProvider) return {
		currentMessageId,
		currentSourceTurnId,
		replyToMode: sessionCtx.ReplyToMode
	};
	const provider = normalizeChatChannelId(rawProvider) ?? normalizeAnyChannelId(rawProvider);
	const threading = provider ? getChannelPlugin(provider)?.threading : void 0;
	const context = threading?.buildToolContext ? threading.buildToolContext({
		cfg: config,
		accountId: sessionCtx.AccountId,
		context: {
			Channel: originProvider,
			From: sessionCtx.From,
			To: originTo,
			ChatType: sessionCtx.ChatType,
			CurrentMessageId: currentMessageId,
			ReplyToMode: sessionCtx.ReplyToMode,
			ReplyToId: sessionCtx.ReplyToId,
			ReplyToIdFull: sessionCtx.ReplyToIdFull,
			ThreadLabel: sessionCtx.ThreadLabel,
			MessageThreadId: sessionCtx.MessageThreadId,
			TransportThreadId: sessionCtx.TransportThreadId,
			NativeChannelId: sessionCtx.NativeChannelId
		},
		hasRepliedRef
	}) ?? {} : {
		currentChannelId: normalizeOptionalString(originTo),
		hasRepliedRef
	};
	const hasAdapterCurrentMessageId = Object.hasOwn(context, "currentMessageId");
	return {
		...context,
		currentChannelProvider: provider ?? rawProvider,
		currentMessageId: hasAdapterCurrentMessageId ? context.currentMessageId : currentMessageId,
		currentSourceTurnId,
		replyToMode: context.replyToMode ?? sessionCtx.ReplyToMode
	};
}
function resolveFollowupCurrentMessageId(queued) {
	return queued.run.inputProvenance?.kind === "internal_system" && queued.run.inputProvenance.sourceTool === "restart-sentinel" ? queued.originatingReplyToId : queued.messageId;
}
/** Remaps the original inline request without reusing a queued model's clamped level. */
function resolveRunThinkingLevelForFallbackCandidate(params) {
	const { run, ...candidate } = params;
	return resolveCandidateThinkingLevel({
		...candidate,
		level: run.thinkLevelOverride === "default" ? run.thinkLevel : run.thinkLevelOverride ?? run.thinkLevel
	});
}
function resolveRunFastModeForFallbackCandidate(params) {
	const state = resolveFastModeState({
		cfg: params.config,
		provider: params.provider,
		model: params.model,
		agentId: params.run.agentId,
		sessionEntry: params.sessionEntry
	});
	return {
		fastMode: params.run.fastModeOverride ? params.run.fastMode : state.mode,
		fastModeAutoOnSeconds: params.run.fastModeAutoOnSecondsOverride ? params.run.fastModeAutoOnSeconds : state.fastAutoOnSeconds
	};
}
function applyReplyRouteToTemplate(params) {
	return {
		...params.sessionCtx,
		OriginatingChannel: params.replyRoute?.originatingChannel ?? params.sessionCtx.OriginatingChannel,
		OriginatingTo: params.replyRoute?.originatingTo ?? params.sessionCtx.OriginatingTo,
		AccountId: params.replyRoute?.originatingAccountId ?? params.sessionCtx.AccountId ?? params.run.agentAccountId,
		ChatType: normalizeChatType(params.replyRoute?.originatingChatType) ?? normalizeChatType(params.sessionCtx.ChatType) ?? params.run.chatType,
		MessageThreadId: params.replyRoute?.originatingThreadId ?? params.sessionCtx.MessageThreadId,
		ReplyToId: params.replyRoute?.originatingReplyToId ?? params.sessionCtx.ReplyToId,
		ReplyToMode: params.replyRoute?.originatingReplyToMode ?? params.sessionCtx.ReplyToMode
	};
}
/**
* Builds message-tool threading context for the queued reply route. Embedded
* and CLI runtimes share it so the channel adapter decides the default thread.
*/
function buildReplyRouteThreadingToolContext(params) {
	return buildThreadingToolContext({
		sessionCtx: applyReplyRouteToTemplate(params),
		config: params.run.config,
		hasRepliedRef: params.hasRepliedRef
	});
}
function buildEmbeddedContextFromTemplate(params) {
	const sessionCtx = applyReplyRouteToTemplate(params);
	return {
		sessionId: params.run.sessionId,
		sessionKey: params.run.sessionKey,
		sandboxSessionKey: params.run.runtimePolicySessionKey,
		agentId: params.run.agentId,
		messageProvider: resolveOriginMessageProvider({
			originatingChannel: sessionCtx.OriginatingChannel,
			provider: sessionCtx.Provider
		}),
		...sessionCtx.ChatType ? { chatType: sessionCtx.ChatType } : {},
		agentAccountId: sessionCtx.AccountId,
		conversationRoutePeerId: params.run.conversationRoutePeerId,
		messageTo: sessionCtx.OriginatingTo ?? sessionCtx.To,
		messageThreadId: sessionCtx.MessageThreadId ?? void 0,
		chatId: normalizeOptionalString(sessionCtx.NativeChannelId) ?? normalizeOptionalString(sessionCtx.ChatId),
		memberRoleIds: normalizeOptionalTrimmedStringList(sessionCtx.MemberRoleIds),
		...buildThreadingToolContext({
			sessionCtx,
			config: params.run.config,
			hasRepliedRef: params.hasRepliedRef
		}),
		currentInboundAudio: hasInboundAudio(sessionCtx)
	};
}
function buildTemplateSenderContext(sessionCtx) {
	return {
		senderId: normalizeOptionalString(sessionCtx.SenderId),
		channelContext: sessionCtx.ChannelContext,
		senderName: normalizeOptionalString(sessionCtx.SenderName),
		senderUsername: normalizeOptionalString(sessionCtx.SenderUsername),
		senderE164: normalizeOptionalString(sessionCtx.SenderE164)
	};
}
/** Bind either runtime to the same trusted source turn and requester. */
function mintReplyMessageActionTurnCapability(turn, runId) {
	if (turn.followupRun.run.internalEventExecution) return;
	const channelIngress = isTrustedMessageActionTurnIngress(turn.sessionCtx.Provider);
	const dashboardAdmission = turn.opts?.dashboardReadAdmission;
	if (turn.isHeartbeat || !channelIngress && (turn.sessionCtx.Provider !== "webchat" || dashboardAdmission?.runId !== runId)) return;
	const context = buildEmbeddedContextFromTemplate({
		run: turn.followupRun.run,
		replyRoute: turn.followupRun,
		sessionCtx: turn.sessionCtx,
		hasRepliedRef: turn.opts?.hasRepliedRef
	});
	const sessionKey = turn.runtimePolicySessionKey ?? context.sessionKey;
	if (!context.agentId || !sessionKey) return;
	if (!channelIngress) {
		if (!dashboardAdmission || dashboardAdmission.agentId !== context.agentId || dashboardAdmission.sessionKey !== sessionKey || dashboardAdmission.sessionId !== context.sessionId) return;
		dashboardAdmission.assertCurrent();
		return mintMessageActionTurnCapability({
			agentId: context.agentId,
			runId,
			sessionKey,
			sessionId: context.sessionId,
			assertDashboardReadCurrent: dashboardAdmission.assertCurrent,
			expiresWithRun: true
		});
	}
	if (!context.messageProvider || !context.currentChannelId) return;
	const sender = buildTemplateSenderContext(turn.sessionCtx);
	return mintMessageActionTurnCapability({
		agentId: context.agentId,
		runId,
		sessionKey,
		sourceReplySessionKey: context.sessionKey,
		sessionId: context.sessionId,
		requesterAccountId: context.agentAccountId,
		requesterSenderId: sender.senderId,
		requesterSenderName: sender.senderName,
		requesterSenderUsername: sender.senderUsername,
		requesterSenderE164: sender.senderE164,
		toolContext: {
			currentChannelId: context.currentChannelId,
			currentChatType: context.chatType,
			currentMessagingTarget: context.currentMessagingTarget,
			currentGraphChannelId: context.currentGraphChannelId,
			currentChannelProvider: context.currentChannelProvider,
			currentThreadTs: context.currentThreadTs,
			currentMessageId: context.currentMessageId,
			currentSourceTurnId: context.currentSourceTurnId,
			replyToMode: context.replyToMode,
			hasRepliedRef: context.hasRepliedRef,
			sameChannelThreadRequired: context.sameChannelThreadRequired
		},
		...resolveMessageActionTurnCapabilityLifetime(turn.followupRun.run.timeoutMs)
	});
}
async function buildEmbeddedRunExecutionParams(params) {
	const authProfile = resolveRunAuthProfile(params.run, params.provider);
	const embeddedContext = buildEmbeddedContextFromTemplate(params);
	const senderContext = buildTemplateSenderContext(params.sessionCtx);
	const snapshot = { ...params };
	const config = snapshot.run.config;
	const { modelFallbackAvailability, fallbacksOverride: modelFallbacksOverride } = resolveModelFallbackOptions(snapshot.run);
	let modelThinkingCapability;
	if (snapshot.agentRuntime) {
		const { loadProviderScopedThinkingCatalog } = await import("./agents/model-catalog.runtime.js");
		const observedCatalog = normalizeThinkingCatalogProviders(await loadProviderScopedThinkingCatalog({
			config,
			provider: snapshot.provider,
			model: snapshot.model,
			agentRuntime: snapshot.agentRuntime,
			agentId: snapshot.run.agentId,
			agentDir: snapshot.run.agentDir,
			workspaceDir: snapshot.run.workspaceDir
		}));
		const thinkingCatalog = findModelInCatalog(observedCatalog, snapshot.provider, snapshot.model) ? observedCatalog : snapshot.run.thinkingCatalog;
		modelThinkingCapability = prepareModelRunCapabilities([thinkingCatalog, []], [
			snapshot.provider,
			snapshot.model,
			snapshot.agentRuntime
		]).modelThinkingCapability;
	}
	const enforceFinalTag = !snapshot.run.skipProviderRuntimeHints && (snapshot.run.enforceFinalTag || isReasoningTagProvider(snapshot.provider, {
		config,
		workspaceDir: snapshot.run.workspaceDir,
		modelId: snapshot.model
	}));
	return {
		...embeddedContext,
		...senderContext,
		...buildReplyRunStateParams(snapshot.run),
		providerReviewAcknowledgment: snapshot.run.providerReviewAcknowledgment,
		permissionMode: snapshot.run.permissionMode,
		sessionRoot: snapshot.run.sessionRoot,
		agentDir: snapshot.run.agentDir,
		config,
		trustedInternalHandoff: snapshot.run.trustedInternalHandoff,
		scheduledToolPolicy: snapshot.run.scheduledToolPolicy,
		runtimePluginToolGrant: snapshot.run.runtimePluginToolGrant,
		enforceFinalTag,
		silentExpected: snapshot.run.silentExpected,
		silentReplyPromptMode: snapshot.run.silentReplyPromptMode,
		sourceReplyDeliveryMode: snapshot.run.sourceReplyDeliveryMode,
		toolBindings: snapshot.run.toolBindings,
		skillLibraryAuthoring: snapshot.run.skillLibraryAuthoring,
		provider: snapshot.provider,
		model: snapshot.model,
		modelHasVision: await resolveRunModelHasVision(snapshot),
		...modelThinkingCapability ? { modelThinkingCapability } : {},
		requestedRouteResolution: "resolved",
		modelSelectionLocked: snapshot.run.modelSelectionLocked,
		modelFallbackAvailability,
		modelFallbacksOverride,
		...authProfile,
		thinkLevel: snapshot.run.thinkLevel,
		fastMode: snapshot.run.fastMode,
		fastModeAutoOnSeconds: snapshot.run.fastModeAutoOnSeconds,
		verboseLevel: snapshot.run.verboseLevel,
		reasoningLevel: snapshot.run.reasoningLevel,
		execOverrides: snapshot.run.execOverrides,
		bashElevated: snapshot.run.bashElevated,
		timeoutMs: snapshot.run.timeoutMs,
		runTimeoutOverrideMs: snapshot.run.runTimeoutOverrideMs,
		runId: snapshot.runId,
		promptCacheKey: snapshot.promptCacheKey,
		allowTransientCooldownProbe: snapshot.allowTransientCooldownProbe
	};
}
//#endregion
export { resolveRunModelHasVision as _, resolveFollowupCurrentMessageId as a, resolveRunFastModeForFallbackCandidate as c, resolveRunAuthProfile as d, buildFallbackCandidateTurnParams as f, resolveModelFallbackOptions as g, buildRunEntrySelection as h, mintReplyMessageActionTurnCapability as i, resolveRunThinkingLevelForFallbackCandidate as l, buildReplyRunStateParams as m, buildReplyRouteThreadingToolContext as n, resolveQueuedReplyExecutionConfig as o, buildReplyMediaContextParams as p, buildThreadingToolContext as r, resolveQueuedReplyRuntimeConfig as s, buildEmbeddedRunExecutionParams as t, resolveFallbackCandidateRun as u };