fengming 0.3.8 → 0.3.10

package/dist/talk-DGOI3Lu3.js

@@ -1,2454 +0,0 @@
-import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DKw2K5wM.js";
-import { p as parseFiniteNumber } from "./number-coercion-D1aDmIZp.js";
-import { i as asOptionalRecord } from "./record-coerce-Btbek4uV.js";
-import { u as readConfigFileSnapshot } from "./io-T1CV3Z1L.js";
-import { i as resolveActiveTalkProviderConfig, r as normalizeTalkSection, t as buildTalkConfigResponse } from "./talk-B1Q8qwLB.js";
-import "./config-4B-JCqw_.js";
-import { An as validateTalkSessionJoinParams, Cn as validateTalkModeParams, Dn as validateTalkSessionCloseParams, En as validateTalkSessionCancelTurnParams, Fn as validateTalkSessionTurnParams, Ln as validateTalkSpeakParams, Nn as validateTalkSessionSteerParams, On as validateTalkSessionCreateParams, Pn as validateTalkSessionSubmitToolResultParams, Ri as ErrorCodes, Tn as validateTalkSessionCancelOutputParams, _n as validateTalkClientSteerParams, bn as validateTalkConfigParams, hn as validateTalkClientCreateParams, pn as validateTalkCatalogParams, t as formatValidationErrors, vn as validateTalkClientToolCallParams, wn as validateTalkSessionAppendAudioParams, zi as errorShape } from "./src-B1Y482-m.js";
-import { a as TALK_SECRETS_SCOPE, t as ADMIN_SCOPE } from "./operator-scopes-DGvgHuOd.js";
-import { _ as resolveSupportedVoiceModelRefs, h as providerMatchesId, m as getVoiceProviderConfig } from "./loader-Ct7uZnva.js";
-import { n as redactConfigObject } from "./redact-snapshot-DFs1a6Z-.js";
-import { i as getSpeechProvider, o as listSpeechProviders, r as canonicalizeSpeechProviderId } from "./directives-C5xgI26A.js";
-import { D as synthesizeSpeech, M as withSpeakerSelectionCompat, N as withSpeakerSelectionFallbackCompat, g as resolveTtsConfig, i as getResolvedSpeechProviderConfig } from "./tts-runtime-cVlyKskt.js";
-import "./tts-B5cmsELt.js";
-import { t as abortChatRunById } from "./chat-abort-wipQF0Ih.js";
-import { t as formatForLog } from "./ws-log-BzGc41ZC.js";
-import { r as listRealtimeTranscriptionProviders } from "./provider-registry-BKmY-C62.js";
-import { A as buildRealtimeVoiceAgentConsultWorkingResponse, C as shouldAutoControlRealtimeVoiceAgentText, D as buildRealtimeVoiceAgentConsultChatMessage, H as createTalkSessionController, L as createRealtimeVoiceForcedConsultCoordinator, Q as REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, T as REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, V as readSpeakableRealtimeVoiceToolResult, W as recordTalkObservabilityEvent, c as resolveConfiguredRealtimeVoiceProvider, d as listRealtimeVoiceProviders, g as REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME, h as REALTIME_VOICE_AGENT_CONTROL_TOOL, i as isLikelyRealtimeVoiceAssistantEchoTranscript, l as canonicalizeRealtimeVoiceProviderId, o as recordRealtimeVoiceTranscript, p as controlRealtimeVoiceAgentRun, s as createRealtimeVoiceBridgeSession, v as buildRealtimeVoiceAgentControlSpeechMessage, w as REALTIME_VOICE_AGENT_CONSULT_TOOL } from "./session-log-runtime-DusjACU2.js";
-import { i as chatHandlers } from "./chat-DWRXkuvU.js";
-import { t as resolveSessionKeyFromResolveParams } from "./sessions-resolve-DfMXookg.js";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-//#region src/gateway/talk-session-registry.ts
-const unifiedTalkSessions = /* @__PURE__ */ new Map();
-function rememberUnifiedTalkSession(sessionId, session) {
-	unifiedTalkSessions.set(sessionId, session);
-}
-function getUnifiedTalkSession(sessionId) {
-	const session = unifiedTalkSessions.get(sessionId);
-	if (!session) throw new Error("未知的通话会话");
-	return session;
-}
-function forgetUnifiedTalkSession(sessionId) {
-	unifiedTalkSessions.delete(sessionId);
-}
-function requireUnifiedTalkSessionConn(session, connId) {
-	if (!connId || session.connId !== connId) throw new Error("通话会话不属于此连接");
-	return connId;
-}
-//#endregion
-//#region src/gateway/talk-realtime-relay.ts
-const RELAY_SESSION_TTL_MS = 1800 * 1e3;
-const MAX_AUDIO_BASE64_BYTES$1 = 512 * 1024;
-const MAX_RELAY_SESSIONS_PER_CONN = 2;
-const MAX_RELAY_SESSIONS_GLOBAL = 64;
-const RELAY_EVENT = "talk.event";
-const RELAY_TRANSCRIPT_ECHO_LOOKBACK_MS = 12e3;
-const FORCED_CONSULT_FALLBACK_DELAY_MS = 200;
-const FORCED_CONSULT_RESULT_MAX_CHARS = 1800;
-const relaySessions = /* @__PURE__ */ new Map();
-function formatError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function isWorkingToolResult(result) {
-	return Boolean(result) && typeof result === "object" && !Array.isArray(result) && result.status === "working";
-}
-function isRelayAssistantEchoTranscript(session, text) {
-	if (!session) return false;
-	return isLikelyRealtimeVoiceAssistantEchoTranscript({
-		transcript: session.transcript,
-		text,
-		lookbackMs: RELAY_TRANSCRIPT_ECHO_LOOKBACK_MS
-	});
-}
-function buildForcedConsultCheckingPrompt() {
-	return ["Briefly tell the person that you are checking with FengMing.", "Do not answer the request yet. Wait for the FengMing result before giving the actual answer."].join(" ");
-}
-function buildForcedConsultSpeechPrompt(text) {
-	return [
-		"FengMing finished checking. Speak this result naturally and concisely.",
-		"Do not mention tool calls, JSON, or internal routing.",
-		"",
-		text
-	].join("\n");
-}
-function buildAlreadyDeliveredToolResult() {
-	return {
-		status: "already_delivered",
-		message: "FengMing already delivered this consult result internally. Do not repeat it."
-	};
-}
-function cancelForcedConsults(session) {
-	for (const handle of session.forcedConsults.handles()) session.forcedConsults.markCancelled(handle);
-}
-function broadcastToOwner$1(context, connId, event) {
-	context.broadcastToConnIds(RELAY_EVENT, event, new Set([connId]), { dropIfSlow: true });
-}
-function abortRelayAgentRuns(session, reason) {
-	for (const [runId, sessionKey] of session.activeAgentRuns) abortChatRunById(session.context, {
-		runId,
-		sessionKey,
-		stopReason: reason
-	});
-	session.activeAgentRuns.clear();
-	session.activeAgentToolCalls.clear();
-}
-function pruneInactiveRelayAgentRuns(session) {
-	for (const runId of session.activeAgentRuns.keys()) if (!session.context.chatAbortControllers.has(runId)) session.activeAgentRuns.delete(runId);
-	for (const [callId, runId] of session.activeAgentToolCalls) if (!session.activeAgentRuns.has(runId)) session.activeAgentToolCalls.delete(callId);
-	return session.activeAgentRuns.size;
-}
-function submitRelayAgentControlProviderResults(session, result, turnId) {
-	if (result.mode !== "cancel" || !result.ok || !result.providerResult) return;
-	const activeCallIds = [...session.activeAgentToolCalls.keys()];
-	for (const callId of activeCallIds) {
-		const forcedConsult = session.forcedConsults.handles().find((handle) => handle.id === callId);
-		if (forcedConsult) {
-			session.forcedConsults.markCancelled(forcedConsult);
-			for (const nativeCallId of session.forcedConsults.nativeCallIds(forcedConsult)) session.bridge.submitToolResult(nativeCallId, result.providerResult, { suppressResponse: true });
-		} else session.bridge.submitToolResult(callId, result.providerResult, { suppressResponse: true });
-		broadcastToOwner$1(session.context, session.connId, {
-			relaySessionId: session.id,
-			type: "toolResult",
-			callId,
-			talkEvent: session.talk.emit({
-				type: "tool.result",
-				callId,
-				turnId,
-				payload: { result: result.providerResult },
-				final: true
-			})
-		});
-		session.activeAgentToolCalls.delete(callId);
-		session.completedAgentToolCalls.add(callId);
-	}
-	session.activeAgentRuns.clear();
-}
-function closeRelaySession(session, reason) {
-	session.forcedConsults.clear();
-	relaySessions.delete(session.id);
-	forgetUnifiedTalkSession(session.id);
-	clearTimeout(session.cleanupTimer);
-	abortRelayAgentRuns(session, reason === "error" ? "relay-error" : "relay-closed");
-	session.bridge.close();
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "close",
-		reason,
-		talkEvent: session.talk.emit({
-			type: "session.closed",
-			payload: { reason },
-			final: true
-		})
-	});
-}
-function pruneExpiredRelaySessions(nowMs = Date.now()) {
-	for (const session of relaySessions.values()) if (nowMs > session.expiresAtMs) closeRelaySession(session, "completed");
-}
-function countRelaySessionsForConn(connId) {
-	let count = 0;
-	for (const session of relaySessions.values()) if (session.connId === connId) count += 1;
-	return count;
-}
-function enforceRelaySessionLimits(connId) {
-	pruneExpiredRelaySessions();
-	if (relaySessions.size >= MAX_RELAY_SESSIONS_GLOBAL) throw new Error("活跃的实时中继会话过多");
-	if (countRelaySessionsForConn(connId) >= MAX_RELAY_SESSIONS_PER_CONN) throw new Error("此连接的活跃实时中继会话过多");
-}
-function createTalkRealtimeRelaySession(params) {
-	enforceRelaySessionLimits(params.connId);
-	const forceAgentConsultOnFinalTranscript = params.forceAgentConsultOnFinalTranscript === true;
-	const relaySessionId = randomUUID();
-	const expiresAtMs = Date.now() + RELAY_SESSION_TTL_MS;
-	const talk = createTalkSessionController({
-		sessionId: relaySessionId,
-		mode: "realtime",
-		transport: "gateway-relay",
-		brain: "agent-consult",
-		provider: params.provider.id
-	}, { onEvent: recordTalkObservabilityEvent });
-	let relay;
-	const emit = (event, talkEvent) => broadcastToOwner$1(params.context, params.connId, {
-		...event,
-		...talkEvent ? { talkEvent: talk.emit(talkEvent) } : {}
-	});
-	let currentOutputItemId;
-	let currentOutputResponseId;
-	const bridge = createRealtimeVoiceBridgeSession({
-		provider: params.provider,
-		cfg: params.cfg,
-		providerConfig: params.providerConfig,
-		audioFormat: REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ,
-		instructions: params.instructions,
-		autoRespondToAudio: !forceAgentConsultOnFinalTranscript,
-		interruptResponseOnInputAudio: !forceAgentConsultOnFinalTranscript,
-		tools: params.tools,
-		markStrategy: "ack-immediately",
-		audioSink: {
-			isOpen: () => Boolean(relay && relaySessions.has(relay.id)),
-			sendAudio: (audio) => {
-				const turnId = relay ? ensureRelayTurn(relay) : void 0;
-				emit({
-					relaySessionId,
-					type: "audio",
-					audioBase64: audio.toString("base64"),
-					...currentOutputItemId ? { itemId: currentOutputItemId } : {},
-					...currentOutputResponseId ? { responseId: currentOutputResponseId } : {}
-				}, {
-					type: "output.audio.delta",
-					turnId,
-					payload: { byteLength: audio.length }
-				});
-			},
-			clearAudio: () => {
-				const turnId = relay ? ensureRelayTurn(relay) : void 0;
-				emit({
-					relaySessionId,
-					type: "clear"
-				}, {
-					type: "output.audio.done",
-					turnId,
-					payload: { reason: "clear" },
-					final: true
-				});
-			},
-			sendMark: (markName) => {
-				const turnId = relay ? ensureRelayTurn(relay) : void 0;
-				emit({
-					relaySessionId,
-					type: "mark",
-					markName
-				}, {
-					type: "output.audio.done",
-					turnId,
-					payload: { markName },
-					final: true
-				});
-			}
-		},
-		onEvent: (event) => {
-			if (event.direction !== "server") return;
-			if (event.type === "conversation.output_audio.delta" || event.type === "response.audio.delta" || event.type === "response.output_audio.delta") {
-				currentOutputItemId = event.itemId ?? currentOutputItemId;
-				currentOutputResponseId = event.responseId ?? currentOutputResponseId;
-				return;
-			}
-			if (event.type === "response.audio.done" || event.type === "response.output_audio.done" || event.type === "conversation.output_audio.done" || event.type === "response.done" || event.type === "response.cancelled") {
-				emit({
-					relaySessionId,
-					type: "audioDone",
-					...event.itemId ?? currentOutputItemId ? { itemId: event.itemId ?? currentOutputItemId } : {},
-					...event.responseId ?? currentOutputResponseId ? { responseId: event.responseId ?? currentOutputResponseId } : {}
-				});
-				currentOutputItemId = void 0;
-				currentOutputResponseId = void 0;
-			}
-		},
-		onTranscript: (role, text, final) => {
-			const turnId = relay ? ensureRelayTurn(relay) : void 0;
-			if (final && relay) recordRealtimeVoiceTranscript(relay.transcript, role, text);
-			emit({
-				relaySessionId,
-				type: "transcript",
-				role,
-				text,
-				final
-			}, {
-				type: role === "assistant" ? final ? "output.text.done" : "output.text.delta" : final ? "transcript.done" : "transcript.delta",
-				turnId,
-				payload: role === "assistant" ? { text } : {
-					role,
-					text
-				},
-				final
-			});
-			if (role === "user" && final && text.trim()) {
-				const question = text.trim();
-				if (isRelayAssistantEchoTranscript(relay, question)) return;
-				if (relay && pruneInactiveRelayAgentRuns(relay) > 0 && shouldAutoControlRealtimeVoiceAgentText(question)) {
-					steerTalkRealtimeRelayAgentRun({
-						relaySessionId,
-						connId: params.connId,
-						text: question
-					}).then((result) => {
-						if (result.speak && !result.suppress && result.message.trim()) bridge.sendUserMessage(buildRealtimeVoiceAgentControlSpeechMessage(result.message));
-					}).catch((error) => {
-						emit({
-							relaySessionId,
-							type: "error",
-							message: formatError(error)
-						}, {
-							type: "session.error",
-							payload: { message: formatError(error) },
-							final: true
-						});
-					});
-					return;
-				}
-				if (forceAgentConsultOnFinalTranscript) scheduleForcedAgentConsult(relay, question);
-			}
-		},
-		onToolCall: (toolCall) => {
-			const turnId = relay ? ensureRelayTurn(relay) : void 0;
-			if (relay && toolCall.name === "fengming_agent_consult") {
-				const forcedConsult = relay.forcedConsults.recordNativeConsult(toolCall.args, toolCall.callId);
-				if (forcedConsult.kind === "in_flight" || forcedConsult.kind === "already_delivered") {
-					if (forcedConsult.kind === "already_delivered") submitAlreadyDeliveredToolResult(relay, toolCall.callId, turnId);
-					else submitRealtimeAgentConsultWorkingResponse(relay, toolCall.callId, turnId);
-					return;
-				}
-				submitRealtimeAgentConsultWorkingResponse(relay, toolCall.callId, turnId);
-			}
-			emit({
-				relaySessionId,
-				type: "toolCall",
-				itemId: toolCall.itemId,
-				callId: toolCall.callId,
-				name: toolCall.name,
-				args: toolCall.args
-			}, {
-				type: "tool.call",
-				itemId: toolCall.itemId,
-				callId: toolCall.callId,
-				turnId,
-				payload: {
-					name: toolCall.name,
-					args: toolCall.args
-				}
-			});
-		},
-		onReady: () => emit({
-			relaySessionId,
-			type: "ready"
-		}, {
-			type: "session.ready",
-			payload: null
-		}),
-		onError: (error) => emit({
-			relaySessionId,
-			type: "error",
-			message: error.message
-		}, {
-			type: "session.error",
-			payload: { message: error.message },
-			final: true
-		}),
-		onClose: (reason) => {
-			const active = relaySessions.get(relaySessionId);
-			if (!active) return;
-			active.forcedConsults.clear();
-			relaySessions.delete(relaySessionId);
-			forgetUnifiedTalkSession(relaySessionId);
-			clearTimeout(active.cleanupTimer);
-			abortRelayAgentRuns(active, "relay-closed");
-			emit({
-				relaySessionId,
-				type: "close",
-				reason
-			}, {
-				type: "session.closed",
-				payload: { reason },
-				final: true
-			});
-		}
-	});
-	relay = {
-		id: relaySessionId,
-		connId: params.connId,
-		context: params.context,
-		bridge,
-		talk,
-		sessionKey: params.sessionKey?.trim() || void 0,
-		expiresAtMs,
-		cleanupTimer: setTimeout(() => {
-			const active = relaySessions.get(relaySessionId);
-			if (active) closeRelaySession(active, "completed");
-		}, RELAY_SESSION_TTL_MS),
-		activeAgentRuns: /* @__PURE__ */ new Map(),
-		activeAgentToolCalls: /* @__PURE__ */ new Map(),
-		completedAgentToolCalls: /* @__PURE__ */ new Set(),
-		forcedConsults: createRealtimeVoiceForcedConsultCoordinator(),
-		transcript: []
-	};
-	relay.cleanupTimer.unref?.();
-	relaySessions.set(relaySessionId, relay);
-	bridge.connect().catch((error) => {
-		emit({
-			relaySessionId,
-			type: "error",
-			message: formatError(error)
-		});
-		const active = relaySessions.get(relaySessionId);
-		if (active) closeRelaySession(active, "error");
-	});
-	return {
-		provider: params.provider.id,
-		transport: "gateway-relay",
-		relaySessionId,
-		audio: {
-			inputEncoding: "pcm16",
-			inputSampleRateHz: REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ.sampleRateHz,
-			outputEncoding: "pcm16",
-			outputSampleRateHz: REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ.sampleRateHz
-		},
-		...params.model ? { model: params.model } : {},
-		...params.voice ? { voice: params.voice } : {},
-		expiresAt: Math.floor(expiresAtMs / 1e3)
-	};
-}
-function scheduleForcedAgentConsult(session, question) {
-	if (!session || !question.trim()) return;
-	if (session.forcedConsults.hasRecentNativeConsult(question)) return;
-	session.forcedConsults.clearPending();
-	const handle = session.forcedConsults.prepare(question);
-	if (!handle) return;
-	session.forcedConsults.schedule(handle, FORCED_CONSULT_FALLBACK_DELAY_MS, () => {
-		if (!relaySessions.has(session.id)) return;
-		const turnId = ensureRelayTurn(session);
-		const callId = handle.id;
-		const itemId = `forced-consult-item-${randomUUID()}`;
-		session.forcedConsults.markStarted(handle);
-		session.bridge.handleBargeIn({
-			audioPlaybackActive: true,
-			force: true
-		});
-		broadcastToOwner$1(session.context, session.connId, {
-			relaySessionId: session.id,
-			type: "toolCall",
-			itemId,
-			callId,
-			name: REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
-			forced: true,
-			args: {
-				question: handle.question,
-				context: "The realtime provider produced a final user transcript without invoking fengming_agent_consult, so FengMing is forcing the consult for realtime Talk.",
-				responseStyle: "Reply in a concise spoken tone."
-			},
-			talkEvent: session.talk.emit({
-				type: "tool.call",
-				itemId,
-				callId,
-				turnId,
-				payload: {
-					name: REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
-					args: { question: handle.question },
-					forced: true
-				}
-			})
-		});
-	});
-}
-function submitAlreadyDeliveredToolResult(session, callId, turnId = ensureRelayTurn(session)) {
-	const result = buildAlreadyDeliveredToolResult();
-	session.bridge.submitToolResult(callId, result, { suppressResponse: true });
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "toolResult",
-		callId,
-		talkEvent: session.talk.emit({
-			type: "tool.result",
-			callId,
-			turnId,
-			payload: {
-				name: REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
-				result
-			},
-			final: true
-		})
-	});
-}
-function submitRealtimeAgentConsultWorkingResponse(session, callId, turnId = ensureRelayTurn(session)) {
-	if (!session.bridge.bridge.supportsToolResultContinuation) return;
-	session.bridge.submitToolResult(callId, buildRealtimeVoiceAgentConsultWorkingResponse("person"), { willContinue: true });
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "toolResult",
-		callId,
-		talkEvent: session.talk.emit({
-			type: "tool.progress",
-			callId,
-			turnId,
-			payload: {
-				name: REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME,
-				status: "working"
-			}
-		})
-	});
-}
-function ensureRelayTurn(session) {
-	const turn = session.talk.ensureTurn();
-	if (turn.event) broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "inputAudio",
-		byteLength: 0,
-		talkEvent: turn.event
-	});
-	return turn.turnId;
-}
-function getRelaySession(relaySessionId, connId) {
-	const session = relaySessions.get(relaySessionId);
-	if (!session || session.connId !== connId || Date.now() > session.expiresAtMs) {
-		if (session) closeRelaySession(session, "completed");
-		throw new Error("未知的实时中继会话");
-	}
-	return session;
-}
-function sendTalkRealtimeRelayAudio(params) {
-	if (params.audioBase64.length > MAX_AUDIO_BASE64_BYTES$1) throw new Error("实时中继音频帧过大");
-	const session = getRelaySession(params.relaySessionId, params.connId);
-	const turnId = ensureRelayTurn(session);
-	const audio = Buffer.from(params.audioBase64, "base64");
-	session.bridge.sendAudio(audio);
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "inputAudio",
-		byteLength: audio.byteLength,
-		talkEvent: session.talk.emit({
-			type: "input.audio.delta",
-			turnId,
-			payload: { byteLength: audio.byteLength }
-		})
-	});
-	if (typeof params.timestamp === "number" && Number.isFinite(params.timestamp)) session.bridge.setMediaTimestamp(params.timestamp);
-}
-function submitTalkRealtimeRelayToolResult(params) {
-	const session = getRelaySession(params.relaySessionId, params.connId);
-	if (session.completedAgentToolCalls.has(params.callId)) return;
-	const forcedConsult = session.forcedConsults.handles().find((handle) => handle.id === params.callId);
-	if (forcedConsult) {
-		const turnId = ensureRelayTurn(session);
-		const cancelled = session.forcedConsults.isCancelled(forcedConsult);
-		if (cancelled) {
-			if (params.options?.willContinue !== true) session.forcedConsults.markCancelled(forcedConsult);
-		} else if (isWorkingToolResult(params.result)) session.bridge.sendUserMessage(buildForcedConsultCheckingPrompt());
-		else {
-			session.forcedConsults.markDelivered(forcedConsult);
-			const text = readSpeakableRealtimeVoiceToolResult(params.result, { maxChars: FORCED_CONSULT_RESULT_MAX_CHARS });
-			for (const nativeCallId of session.forcedConsults.nativeCallIds(forcedConsult)) submitAlreadyDeliveredToolResult(session, nativeCallId, turnId);
-			if (text) session.bridge.sendUserMessage(buildForcedConsultSpeechPrompt(text));
-		}
-		const final = params.options?.willContinue !== true;
-		if (final && !cancelled && !isWorkingToolResult(params.result)) session.forcedConsults.markDelivered(forcedConsult);
-		broadcastToOwner$1(session.context, session.connId, {
-			relaySessionId: session.id,
-			type: "toolResult",
-			callId: params.callId,
-			talkEvent: session.talk.emit({
-				type: "tool.result",
-				callId: params.callId,
-				turnId,
-				payload: {
-					result: params.result,
-					forced: true
-				},
-				final
-			})
-		});
-		return;
-	}
-	session.bridge.submitToolResult(params.callId, params.result, params.options);
-	const turnId = ensureRelayTurn(session);
-	const final = params.options?.willContinue !== true;
-	if (final) {
-		const runId = session.activeAgentToolCalls.get(params.callId);
-		if (runId) {
-			session.activeAgentRuns.delete(runId);
-			session.activeAgentToolCalls.delete(params.callId);
-		}
-	}
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "toolResult",
-		callId: params.callId,
-		talkEvent: session.talk.emit({
-			type: "tool.result",
-			callId: params.callId,
-			turnId,
-			payload: { result: params.result },
-			final
-		})
-	});
-}
-function registerTalkRealtimeRelayAgentRun(params) {
-	const session = getRelaySession(params.relaySessionId, params.connId);
-	session.activeAgentRuns.set(params.runId, params.sessionKey);
-	if (params.callId?.trim()) session.activeAgentToolCalls.set(params.callId.trim(), params.runId);
-	if (!session.sessionKey) session.sessionKey = params.sessionKey;
-}
-async function steerTalkRealtimeRelayAgentRun(params) {
-	const session = getRelaySession(params.relaySessionId, params.connId);
-	const sessionKey = session.sessionKey;
-	if (!sessionKey) throw new Error("实时中继操控需要会话密钥");
-	const requestedSessionKey = params.sessionKey?.trim();
-	if (requestedSessionKey && requestedSessionKey !== sessionKey) throw new Error("实时中继操控会话密钥与中继会话不匹配");
-	const result = await controlRealtimeVoiceAgentRun({
-		sessionKey,
-		text: params.text,
-		mode: params.mode,
-		recentEvents: session.talk.recentEvents
-	});
-	const turnId = ensureRelayTurn(session);
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "toolProgress",
-		result,
-		talkEvent: session.talk.emit({
-			type: "tool.progress",
-			turnId,
-			payload: {
-				name: "fengming_agent_control",
-				phase: result.mode,
-				result
-			},
-			final: result.mode === "cancel" || result.mode === "status"
-		})
-	});
-	submitRelayAgentControlProviderResults(session, result, turnId);
-	return result;
-}
-function cancelTalkRealtimeRelayTurn(params) {
-	const session = getRelaySession(params.relaySessionId, params.connId);
-	const turnId = ensureRelayTurn(session);
-	const reason = params.reason ?? "client-cancelled";
-	cancelForcedConsults(session);
-	session.bridge.handleBargeIn({ audioPlaybackActive: true });
-	abortRelayAgentRuns(session, reason);
-	const cancelled = session.talk.cancelTurn({
-		turnId,
-		payload: { reason }
-	});
-	broadcastToOwner$1(session.context, session.connId, {
-		relaySessionId: session.id,
-		type: "clear",
-		talkEvent: cancelled.ok ? cancelled.event : void 0
-	});
-}
-function stopTalkRealtimeRelaySession(params) {
-	closeRelaySession(getRelaySession(params.relaySessionId, params.connId), "completed");
-}
-//#endregion
-//#region src/gateway/talk-agent-consult.ts
-async function startTalkRealtimeAgentConsult(params) {
-	let message;
-	try {
-		message = buildRealtimeVoiceAgentConsultChatMessage(params.args);
-	} catch (err) {
-		return {
-			ok: false,
-			error: errorShape(ErrorCodes.INVALID_REQUEST, formatForLog(err))
-		};
-	}
-	const idempotencyKey = `talk-${params.callId}-${randomUUID()}`;
-	const normalizedTalk = normalizeTalkSection(params.context.getRuntimeConfig().talk);
-	let chatResponse;
-	await chatHandlers["chat.send"]({
-		req: {
-			type: "req",
-			id: `${params.requestId}:talk-tool-call`,
-			method: "chat.send"
-		},
-		client: params.client,
-		isWebchatConnect: params.isWebchatConnect,
-		context: params.context,
-		params: {
-			sessionKey: params.sessionKey,
-			message,
-			idempotencyKey,
-			...normalizedTalk?.consultThinkingLevel ? { thinking: normalizedTalk.consultThinkingLevel } : {},
-			...typeof normalizedTalk?.consultFastMode === "boolean" ? { fastMode: normalizedTalk.consultFastMode } : {}
-		},
-		respond: (ok, result, error) => {
-			chatResponse = ok ? {
-				ok: true,
-				result
-			} : {
-				ok: false,
-				error: error ?? errorShape(ErrorCodes.UNAVAILABLE, "chat.send failed without error")
-			};
-		}
-	});
-	if (!chatResponse) return {
-		ok: false,
-		error: errorShape(ErrorCodes.UNAVAILABLE, "chat.send did not return a realtime tool result")
-	};
-	if (!chatResponse.ok) return {
-		ok: false,
-		error: chatResponse.error
-	};
-	const result = chatResponse.result;
-	const runId = result && typeof result === "object" && !Array.isArray(result) ? typeof result.runId === "string" ? result.runId : idempotencyKey : idempotencyKey;
-	if (params.relaySessionId && params.connId) registerTalkRealtimeRelayAgentRun({
-		relaySessionId: params.relaySessionId,
-		connId: params.connId,
-		sessionKey: params.sessionKey,
-		runId,
-		callId: params.callId
-	});
-	return {
-		ok: true,
-		runId,
-		idempotencyKey
-	};
-}
-//#endregion
-//#region src/gateway/server-methods/talk-shared.ts
-function canUseTalkDirectTools(client) {
-	return (Array.isArray(client?.connect?.scopes) ? client.connect.scopes : []).includes(ADMIN_SCOPE);
-}
-function broadcastTalkRoomEvents(context, connId, params) {
-	if (!connId || params.events.length === 0) return;
-	for (const talkEvent of params.events) context.broadcastToConnIds("talk.event", {
-		handoffId: params.handoffId,
-		roomId: params.roomId,
-		talkEvent
-	}, new Set([connId]), { dropIfSlow: true });
-}
-function talkHandoffErrorCode(reason) {
-	return reason === "invalid_token" || reason === "no_active_turn" || reason === "stale_turn" ? ErrorCodes.INVALID_REQUEST : ErrorCodes.UNAVAILABLE;
-}
-function getRecord(value) {
-	return asOptionalRecord(value) ?? void 0;
-}
-function singleRecordKey(record) {
-	const keys = record ? Object.keys(record) : [];
-	return keys.length === 1 ? keys[0] : void 0;
-}
-function getVoiceCallRealtimeConfig(config) {
-	const realtime = getRecord(getRecord(getRecord(getRecord(getRecord(config.plugins)?.entries)?.["voice-call"])?.config)?.realtime);
-	const providersRaw = getRecord(realtime?.providers);
-	const providers = {};
-	if (providersRaw) for (const [providerId, providerConfig] of Object.entries(providersRaw)) {
-		const record = getRecord(providerConfig);
-		if (record) providers[providerId] = record;
-	}
-	return {
-		provider: normalizeOptionalString(realtime?.provider),
-		providers: Object.keys(providers).length > 0 ? providers : void 0
-	};
-}
-function getVoiceCallStreamingConfig(config) {
-	const streaming = getRecord(getRecord(getRecord(getRecord(getRecord(config.plugins)?.entries)?.["voice-call"])?.config)?.streaming);
-	const providersRaw = getRecord(streaming?.providers);
-	const providers = {};
-	if (providersRaw) for (const [providerId, providerConfig] of Object.entries(providersRaw)) {
-		const record = getRecord(providerConfig);
-		if (record) providers[providerId] = record;
-	}
-	return {
-		provider: normalizeOptionalString(streaming?.provider),
-		providers: Object.keys(providers).length > 0 ? providers : void 0
-	};
-}
-function resolveConfiguredVoiceModelDefaultRef(params) {
-	const configuredProvider = normalizeOptionalString(params.provider);
-	const refs = resolveSupportedVoiceModelRefs({
-		config: params.config.agents?.defaults?.voiceModel,
-		providers: params.providers,
-		providerId: configuredProvider
-	});
-	for (const ref of refs) {
-		const provider = params.providers.find((entry) => providerMatchesId(entry, ref.provider));
-		if (!provider) continue;
-		if (!configuredProvider) {
-			const rawConfig = getVoiceProviderConfig({
-				providerConfigs: params.providerConfigs,
-				provider
-			});
-			const rawConfigWithModel = rawConfig.model === void 0 ? {
-				...rawConfig,
-				model: ref.model
-			} : rawConfig;
-			const providerConfig = provider.resolveConfig?.({
-				cfg: params.config,
-				rawConfig: rawConfigWithModel
-			}) ?? rawConfigWithModel;
-			if (!configuredOrFalse(() => provider.isConfigured({
-				cfg: params.config,
-				providerConfig
-			}))) continue;
-		}
-		return {
-			provider: provider.id,
-			model: ref.model
-		};
-	}
-}
-function buildTalkRealtimeConfig(config, requestedProvider) {
-	const voiceCallRealtime = getVoiceCallRealtimeConfig(config);
-	const talkRealtime = getRecord(config.talk?.realtime);
-	const talkRealtimeProviderConfigs = talkRealtime?.providers;
-	const explicitProvider = normalizeOptionalString(requestedProvider) ?? normalizeOptionalString(talkRealtime?.provider);
-	const singleConfiguredProvider = normalizeOptionalString(singleRecordKey(talkRealtimeProviderConfigs));
-	const selectedProvider = explicitProvider ?? singleConfiguredProvider ?? voiceCallRealtime.provider ?? singleConfiguredProvider;
-	const providerConfigs = {
-		...voiceCallRealtime.providers,
-		...talkRealtimeProviderConfigs
-	};
-	const voiceModelDefault = resolveConfiguredVoiceModelDefaultRef({
-		config,
-		provider: selectedProvider,
-		providerConfigs,
-		providers: listRealtimeVoiceProviders(config)
-	});
-	return {
-		provider: selectedProvider ?? voiceModelDefault?.provider,
-		providers: providerConfigs,
-		model: normalizeOptionalString(talkRealtime?.model) ?? voiceModelDefault?.model,
-		voice: normalizeOptionalString(talkRealtime?.speakerVoice) ?? normalizeOptionalString(talkRealtime?.speakerVoiceId) ?? normalizeOptionalString(talkRealtime?.voice),
-		instructions: normalizeOptionalString(talkRealtime?.instructions),
-		mode: normalizeOptionalLowercaseString(talkRealtime?.mode),
-		transport: normalizeOptionalLowercaseString(talkRealtime?.transport),
-		brain: normalizeOptionalLowercaseString(talkRealtime?.brain),
-		consultRouting: normalizeOptionalLowercaseString(talkRealtime?.consultRouting)
-	};
-}
-function buildTalkTranscriptionConfig(config, requestedProvider) {
-	const streamingConfig = getVoiceCallStreamingConfig(config);
-	const provider = normalizeOptionalString(requestedProvider) ?? streamingConfig.provider;
-	const providerConfigs = streamingConfig.providers ?? {};
-	const voiceModelDefault = resolveConfiguredVoiceModelDefaultRef({
-		config,
-		provider,
-		providerConfigs,
-		providers: listRealtimeTranscriptionProviders(config)
-	});
-	return {
-		provider: provider ?? voiceModelDefault?.provider,
-		providers: providerConfigs,
-		model: voiceModelDefault?.model
-	};
-}
-function configuredOrFalse(callback) {
-	try {
-		return callback();
-	} catch {
-		return false;
-	}
-}
-function resolveConfiguredRealtimeTranscriptionProvider(params) {
-	const providers = listRealtimeTranscriptionProviders(params.config);
-	const normalizedConfigured = normalizeOptionalLowercaseString(params.configuredProviderId);
-	const orderedProviders = normalizedConfigured ? providers.filter((provider) => normalizeOptionalLowercaseString(provider.id) === normalizedConfigured || (provider.aliases ?? []).some((alias) => normalizeOptionalLowercaseString(alias) === normalizedConfigured)) : providers.toSorted((a, b) => (a.autoSelectOrder ?? 1e3) - (b.autoSelectOrder ?? 1e3));
-	for (const provider of orderedProviders) {
-		const rawConfig = getVoiceProviderConfig({
-			providerConfigs: params.providerConfigs,
-			provider,
-			configuredProviderId: params.configuredProviderId
-		});
-		const rawConfigWithModel = params.defaultModel && rawConfig.model === void 0 ? {
-			...rawConfig,
-			model: params.defaultModel
-		} : rawConfig;
-		const providerConfig = provider.resolveConfig?.({
-			cfg: params.config,
-			rawConfig: rawConfigWithModel
-		}) ?? rawConfigWithModel;
-		if (configuredOrFalse(() => provider.isConfigured({
-			cfg: params.config,
-			providerConfig
-		}))) return {
-			provider,
-			providerConfig
-		};
-	}
-	if (normalizedConfigured) throw new Error(`Realtime transcription provider "${params.configuredProviderId}" is not configured`);
-	throw new Error("没有注册实时转录提供商");
-}
-const DEFAULT_REALTIME_INSTRUCTIONS = [
-	"You are FengMing's realtime voice interface. Keep spoken replies concise.",
-	`If the user asks for code, repository state, files, current FengMing context, tool-backed actions, or deeper reasoning, call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} and then summarize the result naturally.`,
-	`Do not claim you cannot use tools, perform actions, or reach FengMing unless ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} returns that failure.`,
-	`When ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} is in progress, speak one brief acknowledgement such as "Let me check that for you", then wait for the final FengMing result before answering with the actual result.`,
-	`If FengMing is already working through ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} and the user asks in any language for progress, cancellation, a redirect/change, or a follow-up, call ${REALTIME_VOICE_AGENT_CONTROL_TOOL_NAME} with the semantic mode.`,
-	"For greetings and casual chatter while FengMing is working, answer naturally and do not redirect the active work."
-].join(" ");
-function buildRealtimeInstructions(configuredInstructions) {
-	const extra = normalizeOptionalString(configuredInstructions);
-	if (!extra) return DEFAULT_REALTIME_INSTRUCTIONS;
-	return `${DEFAULT_REALTIME_INSTRUCTIONS}\n\nAdditional realtime instructions:\n${extra}`;
-}
-function buildRealtimeVoiceLaunchOptions(params) {
-	return {
-		...pickRealtimeVoiceLaunchOptions(params.defaults),
-		...pickRealtimeVoiceLaunchOptions(params.requested)
-	};
-}
-function withRealtimeBrowserOverrides(providerConfig, params) {
-	const overrides = {};
-	const model = normalizeOptionalString(params.model);
-	const voice = normalizeOptionalString(params.voice);
-	const reasoningEffort = normalizeOptionalString(params.reasoningEffort);
-	if (model) overrides.model = model;
-	if (voice) overrides.voice = voice;
-	if (typeof params.vadThreshold === "number" && Number.isFinite(params.vadThreshold)) overrides.vadThreshold = params.vadThreshold;
-	if (typeof params.silenceDurationMs === "number" && Number.isFinite(params.silenceDurationMs)) overrides.silenceDurationMs = params.silenceDurationMs;
-	if (typeof params.prefixPaddingMs === "number" && Number.isFinite(params.prefixPaddingMs)) overrides.prefixPaddingMs = params.prefixPaddingMs;
-	if (reasoningEffort) overrides.reasoningEffort = reasoningEffort;
-	return Object.keys(overrides).length > 0 ? {
-		...providerConfig,
-		...overrides
-	} : providerConfig;
-}
-function pickRealtimeVoiceLaunchOptions(params) {
-	const options = {};
-	const model = normalizeOptionalString(params.model);
-	const voice = normalizeOptionalString(params.voice);
-	const reasoningEffort = normalizeOptionalString(params.reasoningEffort);
-	if (model) options.model = model;
-	if (voice) options.voice = voice;
-	if (typeof params.vadThreshold === "number" && Number.isFinite(params.vadThreshold)) options.vadThreshold = params.vadThreshold;
-	if (typeof params.silenceDurationMs === "number" && Number.isFinite(params.silenceDurationMs)) options.silenceDurationMs = params.silenceDurationMs;
-	if (typeof params.prefixPaddingMs === "number" && Number.isFinite(params.prefixPaddingMs)) options.prefixPaddingMs = params.prefixPaddingMs;
-	if (reasoningEffort) options.reasoningEffort = reasoningEffort;
-	return options;
-}
-function isUnsupportedBrowserWebRtcSession(session) {
-	const provider = normalizeLowercaseStringOrEmpty(session.provider);
-	const transport = session.transport ?? "webrtc";
-	return provider === "google" && transport === "webrtc";
-}
-//#endregion
-//#region src/gateway/server-methods/talk-client.ts
-const talkClientHandlers = {
-	"talk.client.create": async ({ params, respond, context }) => {
-		if (!validateTalkClientCreateParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.client.create params: ${formatValidationErrors(validateTalkClientCreateParams.errors)}`));
-			return;
-		}
-		const typedParams = params;
-		try {
-			const runtimeConfig = context.getRuntimeConfig();
-			const realtimeConfig = buildTalkRealtimeConfig(runtimeConfig, typedParams.provider);
-			const mode = normalizeOptionalLowercaseString(typedParams.mode) ?? realtimeConfig.mode ?? "realtime";
-			if (mode !== "realtime") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.client.create only supports mode="realtime"; use talk.catalog for ${mode} provider discovery`));
-				return;
-			}
-			if ((normalizeOptionalLowercaseString(typedParams.brain) ?? realtimeConfig.brain ?? "agent-consult") !== "agent-consult") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.client.create only supports brain="agent-consult"`));
-				return;
-			}
-			const transport = normalizeOptionalLowercaseString(typedParams.transport) ?? realtimeConfig.transport;
-			if (transport === "managed-room") {
-				respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, "managed-room realtime Talk sessions are not available in the browser UI yet"));
-				return;
-			}
-			if (transport === "gateway-relay") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.client.create is client-owned; use talk.session.create for gateway-relay`));
-				return;
-			}
-			const resolution = resolveConfiguredRealtimeVoiceProvider({
-				configuredProviderId: realtimeConfig.provider,
-				providerConfigs: realtimeConfig.providers,
-				cfg: runtimeConfig,
-				cfgForResolve: runtimeConfig,
-				defaultModel: realtimeConfig.model,
-				noRegisteredProviderMessage: "No realtime voice provider registered"
-			});
-			const launchOptions = buildRealtimeVoiceLaunchOptions({
-				requested: typedParams,
-				defaults: realtimeConfig
-			});
-			if (resolution.provider.createBrowserSession && transport !== "gateway-relay") {
-				const session = await resolution.provider.createBrowserSession({
-					cfg: runtimeConfig,
-					providerConfig: resolution.providerConfig,
-					instructions: buildRealtimeInstructions(realtimeConfig.instructions),
-					tools: [REALTIME_VOICE_AGENT_CONSULT_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL],
-					...launchOptions
-				});
-				if (!isUnsupportedBrowserWebRtcSession(session) && (!transport || session.transport === transport)) {
-					respond(true, session, void 0);
-					return;
-				}
-				if (transport) {
-					respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, `Realtime provider "${resolution.provider.id}" does not support requested browser transport "${transport}"`));
-					return;
-				}
-			}
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, `Realtime provider "${resolution.provider.id}" does not support client-owned realtime sessions`));
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.client.toolCall": async (request) => {
-		const { params, respond } = request;
-		if (!validateTalkClientToolCallParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.client.toolCall params: ${formatValidationErrors(validateTalkClientToolCallParams.errors)}`));
-			return;
-		}
-		if (params.name !== "fengming_agent_consult") {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `unsupported realtime Talk tool: ${params.name}`));
-			return;
-		}
-		const result = await startTalkRealtimeAgentConsult({
-			context: request.context,
-			client: request.client,
-			isWebchatConnect: request.isWebchatConnect,
-			requestId: request.req.id,
-			sessionKey: params.sessionKey,
-			callId: params.callId,
-			args: params.args ?? {},
-			relaySessionId: normalizeOptionalString(params.relaySessionId),
-			connId: normalizeOptionalString(request.client?.connId)
-		});
-		if (!result.ok) {
-			respond(false, void 0, result.error);
-			return;
-		}
-		respond(true, {
-			runId: result.runId,
-			idempotencyKey: result.idempotencyKey
-		}, void 0);
-	},
-	"talk.client.steer": async ({ params, respond, client, context }) => {
-		if (!validateTalkClientSteerParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.client.steer params: ${formatValidationErrors(validateTalkClientSteerParams.errors)}`));
-			return;
-		}
-		if (!hasOwnedActiveTalkClientRun({
-			context,
-			clientConnId: client?.connId,
-			sessionKey: params.sessionKey
-		})) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.client.steer requires an active browser-owned Talk run"));
-			return;
-		}
-		try {
-			respond(true, await controlRealtimeVoiceAgentRun({
-				sessionKey: params.sessionKey,
-				text: params.text,
-				mode: params.mode
-			}), void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	}
-};
-function hasOwnedActiveTalkClientRun(params) {
-	const connId = normalizeOptionalString(params.clientConnId);
-	const sessionKey = params.sessionKey.trim();
-	if (!connId || !sessionKey) return false;
-	for (const entry of params.context.chatAbortControllers.values()) if (entry.sessionKey === sessionKey && entry.ownerConnId === connId && entry.kind !== "agent") return true;
-	return false;
-}
-//#endregion
-//#region src/gateway/talk-handoff.ts
-const DEFAULT_TALK_HANDOFF_TTL_MS = 600 * 1e3;
-const MAX_TALK_HANDOFF_TTL_MS = 3600 * 1e3;
-const handoffs = /* @__PURE__ */ new Map();
-function createTalkHandoff(params) {
-	pruneExpiredTalkHandoffs();
-	const createdAt = Date.now();
-	const ttlMs = normalizeTtlMs(params.ttlMs);
-	const id = randomUUID();
-	const roomId = `talk_${id}`;
-	const token = randomBytes(32).toString("base64url");
-	const room = createTalkHandoffRoom({
-		roomId,
-		mode: params.mode ?? "stt-tts",
-		transport: params.transport ?? "managed-room",
-		brain: params.brain ?? "agent-consult",
-		provider: params.provider
-	});
-	const record = {
-		id,
-		roomId,
-		roomUrl: `/talk/rooms/${roomId}`,
-		tokenHash: hashTalkHandoffToken(token),
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId,
-		channel: params.channel,
-		target: params.target,
-		provider: params.provider,
-		model: params.model,
-		voice: params.voice,
-		mode: params.mode ?? "stt-tts",
-		transport: params.transport ?? "managed-room",
-		brain: params.brain ?? "agent-consult",
-		createdAt,
-		expiresAt: createdAt + ttlMs,
-		room
-	};
-	appendTalkHandoffRoomEvent(record, {
-		type: "session.started",
-		payload: {
-			handoffId: id,
-			roomId
-		}
-	});
-	handoffs.set(id, record);
-	return {
-		...toPublicTalkHandoffRecord(record),
-		token
-	};
-}
-function getTalkHandoff(id) {
-	pruneExpiredTalkHandoffs();
-	return handoffs.get(id);
-}
-function joinTalkHandoff(id, token, opts = {}) {
-	const access = resolveTalkHandoffAccess(id, token);
-	if (!access.ok) return access;
-	const record = access.record;
-	const previousClientId = record.room.activeClientId;
-	const events = joinTalkHandoffRoom(record, opts.clientId);
-	const replacedClientId = previousClientId && previousClientId !== opts.clientId ? previousClientId : void 0;
-	const replacementEvents = replacedClientId ? events.filter((event) => event.type === "session.replaced") : [];
-	const activeClientEvents = replacedClientId ? events.filter((event) => event.type !== "session.replaced") : events;
-	return {
-		ok: true,
-		record: toPublicTalkHandoffRecord(record),
-		events,
-		replacedClientId,
-		replacementEvents,
-		activeClientEvents
-	};
-}
-function startTalkHandoffTurn(id, token, opts = {}) {
-	const access = resolveTalkHandoffAccess(id, token);
-	if (!access.ok) return access;
-	const record = access.record;
-	if (opts.clientId) record.room.activeClientId = opts.clientId;
-	const turnId = normalizeOptionalString(opts.turnId) ?? randomUUID();
-	const turn = record.room.talk.startTurn({
-		turnId,
-		payload: {
-			handoffId: id,
-			roomId: record.roomId,
-			clientId: record.room.activeClientId
-		}
-	});
-	return {
-		ok: true,
-		record: toPublicTalkHandoffRecord(record),
-		turnId,
-		events: turn.event ? [turn.event] : []
-	};
-}
-function endTalkHandoffTurn(id, token, opts = {}) {
-	const access = resolveTalkHandoffAccess(id, token);
-	if (!access.ok) return access;
-	const record = access.record;
-	const result = record.room.talk.endTurn({
-		turnId: normalizeOptionalString(opts.turnId),
-		payload: {
-			handoffId: id,
-			roomId: record.roomId
-		}
-	});
-	if (!result.ok) return result;
-	return {
-		ok: true,
-		record: toPublicTalkHandoffRecord(record),
-		turnId: result.turnId,
-		events: [result.event]
-	};
-}
-function cancelTalkHandoffTurn(id, token, opts = {}) {
-	const access = resolveTalkHandoffAccess(id, token);
-	if (!access.ok) return access;
-	const record = access.record;
-	const result = record.room.talk.cancelTurn({
-		turnId: normalizeOptionalString(opts.turnId),
-		payload: {
-			handoffId: id,
-			roomId: record.roomId,
-			reason: opts.reason ?? "client-cancelled"
-		}
-	});
-	if (!result.ok) return result;
-	return {
-		ok: true,
-		record: toPublicTalkHandoffRecord(record),
-		turnId: result.turnId,
-		events: [result.event]
-	};
-}
-function revokeTalkHandoff(id) {
-	pruneExpiredTalkHandoffs();
-	const record = handoffs.get(id);
-	if (!record) return {
-		revoked: false,
-		events: []
-	};
-	const event = appendTalkHandoffRoomEvent(record, {
-		type: "session.closed",
-		payload: {
-			reason: "revoked",
-			handoffId: id,
-			roomId: record.roomId
-		},
-		final: true
-	});
-	handoffs.delete(id);
-	return {
-		revoked: true,
-		roomId: record.roomId,
-		activeClientId: record.room.activeClientId,
-		events: [event]
-	};
-}
-function verifyTalkHandoffToken(record, token) {
-	return record.tokenHash === hashTalkHandoffToken(token);
-}
-function normalizeTtlMs(value) {
-	if (!Number.isFinite(value) || value === void 0) return DEFAULT_TALK_HANDOFF_TTL_MS;
-	return Math.min(Math.max(Math.trunc(value), 1e3), MAX_TALK_HANDOFF_TTL_MS);
-}
-function pruneExpiredTalkHandoffs(now = Date.now()) {
-	for (const [id, record] of handoffs) if (record.expiresAt <= now) {
-		appendTalkHandoffRoomEvent(record, {
-			type: "session.closed",
-			payload: {
-				reason: "expired",
-				handoffId: id,
-				roomId: record.roomId
-			},
-			final: true
-		});
-		handoffs.delete(id);
-	}
-}
-function hashTalkHandoffToken(token) {
-	return createHash("sha256").update(token).digest("base64url");
-}
-function toPublicTalkHandoffRecord(record) {
-	const { tokenHash: _tokenHash, room: _room, ...publicRecord } = record;
-	return {
-		...publicRecord,
-		room: {
-			activeClientId: record.room.activeClientId,
-			activeTurnId: record.room.talk.activeTurnId,
-			recentTalkEvents: [...record.room.talk.recentEvents]
-		}
-	};
-}
-function createTalkHandoffRoom(params) {
-	return { talk: createTalkSessionController({
-		sessionId: params.roomId,
-		mode: params.mode,
-		transport: params.transport,
-		brain: params.brain,
-		provider: params.provider
-	}, { onEvent: recordTalkObservabilityEvent }) };
-}
-function resolveTalkHandoffAccess(id, token) {
-	const record = handoffs.get(id);
-	if (!record) return {
-		ok: false,
-		reason: "not_found"
-	};
-	if (record.expiresAt <= Date.now()) {
-		appendTalkHandoffRoomEvent(record, {
-			type: "session.closed",
-			payload: {
-				reason: "expired",
-				handoffId: id,
-				roomId: record.roomId
-			},
-			final: true
-		});
-		handoffs.delete(id);
-		return {
-			ok: false,
-			reason: "expired"
-		};
-	}
-	if (!verifyTalkHandoffToken(record, token)) return {
-		ok: false,
-		reason: "invalid_token"
-	};
-	return {
-		ok: true,
-		record
-	};
-}
-function appendTalkHandoffRoomEvent(record, input) {
-	return record.room.talk.emit(input);
-}
-function joinTalkHandoffRoom(record, clientId) {
-	const events = [];
-	if (record.room.activeClientId && record.room.activeClientId !== clientId) events.push(appendTalkHandoffRoomEvent(record, {
-		type: "session.replaced",
-		payload: {
-			handoffId: record.id,
-			roomId: record.roomId,
-			previousClientId: record.room.activeClientId,
-			nextClientId: clientId
-		}
-	}));
-	record.room.activeClientId = clientId;
-	events.push(appendTalkHandoffRoomEvent(record, {
-		type: "session.ready",
-		payload: {
-			handoffId: record.id,
-			roomId: record.roomId,
-			clientId
-		}
-	}));
-	return events;
-}
-//#endregion
-//#region src/gateway/talk-transcription-relay.ts
-const TRANSCRIPTION_SESSION_TTL_MS = 1800 * 1e3;
-const MAX_AUDIO_BASE64_BYTES = 512 * 1024;
-const MAX_TRANSCRIPTION_SESSIONS_PER_CONN = 2;
-const MAX_TRANSCRIPTION_SESSIONS_GLOBAL = 64;
-const TRANSCRIPTION_EVENT = "talk.event";
-const RELAY_INPUT_ENCODING = "g711_ulaw";
-const RELAY_INPUT_SAMPLE_RATE_HZ = 8e3;
-const transcriptionSessions = /* @__PURE__ */ new Map();
-function normalizeRelayInputEncoding(value) {
-	if (typeof value !== "string") return;
-	const normalized = value.trim().toLowerCase();
-	if (!normalized) return;
-	if (normalized === "mulaw" || normalized === "ulaw" || normalized === "g711_ulaw" || normalized === "g711-mulaw" || normalized === "pcm_mulaw" || normalized === "audio/pcmu" || normalized === "ulaw_8000") return "g711_ulaw";
-	if (normalized === "alaw" || normalized === "g711_alaw" || normalized === "g711-alaw" || normalized === "pcm_alaw") return "g711_alaw";
-	if (normalized === "pcm" || normalized === "pcm16" || normalized === "linear16" || normalized === "pcm_s16le") return "pcm16";
-}
-function inferSampleRateFromAudioFormat(value) {
-	if (typeof value !== "string") return;
-	const match = value.match(/_(\d+)$/);
-	return match ? parseFiniteNumber(match[1]) : void 0;
-}
-function assertRelayInputAudioConfig(providerConfig) {
-	const encodingValue = providerConfig.encoding ?? providerConfig.audioFormat ?? providerConfig.audio_format;
-	const encoding = normalizeRelayInputEncoding(encodingValue);
-	if (encoding && encoding !== RELAY_INPUT_ENCODING) throw new Error(`Gateway transcription relay requires ${RELAY_INPUT_ENCODING}/${RELAY_INPUT_SAMPLE_RATE_HZ} audio`);
-	const sampleRate = parseFiniteNumber(providerConfig.sampleRate ?? providerConfig.sample_rate) ?? inferSampleRateFromAudioFormat(encodingValue);
-	if (sampleRate && sampleRate !== RELAY_INPUT_SAMPLE_RATE_HZ) throw new Error(`Gateway transcription relay requires ${RELAY_INPUT_ENCODING}/${RELAY_INPUT_SAMPLE_RATE_HZ} audio`);
-}
-function broadcastToOwner(context, connId, event) {
-	context.broadcastToConnIds(TRANSCRIPTION_EVENT, event, new Set([connId]), { dropIfSlow: true });
-}
-function ensureTranscriptionTurn(session) {
-	const turn = session.talk.ensureTurn();
-	if (turn.event) broadcastToOwner(session.context, session.connId, {
-		transcriptionSessionId: session.id,
-		type: "speechStart",
-		talkEvent: turn.event
-	});
-	return turn.turnId;
-}
-function closeTranscriptionSession(session, reason) {
-	if (session.closed) return;
-	session.closed = true;
-	transcriptionSessions.delete(session.id);
-	clearTimeout(session.cleanupTimer);
-	session.sttSession.close();
-	broadcastToOwner(session.context, session.connId, {
-		transcriptionSessionId: session.id,
-		type: "close",
-		reason,
-		talkEvent: session.talk.emit({
-			type: "session.closed",
-			payload: { reason },
-			final: true
-		})
-	});
-}
-function pruneExpiredTranscriptionSessions(nowMs = Date.now()) {
-	for (const session of transcriptionSessions.values()) if (nowMs > session.expiresAtMs) closeTranscriptionSession(session, "completed");
-}
-function countTranscriptionSessionsForConn(connId) {
-	let count = 0;
-	for (const session of transcriptionSessions.values()) if (session.connId === connId) count += 1;
-	return count;
-}
-function enforceTranscriptionSessionLimits(connId) {
-	pruneExpiredTranscriptionSessions();
-	if (transcriptionSessions.size >= MAX_TRANSCRIPTION_SESSIONS_GLOBAL) throw new Error("活跃的转录通话会话过多");
-	if (countTranscriptionSessionsForConn(connId) >= MAX_TRANSCRIPTION_SESSIONS_PER_CONN) throw new Error("此连接的活跃转录通话会话过多");
-}
-function createTalkTranscriptionRelaySession(params) {
-	enforceTranscriptionSessionLimits(params.connId);
-	assertRelayInputAudioConfig(params.providerConfig);
-	const transcriptionSessionId = randomUUID();
-	const expiresAtMs = Date.now() + TRANSCRIPTION_SESSION_TTL_MS;
-	const talk = createTalkSessionController({
-		sessionId: transcriptionSessionId,
-		mode: "transcription",
-		transport: "gateway-relay",
-		brain: "none",
-		provider: params.provider.id
-	}, { onEvent: recordTalkObservabilityEvent });
-	let relay;
-	const emit = (event, talkEvent) => {
-		broadcastToOwner(params.context, params.connId, {
-			...event,
-			...talkEvent ? { talkEvent: talk.emit(talkEvent) } : {}
-		});
-	};
-	const ensureTurnId = () => {
-		return relay ? ensureTranscriptionTurn(relay) : "turn-1";
-	};
-	const sttSession = params.provider.createSession({
-		cfg: params.context.getRuntimeConfig(),
-		providerConfig: params.providerConfig,
-		onSpeechStart: () => {
-			ensureTurnId();
-		},
-		onPartial: (text) => {
-			const turnId = ensureTurnId();
-			emit({
-				transcriptionSessionId,
-				type: "partial",
-				text
-			}, {
-				type: "transcript.delta",
-				turnId,
-				payload: { text }
-			});
-		},
-		onTranscript: (text) => {
-			const turnId = ensureTurnId();
-			emit({
-				transcriptionSessionId,
-				type: "transcript",
-				text,
-				final: true
-			}, {
-				type: "transcript.done",
-				turnId,
-				payload: { text },
-				final: true
-			});
-			if (relay) {
-				const ended = relay.talk.endTurn({
-					turnId,
-					payload: {}
-				});
-				if (ended.ok) broadcastToOwner(relay.context, relay.connId, {
-					transcriptionSessionId,
-					type: "transcript",
-					text: "",
-					final: true,
-					talkEvent: ended.event
-				});
-			}
-		},
-		onError: (error) => {
-			emit({
-				transcriptionSessionId,
-				type: "error",
-				message: error.message
-			}, {
-				type: "session.error",
-				payload: { message: error.message },
-				final: true
-			});
-			if (relay) closeTranscriptionSession(relay, "error");
-		}
-	});
-	relay = {
-		id: transcriptionSessionId,
-		connId: params.connId,
-		context: params.context,
-		provider: params.provider,
-		sttSession,
-		talk,
-		expiresAtMs,
-		cleanupTimer: setTimeout(() => {
-			const active = transcriptionSessions.get(transcriptionSessionId);
-			if (active) closeTranscriptionSession(active, "completed");
-		}, TRANSCRIPTION_SESSION_TTL_MS),
-		closed: false
-	};
-	relay.cleanupTimer.unref?.();
-	transcriptionSessions.set(transcriptionSessionId, relay);
-	sttSession.connect().then(() => {
-		emit({
-			transcriptionSessionId,
-			type: "ready"
-		}, {
-			type: "session.ready",
-			payload: null
-		});
-	}).catch((error) => {
-		emit({
-			transcriptionSessionId,
-			type: "error",
-			message: error instanceof Error ? error.message : String(error)
-		}, {
-			type: "session.error",
-			payload: { message: error instanceof Error ? error.message : String(error) },
-			final: true
-		});
-		const active = transcriptionSessions.get(transcriptionSessionId);
-		if (active) closeTranscriptionSession(active, "error");
-	});
-	return {
-		provider: params.provider.id,
-		mode: "transcription",
-		transport: "gateway-relay",
-		transcriptionSessionId,
-		audio: {
-			inputEncoding: RELAY_INPUT_ENCODING,
-			inputSampleRateHz: RELAY_INPUT_SAMPLE_RATE_HZ
-		},
-		expiresAt: Math.floor(expiresAtMs / 1e3)
-	};
-}
-function getTranscriptionSession(transcriptionSessionId, connId) {
-	const session = transcriptionSessions.get(transcriptionSessionId);
-	if (!session || session.connId !== connId || Date.now() > session.expiresAtMs) {
-		if (session) closeTranscriptionSession(session, "completed");
-		throw new Error("未知的转录通话会话");
-	}
-	return session;
-}
-function sendTalkTranscriptionRelayAudio(params) {
-	if (params.audioBase64.length > MAX_AUDIO_BASE64_BYTES) throw new Error("转录通话音频帧过大");
-	const session = getTranscriptionSession(params.transcriptionSessionId, params.connId);
-	const audio = Buffer.from(params.audioBase64, "base64");
-	const turnId = ensureTranscriptionTurn(session);
-	session.sttSession.sendAudio(audio);
-	broadcastToOwner(session.context, session.connId, {
-		transcriptionSessionId: session.id,
-		type: "inputAudio",
-		byteLength: audio.byteLength,
-		talkEvent: session.talk.emit({
-			type: "input.audio.delta",
-			turnId,
-			payload: { byteLength: audio.byteLength }
-		})
-	});
-}
-function stopTalkTranscriptionRelaySession(params) {
-	const session = getTranscriptionSession(params.transcriptionSessionId, params.connId);
-	if (session.talk.activeTurnId) broadcastToOwner(session.context, session.connId, {
-		transcriptionSessionId: session.id,
-		type: "transcript",
-		text: "",
-		final: true,
-		talkEvent: session.talk.emit({
-			type: "input.audio.committed",
-			turnId: session.talk.activeTurnId,
-			payload: {},
-			final: true
-		})
-	});
-	closeTranscriptionSession(session, "completed");
-}
-function cancelTalkTranscriptionRelayTurn(params) {
-	const session = getTranscriptionSession(params.transcriptionSessionId, params.connId);
-	const turnId = ensureTranscriptionTurn(session);
-	const cancelled = session.talk.cancelTurn({
-		turnId,
-		payload: { reason: params.reason ?? "client-cancelled" }
-	});
-	broadcastToOwner(session.context, session.connId, {
-		transcriptionSessionId: session.id,
-		type: "transcript",
-		text: "",
-		final: true,
-		talkEvent: cancelled.ok ? cancelled.event : void 0
-	});
-	closeTranscriptionSession(session, "completed");
-}
-//#endregion
-//#region src/gateway/server-methods/talk-session.ts
-function normalizeTalkSessionMode(params) {
-	const mode = normalizeOptionalLowercaseString(params.mode);
-	if (mode) return mode;
-	return normalizeOptionalLowercaseString(params.transport) === "managed-room" ? "stt-tts" : "realtime";
-}
-function normalizeTalkSessionTransport(params) {
-	const transport = normalizeOptionalLowercaseString(params.transport);
-	if (transport) return transport;
-	return params.mode === "stt-tts" ? "managed-room" : "gateway-relay";
-}
-function normalizeTalkSessionBrain(params) {
-	const brain = normalizeOptionalLowercaseString(params.brain);
-	if (brain) return brain;
-	return params.mode === "transcription" ? "none" : "agent-consult";
-}
-function isActiveManagedRoomClient(session, connId) {
-	if (!connId) return false;
-	return getTalkHandoff(session.handoffId)?.room.activeClientId === connId;
-}
-function canCloseManagedRoomSession(session, connId) {
-	const handoff = getTalkHandoff(session.handoffId);
-	return !handoff?.room.activeClientId || handoff.room.activeClientId === connId;
-}
-function canCreateUnscopedManagedRoomSession(client) {
-	return client?.connect?.scopes?.includes(ADMIN_SCOPE) === true;
-}
-function managedRoomOwnershipError(action) {
-	return errorShape(ErrorCodes.INVALID_REQUEST, `talk.session.${action} requires the active managed-room connection`);
-}
-const talkSessionHandlers = {
-	"talk.session.create": async ({ params, respond, context, client }) => {
-		if (!validateTalkSessionCreateParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.create params: ${formatValidationErrors(validateTalkSessionCreateParams.errors)}`));
-			return;
-		}
-		const mode = normalizeTalkSessionMode(params);
-		const transport = normalizeTalkSessionTransport({
-			mode,
-			transport: params.transport
-		});
-		const brain = normalizeTalkSessionBrain({
-			mode,
-			brain: params.brain
-		});
-		if (transport === "webrtc" || transport === "provider-websocket") {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.session.create is Gateway-managed; use talk.client.create for client transport "${transport}"`));
-			return;
-		}
-		try {
-			if (transport === "managed-room") {
-				if (brain === "direct-tools" && !canUseTalkDirectTools(client)) {
-					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.session.create brain="direct-tools" requires gateway scope: ${ADMIN_SCOPE}`));
-					return;
-				}
-				const spawnedBy = normalizeOptionalString(params.spawnedBy);
-				if (normalizeOptionalString(params.sessionKey) && !spawnedBy && !canCreateUnscopedManagedRoomSession(client)) {
-					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `talk.session.create managed-room sessionKey requires spawnedBy or gateway scope: ${ADMIN_SCOPE}`));
-					return;
-				}
-				const resolvedSession = await resolveSessionKeyFromResolveParams({
-					cfg: context.getRuntimeConfig(),
-					p: {
-						key: params.sessionKey,
-						...spawnedBy ? { spawnedBy } : {},
-						includeGlobal: true,
-						includeUnknown: true
-					}
-				});
-				if (!resolvedSession.ok) {
-					respond(false, void 0, resolvedSession.error);
-					return;
-				}
-				const handoff = createTalkHandoff({
-					sessionKey: resolvedSession.key,
-					provider: normalizeOptionalString(params.provider),
-					model: normalizeOptionalString(params.model),
-					voice: normalizeOptionalString(params.voice),
-					mode,
-					transport,
-					brain,
-					ttlMs: params.ttlMs
-				});
-				rememberUnifiedTalkSession(handoff.id, {
-					kind: "managed-room",
-					handoffId: handoff.id,
-					token: handoff.token,
-					roomId: handoff.roomId
-				});
-				respond(true, {
-					sessionId: handoff.id,
-					provider: handoff.provider,
-					mode: handoff.mode,
-					transport: handoff.transport,
-					brain: handoff.brain,
-					handoffId: handoff.id,
-					roomId: handoff.roomId,
-					roomUrl: handoff.roomUrl,
-					token: handoff.token,
-					model: handoff.model,
-					voice: handoff.voice,
-					expiresAt: handoff.expiresAt
-				}, void 0);
-				return;
-			}
-			const connId = client?.connId;
-			if (!connId) {
-				respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, "Talk session unavailable"));
-				return;
-			}
-			if (mode === "realtime") {
-				if (transport !== "gateway-relay" || brain !== "agent-consult") {
-					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `realtime talk.session.create requires transport="gateway-relay" and brain="agent-consult"`));
-					return;
-				}
-				const runtimeConfig = context.getRuntimeConfig();
-				const realtimeConfig = buildTalkRealtimeConfig(runtimeConfig, params.provider);
-				const resolution = resolveConfiguredRealtimeVoiceProvider({
-					configuredProviderId: realtimeConfig.provider,
-					providerConfigs: realtimeConfig.providers,
-					cfg: runtimeConfig,
-					cfgForResolve: runtimeConfig,
-					defaultModel: realtimeConfig.model,
-					noRegisteredProviderMessage: "No realtime voice provider registered"
-				});
-				const launchOptions = buildRealtimeVoiceLaunchOptions({
-					requested: params,
-					defaults: realtimeConfig
-				});
-				const session = createTalkRealtimeRelaySession({
-					context,
-					connId,
-					cfg: runtimeConfig,
-					provider: resolution.provider,
-					providerConfig: withRealtimeBrowserOverrides(resolution.providerConfig, launchOptions),
-					instructions: buildRealtimeInstructions(realtimeConfig.instructions),
-					tools: [REALTIME_VOICE_AGENT_CONSULT_TOOL, REALTIME_VOICE_AGENT_CONTROL_TOOL],
-					model: launchOptions.model,
-					sessionKey: normalizeOptionalString(params.sessionKey),
-					voice: launchOptions.voice,
-					forceAgentConsultOnFinalTranscript: realtimeConfig.consultRouting === "force-agent-consult"
-				});
-				rememberUnifiedTalkSession(session.relaySessionId, {
-					kind: "realtime-relay",
-					connId,
-					relaySessionId: session.relaySessionId
-				});
-				respond(true, {
-					...session,
-					sessionId: session.relaySessionId,
-					mode,
-					brain
-				}, void 0);
-				return;
-			}
-			if (mode === "transcription") {
-				if (transport !== "gateway-relay" || brain !== "none") {
-					respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `transcription talk.session.create requires transport="gateway-relay" and brain="none"`));
-					return;
-				}
-				const runtimeConfig = context.getRuntimeConfig();
-				const transcriptionConfig = buildTalkTranscriptionConfig(runtimeConfig, params.provider);
-				const resolution = resolveConfiguredRealtimeTranscriptionProvider({
-					config: runtimeConfig,
-					configuredProviderId: transcriptionConfig.provider,
-					providerConfigs: transcriptionConfig.providers,
-					defaultModel: transcriptionConfig.model
-				});
-				const session = createTalkTranscriptionRelaySession({
-					context,
-					connId,
-					provider: resolution.provider,
-					providerConfig: resolution.providerConfig
-				});
-				rememberUnifiedTalkSession(session.transcriptionSessionId, {
-					kind: "transcription-relay",
-					connId,
-					transcriptionSessionId: session.transcriptionSessionId
-				});
-				respond(true, {
-					...session,
-					sessionId: session.transcriptionSessionId,
-					brain
-				}, void 0);
-				return;
-			}
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `stt-tts talk.session.create requires transport="managed-room"`));
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.join": async ({ params, respond, client, context }) => {
-		if (!validateTalkSessionJoinParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.join params: ${formatValidationErrors(validateTalkSessionJoinParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind !== "managed-room") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.join requires a managed-room session"));
-				return;
-			}
-			const result = joinTalkHandoff(session.handoffId, params.token, { clientId: client?.connId });
-			if (!result.ok) {
-				respond(false, void 0, errorShape(result.reason === "invalid_token" ? ErrorCodes.INVALID_REQUEST : ErrorCodes.UNAVAILABLE, `talk session join failed: ${result.reason}`));
-				return;
-			}
-			broadcastTalkRoomEvents(context, result.replacedClientId, {
-				handoffId: result.record.id,
-				roomId: result.record.roomId,
-				events: result.replacementEvents
-			});
-			broadcastTalkRoomEvents(context, client?.connId, {
-				handoffId: result.record.id,
-				roomId: result.record.roomId,
-				events: result.activeClientEvents
-			});
-			respond(true, result.record, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.appendAudio": async ({ params, respond, client }) => {
-		if (!validateTalkSessionAppendAudioParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.appendAudio params: ${formatValidationErrors(validateTalkSessionAppendAudioParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind === "realtime-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				sendTalkRealtimeRelayAudio({
-					relaySessionId: session.relaySessionId,
-					connId,
-					audioBase64: params.audioBase64,
-					timestamp: params.timestamp
-				});
-				respond(true, { ok: true }, void 0);
-				return;
-			}
-			if (session.kind === "transcription-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				sendTalkTranscriptionRelayAudio({
-					transcriptionSessionId: session.transcriptionSessionId,
-					connId,
-					audioBase64: params.audioBase64
-				});
-				respond(true, { ok: true }, void 0);
-				return;
-			}
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.appendAudio is not supported for managed-room sessions"));
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.startTurn": async ({ params, respond, client, context }) => {
-		if (!validateTalkSessionTurnParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.startTurn params: ${formatValidationErrors(validateTalkSessionTurnParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind !== "managed-room") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.startTurn requires managed-room"));
-				return;
-			}
-			if (!isActiveManagedRoomClient(session, client?.connId)) {
-				respond(false, void 0, managedRoomOwnershipError("startTurn"));
-				return;
-			}
-			const result = startTalkHandoffTurn(session.handoffId, session.token, {
-				turnId: params.turnId,
-				clientId: client?.connId
-			});
-			if (!result.ok) {
-				respond(false, void 0, errorShape(talkHandoffErrorCode(result.reason), `talk turn start failed: ${result.reason}`));
-				return;
-			}
-			broadcastTalkRoomEvents(context, result.record.room.activeClientId, {
-				handoffId: result.record.id,
-				roomId: result.record.roomId,
-				events: result.events
-			});
-			respond(true, {
-				ok: true,
-				turnId: result.turnId,
-				events: result.events
-			}, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.endTurn": async ({ params, respond, client, context }) => {
-		if (!validateTalkSessionTurnParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.endTurn params: ${formatValidationErrors(validateTalkSessionTurnParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind !== "managed-room") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.endTurn requires managed-room"));
-				return;
-			}
-			if (!isActiveManagedRoomClient(session, client?.connId)) {
-				respond(false, void 0, managedRoomOwnershipError("endTurn"));
-				return;
-			}
-			const result = endTalkHandoffTurn(session.handoffId, session.token, { turnId: params.turnId });
-			if (!result.ok) {
-				respond(false, void 0, errorShape(talkHandoffErrorCode(result.reason), `talk turn end failed: ${result.reason}`));
-				return;
-			}
-			broadcastTalkRoomEvents(context, result.record.room.activeClientId, {
-				handoffId: result.record.id,
-				roomId: result.record.roomId,
-				events: result.events
-			});
-			respond(true, {
-				ok: true,
-				turnId: result.turnId,
-				events: result.events
-			}, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.cancelTurn": async ({ params, respond, client, context }) => {
-		if (!validateTalkSessionCancelTurnParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.cancelTurn params: ${formatValidationErrors(validateTalkSessionCancelTurnParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind === "realtime-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				cancelTalkRealtimeRelayTurn({
-					relaySessionId: session.relaySessionId,
-					connId,
-					reason: normalizeOptionalString(params.reason)
-				});
-				respond(true, { ok: true }, void 0);
-				return;
-			}
-			if (session.kind === "transcription-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				cancelTalkTranscriptionRelayTurn({
-					transcriptionSessionId: session.transcriptionSessionId,
-					connId,
-					reason: normalizeOptionalString(params.reason)
-				});
-				respond(true, { ok: true }, void 0);
-				return;
-			}
-			if (!isActiveManagedRoomClient(session, client?.connId)) {
-				respond(false, void 0, managedRoomOwnershipError("cancelTurn"));
-				return;
-			}
-			const result = cancelTalkHandoffTurn(session.handoffId, session.token, {
-				turnId: params.turnId,
-				reason: params.reason
-			});
-			if (!result.ok) {
-				respond(false, void 0, errorShape(talkHandoffErrorCode(result.reason), `talk turn cancel failed: ${result.reason}`));
-				return;
-			}
-			broadcastTalkRoomEvents(context, result.record.room.activeClientId, {
-				handoffId: result.record.id,
-				roomId: result.record.roomId,
-				events: result.events
-			});
-			respond(true, {
-				ok: true,
-				turnId: result.turnId,
-				events: result.events
-			}, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.cancelOutput": async ({ params, respond, client }) => {
-		if (!validateTalkSessionCancelOutputParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.cancelOutput params: ${formatValidationErrors(validateTalkSessionCancelOutputParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind !== "realtime-relay") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.cancelOutput requires realtime relay"));
-				return;
-			}
-			const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-			cancelTalkRealtimeRelayTurn({
-				relaySessionId: session.relaySessionId,
-				connId,
-				reason: normalizeOptionalString(params.reason) ?? "output-cancelled"
-			});
-			respond(true, { ok: true }, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.submitToolResult": async ({ params, respond, client }) => {
-		if (!validateTalkSessionSubmitToolResultParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.submitToolResult params: ${formatValidationErrors(validateTalkSessionSubmitToolResultParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind !== "realtime-relay") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.submitToolResult is only supported for realtime relay sessions"));
-				return;
-			}
-			const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-			submitTalkRealtimeRelayToolResult({
-				relaySessionId: session.relaySessionId,
-				connId,
-				callId: params.callId,
-				result: params.result,
-				options: params.options
-			});
-			respond(true, { ok: true }, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.steer": async ({ params, respond, client }) => {
-		if (!validateTalkSessionSteerParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.steer params: ${formatValidationErrors(validateTalkSessionSteerParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind === "realtime-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				respond(true, await steerTalkRealtimeRelayAgentRun({
-					relaySessionId: session.relaySessionId,
-					connId,
-					sessionKey: normalizeOptionalString(params.sessionKey),
-					text: params.text,
-					mode: normalizeOptionalString(params.mode)
-				}), void 0);
-				return;
-			}
-			if (session.kind === "transcription-relay") {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.steer requires an agent-backed Talk session"));
-				return;
-			}
-			if (!isActiveManagedRoomClient(session, client?.connId)) {
-				respond(false, void 0, managedRoomOwnershipError("steer"));
-				return;
-			}
-			const handoff = getTalkHandoff(session.handoffId);
-			const sessionKey = handoff?.sessionKey;
-			if (!sessionKey) {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.steer requires a session key"));
-				return;
-			}
-			const requestedSessionKey = normalizeOptionalString(params.sessionKey);
-			if (requestedSessionKey && requestedSessionKey !== sessionKey) {
-				respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.session.steer sessionKey does not match the managed-room session"));
-				return;
-			}
-			respond(true, await controlRealtimeVoiceAgentRun({
-				sessionKey,
-				text: params.text,
-				mode: params.mode,
-				recentEvents: handoff?.room.talk.recentEvents
-			}), void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.session.close": async ({ params, respond, client, context }) => {
-		if (!validateTalkSessionCloseParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.session.close params: ${formatValidationErrors(validateTalkSessionCloseParams.errors)}`));
-			return;
-		}
-		try {
-			const session = getUnifiedTalkSession(params.sessionId);
-			if (session.kind === "realtime-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				stopTalkRealtimeRelaySession({
-					relaySessionId: session.relaySessionId,
-					connId
-				});
-			} else if (session.kind === "transcription-relay") {
-				const connId = requireUnifiedTalkSessionConn(session, client?.connId);
-				stopTalkTranscriptionRelaySession({
-					transcriptionSessionId: session.transcriptionSessionId,
-					connId
-				});
-			} else {
-				if (!canCloseManagedRoomSession(session, client?.connId)) {
-					respond(false, void 0, managedRoomOwnershipError("close"));
-					return;
-				}
-				const result = revokeTalkHandoff(session.handoffId);
-				broadcastTalkRoomEvents(context, result.activeClientId, {
-					handoffId: session.handoffId,
-					roomId: session.roomId,
-					events: result.events
-				});
-			}
-			forgetUnifiedTalkSession(params.sessionId);
-			respond(true, { ok: true }, void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	}
-};
-//#endregion
-//#region src/gateway/server-methods/talk.ts
-function canReadTalkSecrets(client) {
-	const scopes = Array.isArray(client?.connect?.scopes) ? client.connect.scopes : [];
-	return scopes.includes("operator.admin") || scopes.includes("operator.talk.secrets");
-}
-function asStringRecord(value) {
-	const record = asOptionalRecord(value);
-	if (!record) return;
-	const next = {};
-	for (const [key, entryValue] of Object.entries(record)) if (typeof entryValue === "string") next[key] = entryValue;
-	return Object.keys(next).length > 0 ? next : void 0;
-}
-function normalizeAliasKey(value) {
-	return normalizeLowercaseStringOrEmpty(value);
-}
-function resolveTalkVoiceId(providerConfig, requested) {
-	if (!requested) return;
-	const aliases = asStringRecord(providerConfig.voiceAliases);
-	if (!aliases) return requested;
-	const normalizedRequested = normalizeAliasKey(requested);
-	for (const [alias, voiceId] of Object.entries(aliases)) if (normalizeAliasKey(alias) === normalizedRequested) return voiceId;
-	return requested;
-}
-function withTalkBaseTtsSpeakerSelectionCompat(baseTts) {
-	const next = withSpeakerSelectionCompat(baseTts);
-	const providers = asOptionalRecord(baseTts.providers);
-	if (providers) next.providers = Object.fromEntries(Object.entries(providers).map(([providerId, providerConfig]) => [providerId, withSpeakerSelectionCompat(asOptionalRecord(providerConfig) ?? {})]));
-	for (const [key, value] of Object.entries(baseTts)) {
-		if (key === "providers") continue;
-		const record = asOptionalRecord(value);
-		if (record) next[key] = withSpeakerSelectionCompat(record);
-	}
-	return next;
-}
-function buildTalkTtsConfig(config) {
-	const resolved = resolveActiveTalkProviderConfig(config.talk);
-	const provider = canonicalizeSpeechProviderId(resolved?.provider, config);
-	if (!resolved || !provider) return {
-		error: "talk.speak unavailable: talk provider not configured",
-		reason: "talk_unconfigured"
-	};
-	const speechProvider = getSpeechProvider(provider, config);
-	if (!speechProvider) return {
-		error: `talk.speak unavailable: speech provider "${provider}" does not support Talk mode`,
-		reason: "talk_provider_unsupported"
-	};
-	const baseTts = withTalkBaseTtsSpeakerSelectionCompat(asOptionalRecord(config.messages?.tts) ?? {});
-	const providerConfig = withSpeakerSelectionFallbackCompat(resolved.config);
-	const resolvedProviderConfig = speechProvider.resolveTalkConfig?.({
-		cfg: config,
-		baseTtsConfig: baseTts,
-		talkProviderConfig: providerConfig,
-		timeoutMs: baseTts.timeoutMs ?? 3e4
-	}) ?? providerConfig;
-	const talkTts = {
-		...baseTts,
-		auto: "always",
-		provider,
-		providers: {
-			...asOptionalRecord(baseTts.providers) ?? {},
-			[provider]: resolvedProviderConfig
-		}
-	};
-	return {
-		provider,
-		providerConfig,
-		cfg: {
-			...config,
-			messages: {
-				...config.messages,
-				tts: talkTts
-			}
-		}
-	};
-}
-function buildTalkCatalog(config) {
-	const ttsConfig = resolveTtsConfig(config);
-	const activeSpeechProvider = canonicalizeSpeechProviderId(resolveActiveTalkProviderConfig(config.talk)?.provider, config);
-	const streamingConfig = getVoiceCallStreamingConfig(config);
-	const realtimeConfig = buildTalkRealtimeConfig(config);
-	const activeRealtimeProvider = canonicalizeRealtimeVoiceProviderId(realtimeConfig.provider, config);
-	return {
-		modes: [
-			"realtime",
-			"stt-tts",
-			"transcription"
-		],
-		transports: [
-			"webrtc",
-			"provider-websocket",
-			"gateway-relay",
-			"managed-room"
-		],
-		brains: [
-			"agent-consult",
-			"direct-tools",
-			"none"
-		],
-		speech: {
-			...activeSpeechProvider ? { activeProvider: activeSpeechProvider } : {},
-			providers: listSpeechProviders(config).map((provider) => {
-				const entry = {
-					id: provider.id,
-					label: provider.label,
-					configured: configuredOrFalse(() => provider.isConfigured({
-						cfg: config,
-						providerConfig: getResolvedSpeechProviderConfig(ttsConfig, provider.id, config),
-						timeoutMs: ttsConfig.timeoutMs
-					})),
-					modes: ["stt-tts"],
-					brains: ["agent-consult"]
-				};
-				if (provider.models) entry.models = [...provider.models];
-				if (provider.voices) entry.voices = [...provider.voices];
-				return entry;
-			})
-		},
-		transcription: {
-			...streamingConfig.provider ? { activeProvider: streamingConfig.provider } : {},
-			providers: listRealtimeTranscriptionProviders(config).map((provider) => {
-				const rawConfig = streamingConfig.providers?.[provider.id] ?? {};
-				const providerConfig = provider.resolveConfig?.({
-					cfg: config,
-					rawConfig
-				}) ?? rawConfig;
-				const entry = {
-					id: provider.id,
-					label: provider.label,
-					configured: configuredOrFalse(() => provider.isConfigured({
-						cfg: config,
-						providerConfig
-					})),
-					modes: ["transcription"],
-					transports: ["gateway-relay"],
-					brains: ["none"]
-				};
-				if (provider.defaultModel) entry.defaultModel = provider.defaultModel;
-				return entry;
-			})
-		},
-		realtime: {
-			...activeRealtimeProvider ? { activeProvider: activeRealtimeProvider } : {},
-			providers: listRealtimeVoiceProviders(config).map((provider) => {
-				const rawConfig = realtimeConfig.providers?.[provider.id] ?? {};
-				const providerConfig = provider.resolveConfig?.({
-					cfg: config,
-					rawConfig
-				}) ?? rawConfig;
-				const capabilities = provider.capabilities;
-				const entry = {
-					id: provider.id,
-					label: provider.label,
-					configured: configuredOrFalse(() => provider.isConfigured({
-						cfg: config,
-						providerConfig
-					})),
-					modes: ["realtime"],
-					brains: capabilities?.supportsToolCalls === false ? ["none"] : ["agent-consult"],
-					supportsBrowserSession: Boolean(capabilities?.supportsBrowserSession ?? provider.createBrowserSession)
-				};
-				if (provider.defaultModel) entry.defaultModel = provider.defaultModel;
-				if (capabilities?.transports) entry.transports = [...capabilities.transports];
-				if (capabilities?.inputAudioFormats) entry.inputAudioFormats = capabilities.inputAudioFormats.map((format) => ({ ...format }));
-				if (capabilities?.outputAudioFormats) entry.outputAudioFormats = capabilities.outputAudioFormats.map((format) => ({ ...format }));
-				if (capabilities?.supportsBargeIn !== void 0) entry.supportsBargeIn = capabilities.supportsBargeIn;
-				if (capabilities?.supportsToolCalls !== void 0) entry.supportsToolCalls = capabilities.supportsToolCalls;
-				if (capabilities?.supportsVideoFrames !== void 0) entry.supportsVideoFrames = capabilities.supportsVideoFrames;
-				if (capabilities?.supportsSessionResumption !== void 0) entry.supportsSessionResumption = capabilities.supportsSessionResumption;
-				return entry;
-			})
-		}
-	};
-}
-function isFallbackEligibleTalkReason(reason) {
-	return reason === "talk_unconfigured" || reason === "talk_provider_unsupported" || reason === "method_unavailable";
-}
-function talkSpeakError(reason, message) {
-	const details = {
-		reason,
-		fallbackEligible: isFallbackEligibleTalkReason(reason)
-	};
-	return errorShape(ErrorCodes.UNAVAILABLE, message, { details });
-}
-function resolveTalkSpeed(params) {
-	if (typeof params.speed === "number") return params.speed;
-	if (typeof params.rateWpm !== "number" || params.rateWpm <= 0) return;
-	const resolved = params.rateWpm / 175;
-	if (resolved <= .5 || resolved >= 2) return;
-	return resolved;
-}
-function buildTalkSpeakOverrides(provider, providerConfig, config, params) {
-	const speechProvider = getSpeechProvider(provider, config);
-	if (!speechProvider?.resolveTalkOverrides) return { provider };
-	const resolvedSpeed = resolveTalkSpeed(params);
-	const resolvedVoiceId = resolveTalkVoiceId(providerConfig, normalizeOptionalString(params.voiceId));
-	const providerOverrides = speechProvider.resolveTalkOverrides({
-		talkProviderConfig: providerConfig,
-		params: {
-			...params,
-			...resolvedVoiceId == null ? {} : { voiceId: resolvedVoiceId },
-			...resolvedSpeed == null ? {} : { speed: resolvedSpeed }
-		}
-	});
-	if (!providerOverrides || Object.keys(providerOverrides).length === 0) return { provider };
-	return {
-		provider,
-		providerOverrides: { [provider]: providerOverrides }
-	};
-}
-function inferMimeType(outputFormat, fileExtension) {
-	const normalizedOutput = normalizeOptionalLowercaseString(outputFormat);
-	const normalizedExtension = normalizeOptionalLowercaseString(fileExtension);
-	if (normalizedOutput === "mp3" || normalizedOutput?.startsWith("mp3_") || normalizedOutput?.endsWith("-mp3") || normalizedExtension === ".mp3") return "audio/mpeg";
-	if (normalizedOutput === "opus" || normalizedOutput?.startsWith("opus_") || normalizedExtension === ".opus" || normalizedExtension === ".ogg") return "audio/ogg";
-	if (normalizedOutput?.endsWith("-wav") || normalizedExtension === ".wav") return "audio/wav";
-	if (normalizedOutput?.endsWith("-webm") || normalizedExtension === ".webm") return "audio/webm";
-}
-function resolveTalkResponseFromConfig(params) {
-	const normalizedTalk = normalizeTalkSection(params.sourceConfig.talk);
-	if (!normalizedTalk) return;
-	const payload = buildTalkConfigResponse(normalizedTalk);
-	if (!payload) return;
-	if (params.includeSecrets) return payload;
-	const sourceResolved = resolveActiveTalkProviderConfig(normalizedTalk);
-	const runtimeResolved = resolveActiveTalkProviderConfig(params.runtimeConfig.talk);
-	const provider = canonicalizeSpeechProviderId(sourceResolved?.provider ?? runtimeResolved?.provider, params.runtimeConfig);
-	if (!provider) return payload;
-	const speechProvider = getSpeechProvider(provider, params.runtimeConfig);
-	const sourceBaseTts = withTalkBaseTtsSpeakerSelectionCompat(asOptionalRecord(params.sourceConfig.messages?.tts) ?? {});
-	const runtimeBaseTts = withTalkBaseTtsSpeakerSelectionCompat(asOptionalRecord(params.runtimeConfig.messages?.tts) ?? {});
-	const sourceProviderConfig = withSpeakerSelectionFallbackCompat(sourceResolved?.config);
-	const runtimeProviderConfig = withSpeakerSelectionFallbackCompat(runtimeResolved?.config);
-	const selectedBaseTts = Object.keys(runtimeBaseTts).length > 0 ? runtimeBaseTts : stripUnresolvedSecretApiKeysFromBaseTtsProviders(sourceBaseTts);
-	const providerInputConfig = stripUnresolvedSecretApiKey(Object.keys(runtimeProviderConfig).length > 0 ? runtimeProviderConfig : sourceProviderConfig);
-	const resolvedConfig = speechProvider?.resolveTalkConfig?.({
-		cfg: params.runtimeConfig,
-		baseTtsConfig: selectedBaseTts,
-		talkProviderConfig: providerInputConfig,
-		timeoutMs: typeof selectedBaseTts.timeoutMs === "number" ? selectedBaseTts.timeoutMs : 3e4
-	}) ?? providerInputConfig;
-	const responseConfig = sourceProviderConfig.apiKey === void 0 ? resolvedConfig : {
-		...resolvedConfig,
-		apiKey: sourceProviderConfig.apiKey
-	};
-	return {
-		...payload,
-		provider,
-		resolved: {
-			provider,
-			config: responseConfig
-		}
-	};
-}
-function stripUnresolvedSecretApiKey(config) {
-	return stripUnresolvedSecretApiKeyFromRecord(config);
-}
-function stripUnresolvedSecretApiKeysFromBaseTtsProviders(base) {
-	const providers = asOptionalRecord(base.providers);
-	if (!providers) return base;
-	let mutated = false;
-	const cleaned = Object.create(null);
-	for (const [providerId, providerConfig] of Object.entries(providers)) {
-		const cfg = asOptionalRecord(providerConfig);
-		if (!cfg) {
-			cleaned[providerId] = providerConfig;
-			continue;
-		}
-		const next = stripUnresolvedSecretApiKeyFromRecord(cfg);
-		if (next !== cfg) mutated = true;
-		cleaned[providerId] = next;
-	}
-	if (!mutated) return base;
-	return {
-		...base,
-		providers: cleaned
-	};
-}
-function stripUnresolvedSecretApiKeyFromRecord(config) {
-	if (config.apiKey === void 0 || typeof config.apiKey === "string") return config;
-	const { apiKey: _omit, ...rest } = config;
-	return rest;
-}
-const talkHandlers = {
-	...talkSessionHandlers,
-	...talkClientHandlers,
-	"talk.catalog": async ({ params, respond, context }) => {
-		if (!validateTalkCatalogParams(params ?? {})) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.catalog params: ${formatValidationErrors(validateTalkCatalogParams.errors)}`));
-			return;
-		}
-		try {
-			respond(true, buildTalkCatalog(context.getRuntimeConfig()), void 0);
-		} catch (err) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, formatForLog(err)));
-		}
-	},
-	"talk.config": async ({ params, respond, client, context }) => {
-		if (!validateTalkConfigParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.config params: ${formatValidationErrors(validateTalkConfigParams.errors)}`));
-			return;
-		}
-		const includeSecrets = Boolean(params.includeSecrets);
-		if (includeSecrets && !canReadTalkSecrets(client)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `missing scope: ${TALK_SECRETS_SCOPE}`));
-			return;
-		}
-		const snapshot = await readConfigFileSnapshot();
-		const runtimeConfig = context.getRuntimeConfig();
-		const configPayload = {};
-		const talk = resolveTalkResponseFromConfig({
-			includeSecrets,
-			sourceConfig: snapshot.config,
-			runtimeConfig
-		});
-		if (talk) configPayload.talk = includeSecrets ? talk : redactConfigObject(talk);
-		const sessionMainKey = snapshot.config.session?.mainKey;
-		if (typeof sessionMainKey === "string") configPayload.session = { mainKey: sessionMainKey };
-		const seamColor = snapshot.config.ui?.seamColor;
-		if (typeof seamColor === "string") configPayload.ui = { seamColor };
-		respond(true, { config: configPayload }, void 0);
-	},
-	"talk.speak": async ({ params, respond, context }) => {
-		if (!validateTalkSpeakParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.speak params: ${formatValidationErrors(validateTalkSpeakParams.errors)}`));
-			return;
-		}
-		const typedParams = params;
-		const text = normalizeOptionalString(typedParams.text);
-		if (!text) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, "talk.speak requires text"));
-			return;
-		}
-		if (typedParams.speed == null && typedParams.rateWpm != null && resolveTalkSpeed(typedParams) == null) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.speak params: rateWpm must resolve to speed between 0.5 and 2.0`));
-			return;
-		}
-		try {
-			const runtimeConfig = context.getRuntimeConfig();
-			const setup = buildTalkTtsConfig(runtimeConfig);
-			if ("error" in setup) {
-				respond(false, void 0, talkSpeakError(setup.reason, setup.error));
-				return;
-			}
-			const overrides = buildTalkSpeakOverrides(setup.provider, setup.providerConfig, runtimeConfig, typedParams);
-			const result = await synthesizeSpeech({
-				text,
-				cfg: setup.cfg,
-				overrides,
-				disableFallback: true
-			});
-			if (!result.success || !result.audioBuffer) {
-				respond(false, void 0, talkSpeakError("synthesis_failed", result.error ?? "talk synthesis failed"));
-				return;
-			}
-			if ((result.provider ?? setup.provider).trim().length === 0) {
-				respond(false, void 0, talkSpeakError("invalid_audio_result", "talk synthesis returned empty provider"));
-				return;
-			}
-			if (result.audioBuffer.length === 0) {
-				respond(false, void 0, talkSpeakError("invalid_audio_result", "talk synthesis returned empty audio"));
-				return;
-			}
-			respond(true, {
-				audioBase64: result.audioBuffer.toString("base64"),
-				provider: result.provider ?? setup.provider,
-				outputFormat: result.outputFormat,
-				voiceCompatible: result.voiceCompatible,
-				mimeType: inferMimeType(result.outputFormat, result.fileExtension),
-				fileExtension: result.fileExtension
-			}, void 0);
-		} catch (err) {
-			respond(false, void 0, talkSpeakError("synthesis_failed", formatForLog(err)));
-		}
-	},
-	"talk.mode": ({ params, respond, context, client, isWebchatConnect }) => {
-		if (client && isWebchatConnect(client.connect) && !context.hasConnectedTalkNode()) {
-			respond(false, void 0, errorShape(ErrorCodes.UNAVAILABLE, "talk disabled: no connected Talk-capable nodes"));
-			return;
-		}
-		if (!validateTalkModeParams(params)) {
-			respond(false, void 0, errorShape(ErrorCodes.INVALID_REQUEST, `invalid talk.mode params: ${formatValidationErrors(validateTalkModeParams.errors)}`));
-			return;
-		}
-		const payload = {
-			enabled: params.enabled,
-			phase: params.phase ?? null,
-			ts: Date.now()
-		};
-		context.broadcast("talk.mode", payload, { dropIfSlow: true });
-		respond(true, payload, void 0);
-	}
-};
-//#endregion
-export { talkHandlers };