@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/voice/platform-streams.js

@@ -0,0 +1,250 @@
+import WebSocket from "ws";
+//#region src/voice/platform-streams.ts
+const MAX_BUFFERED_BYTES = 512 * 1024;
+function connect(url, token, signal, onEvent, onFailure) {
+	signal.throwIfAborted();
+	const socket = new WebSocket(url, {
+		headers: { Authorization: `Bearer ${token}` },
+		perMessageDeflate: false,
+		maxPayload: 1024 * 1024
+	});
+	let ended = false;
+	const close = () => {
+		if (ended) return;
+		ended = true;
+		signal.removeEventListener("abort", abort);
+		if (socket.readyState === WebSocket.OPEN) socket.close();
+		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+	};
+	const fail = (error) => {
+		if (!ended) {
+			onFailure(error);
+			close();
+		}
+	};
+	const abort = () => fail(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Voice request aborted"));
+	signal.addEventListener("abort", abort, { once: true });
+	socket.on("message", (raw, binary) => {
+		if (ended) return;
+		try {
+			if (binary) throw new Error("Unexpected platform binary event");
+			const event = JSON.parse(raw.toString());
+			if (!event || typeof event.type !== "string") throw new Error("Invalid platform voice event");
+			if (event.type === "error") throw new Error(event.error?.message ?? "Platform voice failed");
+			onEvent(event);
+		} catch (error) {
+			fail(error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid platform voice event"));
+		}
+	});
+	socket.on("unexpected-response", (_request, response) => {
+		response.resume();
+		fail(/* @__PURE__ */ new Error(`Platform voice rejected connection (${response.statusCode})`));
+	});
+	socket.on("error", fail);
+	socket.on("close", () => fail(/* @__PURE__ */ new Error("Platform voice disconnected before completion")));
+	return {
+		socket,
+		close,
+		fail,
+		send: (value) => {
+			if (ended || socket.readyState !== WebSocket.OPEN) throw new Error("Platform voice is not connected");
+			if (socket.bufferedAmount > MAX_BUFFERED_BYTES) throw new Error("Platform voice backpressure limit exceeded");
+			socket.send(value instanceof Uint8Array ? value : JSON.stringify(value));
+		}
+	};
+}
+async function openPlatformStt(request) {
+	if (!request.apiKey || !request.baseUrl) throw new Error("Platform authorization is unavailable");
+	if (request.inputFormat.sampleRate !== 16e3 || request.inputFormat.encoding !== "pcm_s16le" || request.inputFormat.channels !== 1) throw new Error("Platform STT requires 16 kHz mono PCM16");
+	let ready = false, finished = false, finishing = false;
+	let failure;
+	let inputBytes = 0;
+	const sentences = /* @__PURE__ */ new Map();
+	let resolveReady, rejectReady, resolveFinished;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const finishedPromise = new Promise((resolve) => {
+		resolveFinished = resolve;
+	});
+	const connection = connect(request.baseUrl, request.apiKey, request.signal, (event) => {
+		if (event.type === "session.updated") {
+			if (event.session?.input_sample_rate !== 16e3) throw new Error("Unsupported STT audio format");
+			ready = true;
+			resolveReady();
+			request.onEvent({ type: "ready" });
+		} else if (event.type === "transcript.partial" || event.type === "transcript.final") {
+			if (!ready || typeof event.item_id !== "string" || typeof event.text !== "string") throw new Error("Invalid platform transcript");
+			let sentence = sentences.get(event.item_id);
+			if (sentence?.final) return;
+			if (!sentence) {
+				if (sentences.size >= 1e4) throw new Error("Transcript limit exceeded");
+				sentence = {
+					revision: 0,
+					final: false
+				};
+				sentences.set(event.item_id, sentence);
+				request.onEvent({
+					type: "speech_started",
+					utteranceId: event.item_id
+				});
+			}
+			sentence.revision++;
+			if (event.type === "transcript.final") {
+				sentence.final = true;
+				request.onEvent({
+					type: "speech_stopped",
+					utteranceId: event.item_id
+				});
+				request.onEvent({
+					type: "transcript_final",
+					utteranceId: event.item_id,
+					revision: sentence.revision,
+					text: event.text
+				});
+			} else request.onEvent({
+				type: "transcript_delta",
+				utteranceId: event.item_id,
+				revision: sentence.revision,
+				text: event.text
+			});
+		} else if (event.type === "session.finished") {
+			finished = true;
+			request.onEvent({
+				type: "usage",
+				inputAudioMs: Math.round(inputBytes / 32)
+			});
+			resolveFinished();
+			connection.close();
+		}
+	}, (error) => {
+		failure = error;
+		rejectReady(error);
+		resolveFinished();
+		request.onEvent({
+			type: "error",
+			error
+		});
+	});
+	connection.socket.once("open", () => connection.send({
+		type: "session.update",
+		session: { ...request.language ? { language: request.language } : {} }
+	}));
+	const timer = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform STT setup timed out")), request.timeoutMs);
+	try {
+		await readyPromise;
+	} finally {
+		clearTimeout(timer);
+	}
+	const commit = async () => {
+		if (failure) throw failure;
+		if (!finished && !finishing) {
+			finishing = true;
+			connection.send({ type: "session.finish" });
+		}
+		const timeout = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform STT finalization timed out")), request.timeoutMs);
+		try {
+			await finishedPromise;
+			if (failure) throw failure;
+		} finally {
+			clearTimeout(timeout);
+			connection.close();
+		}
+	};
+	return {
+		appendAudio(bytes) {
+			if (!ready || finished || finishing || failure) throw new Error("Platform STT is not writable");
+			if (!bytes.length || bytes.length % 2 || bytes.length > 65536) throw new Error("Invalid PCM frame");
+			inputBytes += bytes.length;
+			connection.send(bytes);
+		},
+		commit,
+		close: commit,
+		abort() {
+			finished = true;
+			resolveFinished();
+			connection.close();
+		}
+	};
+}
+async function openPlatformTts(request) {
+	let controller;
+	let resolveReady, rejectReady;
+	let ready = false, ended = false, finishSent = false;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const stream = new ReadableStream({
+		start(value) {
+			controller = value;
+		},
+		cancel() {
+			ended = true;
+			clearTimeout(timer);
+			connection.close();
+		}
+	}, {
+		highWaterMark: MAX_BUFFERED_BYTES,
+		size: (chunk) => chunk.byteLength
+	});
+	const connection = connect(request.baseUrl, request.apiKey, request.signal, (event) => {
+		if (event.type === "session.updated" && !ready) {
+			if (event.session?.output_sample_rate !== 24e3) throw new Error("Unsupported TTS audio format");
+			ready = true;
+			resolveReady();
+			const characters = [...request.text];
+			for (let i = 0; i < characters.length; i += 1e3) connection.send({
+				type: "input_text_buffer.append",
+				text: characters.slice(i, i + 1e3).join("")
+			});
+			connection.send({ type: "input_text_buffer.commit" });
+		} else if ((event.type === "response.done" || event.type === "text.flushed") && !finishSent) {
+			finishSent = true;
+			connection.send({ type: "session.finish" });
+		} else if (event.type === "response.audio.delta") {
+			if (!ready || typeof event.delta !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(event.delta)) throw new Error("Invalid platform audio");
+			const bytes = Buffer.from(event.delta, "base64");
+			if (bytes.length % 2 || (controller.desiredSize ?? 0) < bytes.length) throw new Error("Platform TTS audio buffer exceeded");
+			controller.enqueue(bytes);
+		} else if (event.type === "session.finished") {
+			ended = true;
+			clearTimeout(timer);
+			controller.close();
+			connection.close();
+		}
+	}, (error) => {
+		rejectReady(error);
+		if (!ended) {
+			ended = true;
+			controller.error(error);
+		}
+		clearTimeout(timer);
+	});
+	const timer = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform TTS timed out")), request.timeoutMs);
+	connection.socket.once("open", () => connection.send({
+		type: "session.update",
+		session: {
+			voice: request.voice,
+			...request.instructions ? { instructions: request.instructions } : {}
+		}
+	}));
+	await readyPromise;
+	return {
+		audioStream: stream,
+		outputFormat: "pcm",
+		fileExtension: "pcm",
+		voiceCompatible: false,
+		release: async () => {
+			clearTimeout(timer);
+			connection.close();
+			if (!ended) {
+				ended = true;
+				controller.close();
+			}
+		}
+	};
+}
+//#endregion
+export { openPlatformStt, openPlatformTts };

package/dist/src/voice/realtime/agentBroker.d.ts

@@ -12,8 +12,8 @@ export interface VoiceAgentTask {
 }
 export interface VoiceAgentBroker {
     delegate(input: {
-        sessionKey: string;
-        expectedSessionId: string;
+        conversationId: string;
+        expectedTranscriptId: string;
         turnId: string;
         text: string;
         signal: AbortSignal;
@@ -30,8 +30,8 @@ type SubmitResult = {
 };
 type BrokerDependencies = {
     submit(input: SubmitSessionInput): Promise<SubmitResult>;
-    find(sessionKey: string, clientMessageId: string): SessionInput | undefined;
-    snapshot(sessionKey: string): SessionInputState;
+    find(conversationId: string, clientMessageId: string): SessionInput | undefined;
+    snapshot(conversationId: string): SessionInputState;
     currentSequence(topic: string): number;
     subscribe(topic: string, afterSeq: number, listener: (event: RealtimeEvent) => void): RealtimeSubscriptionHandle;
     cancelRun(runId: string): Promise<void>;
@@ -42,8 +42,8 @@ export declare class DurableVoiceAgentBroker implements VoiceAgentBroker {
     private readonly runByTask;
     constructor(deps: BrokerDependencies);
     delegate(input: {
-        sessionKey: string;
-        expectedSessionId: string;
+        conversationId: string;
+        expectedTranscriptId: string;
         turnId: string;
         text: string;
         signal: AbortSignal;

package/dist/src/voice/realtime/agentBroker.js

@@ -29,12 +29,12 @@ var DurableVoiceAgentBroker = class {
 		this.deps = deps;
 	}
 	async delegate(input) {
-		const clientMessageId = `voice:${input.expectedSessionId}:${input.turnId}`;
-		const activeRunId = this.deps.snapshot(input.sessionKey).activeRunId;
+		const clientMessageId = `voice:${input.expectedTranscriptId}:${input.turnId}`;
+		const activeRunId = this.deps.snapshot(input.conversationId).activeRunId;
 		const activeRunCursor = activeRunId ? this.deps.currentSequence(`run:${activeRunId}`) : 0;
 		const result = await this.deps.submit({
-			sessionKey: input.sessionKey,
-			expectedSessionId: input.expectedSessionId,
+			conversationId: input.conversationId,
+			expectedTranscriptId: input.expectedTranscriptId,
 			clientMessageId,
 			delivery: activeRunId ? "steer" : "next",
 			content: input.text,
@@ -45,7 +45,7 @@ var DurableVoiceAgentBroker = class {
 		});
 		if (result.ok === false) throw new Error(`Voice task submission failed: ${result.code}`);
 		const deadline = Date.now() + RUN_ASSIGNMENT_TIMEOUT_MS;
-		let row = this.deps.find(input.sessionKey, clientMessageId);
+		let row = this.deps.find(input.conversationId, clientMessageId);
 		while (!row?.runId && !row?.targetRunId) {
 			if (row && [
 				"completed",
@@ -55,7 +55,7 @@ var DurableVoiceAgentBroker = class {
 			].includes(row.status)) throw new Error(row.error ?? `Voice task ended before assignment: ${row.status}`);
 			if (Date.now() >= deadline) throw new Error("Voice task run assignment timed out");
 			await sleep(RUN_ASSIGNMENT_POLL_MS, input.signal);
-			row = this.deps.find(input.sessionKey, clientMessageId);
+			row = this.deps.find(input.conversationId, clientMessageId);
 		}
 		const runId = row.runId ?? row.targetRunId;
 		this.runByTask.set(row.id, runId);

package/dist/src/voice/realtime/agentEngine.js

@@ -86,9 +86,9 @@ function createAgentVoiceEngine(options) {
 			responseId: response.id,
 			reason
 		});
-		const sessionKey = claim.request.sessionKey;
-		if (sessionKey && reason !== "session_closed") interruptionWrites = interruptionWrites.then(() => options.runtime.recordInterruption({
-			sessionKey,
+		const conversationId = claim.request.conversationId;
+		if (conversationId && reason !== "session_closed") interruptionWrites = interruptionWrites.then(() => options.runtime.recordInterruption({
+			conversationId,
 			responseId: response.id,
 			reason,
 			generatedCharacters: response.text.length,
@@ -222,7 +222,7 @@ function createAgentVoiceEngine(options) {
 		else startSpeechWorker(response);
 	}
 	async function runAssistantTurn(text, turnId) {
-		if (!claim.tts || !claim.request.sessionKey || !text.trim() || closed) return;
+		if (!claim.tts || !claim.request.conversationId || !text.trim() || closed) return;
 		cancelActiveResponse("barge_in");
 		const response = {
 			id: `resp_${crypto.randomUUID()}`,
@@ -248,8 +248,8 @@ function createAgentVoiceEngine(options) {
 			const task = await options.runtime.agentBroker.delegate({
 				text,
 				turnId,
-				sessionKey: claim.request.sessionKey,
-				expectedSessionId: claim.conversationSessionId,
+				conversationId: claim.request.conversationId,
+				expectedTranscriptId: claim.conversationSessionId,
 				signal: response.abortController.signal
 			});
 			response.taskId = task.taskId;

package/dist/src/voice/realtime/memory-context.d.ts

@@ -10,11 +10,11 @@ export interface VoiceMemorySnapshot {
     isCurrent: () => boolean;
     subscribe: (invalidate: () => void) => () => void;
 }
-export declare function voiceMemoryEnabled(config: Config, sessionKey: string): boolean;
+export declare function voiceMemoryEnabled(config: Config, conversationId: string): boolean;
 export declare function voiceMemoryQuery(history: AgentMessage[]): string;
 export declare function buildVoiceMemoryContext(input: {
     getConfig: () => Config;
-    sessionKey: string;
+    conversationId: string;
     workspaceId: string;
     projectId?: string;
     history: AgentMessage[];

package/dist/src/voice/realtime/memory-context.js

@@ -1,9 +1,10 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { parseAgentSessionKey } from "../../routing/session-key-utils.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
+import { getSessionMetadata, init_session_repository } from "../../storage/sqlite/session-repository.js";
 import { getSessionConfig } from "../../storage/sqlite/config-repository.js";
-import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
+import { getConversationRouting } from "../../storage/sqlite/conversation-repository.js";
+import { getConversation } from "../../routing/agent-session-key.js";
+import { init_session_key } from "../../routing/session-key.js";
 import { getKnowledgeItem } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 import { getUserAssertion } from "../../user-model/repository.js";
@@ -12,16 +13,15 @@ import { stripRuntimeContextFromUserMessage } from "../../session/user-message-d
 import { buildExecutionContext } from "../../agent/context/execution-context.js";
 //#region src/voice/realtime/memory-context.ts
 init_session_key();
+init_session_repository();
 init_logger();
 const log = createLogger("Voice:Memory");
-function voiceMemoryEnabled(config, sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
-	const rest = parseAgentSessionKey(sessionKey)?.rest;
-	const parts = rest?.split(":") ?? [];
-	const explicitlyPrivate = rest === "main" || parts.every(Boolean) && !["cron", "subagent"].includes(parts[0] ?? "") && (parts[0] === "direct" && parts.length >= 2 || parts[1] === "direct" && parts.length >= 3 || parts[2] === "direct" && parts.length >= 4);
+function voiceMemoryEnabled(config, conversationId) {
+	const parsed = getConversationRouting(conversationId);
+	const explicitlyPrivate = getConversation(conversationId)?.sessionType === "chat" && parsed?.peerKind === "direct";
 	const user = config.userContext;
 	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.userModel.enabled || !user.contextPlanning.enabled) return false;
-	const mode = getSessionConfig(sessionKey)?.userContextMode;
+	const mode = getSessionConfig(conversationId)?.userContextMode;
 	return mode === void 0 || mode === "enabled";
 }
 function voiceMemoryQuery(history) {
@@ -33,14 +33,14 @@ function buildVoiceMemoryContext(input) {
 	const started = performance.now();
 	try {
 		const config = input.getConfig();
-		if (!voiceMemoryEnabled(config, input.sessionKey) || input.maxChars < 128) return;
-		const session = getSessionMetadata(input.sessionKey);
+		if (!voiceMemoryEnabled(config, input.conversationId) || input.maxChars < 128) return;
+		const session = getSessionMetadata(input.conversationId);
 		const context = buildExecutionContext({
 			query: voiceMemoryQuery(input.history),
 			agentId: session?.routing?.agentId ?? "main",
 			workspaceId: input.workspaceId,
 			projectId: input.projectId,
-			sessionId: input.sessionKey,
+			conversationId: input.conversationId,
 			maxAssertions: 6,
 			maxKnowledge: 3
 		});
@@ -61,11 +61,11 @@ function buildVoiceMemoryContext(input) {
 		}))];
 		const configVersion = JSON.stringify(config.userContext);
 		const isCurrent = () => {
-			if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || JSON.stringify(input.getConfig().userContext) !== configVersion) return false;
+			if (!voiceMemoryEnabled(input.getConfig(), input.conversationId) || JSON.stringify(input.getConfig().userContext) !== configVersion) return false;
 			return references.every((reference) => reference.kind === "assertion" ? getUserAssertion(reference.id)?.recordedAt === reference.updatedAt : getKnowledgeItem(reference.id)?.updatedAt === reference.updatedAt);
 		};
 		log.debug({
-			sessionKey: input.sessionKey,
+			conversationId: input.conversationId,
 			selectedCount: references.length,
 			contextChars: block.length,
 			durationMs: performance.now() - started
@@ -78,7 +78,7 @@ function buildVoiceMemoryContext(input) {
 		};
 	} catch {
 		log.warn({
-			sessionKey: input.sessionKey,
+			conversationId: input.conversationId,
 			durationMs: performance.now() - started
 		}, "Native voice memory unavailable; continuing with chat history");
 		return;

package/dist/src/voice/realtime/omniEngine.js

@@ -143,7 +143,7 @@ function createOmniVoiceEngine(options) {
 				reason
 			});
 		}
-		if ((reason === "client_cancelled" || reason === "barge_in" && !options.bargeIn) && response.generating && socket?.readyState === WebSocket.OPEN) {
+		if ((reason === "client_cancelled" || reason === "barge_in" && (options.route.route.managed || !options.bargeIn)) && response.generating && socket?.readyState === WebSocket.OPEN) {
 			cancellationPending = true;
 			send("response.cancel");
 		}
@@ -286,7 +286,7 @@ function createOmniVoiceEngine(options) {
 						if (binary) throw new Error("Unexpected Omni binary frame");
 						const event = JSON.parse(raw.toString());
 						if (event.type === "error") {
-							if (cancellationPending && event.error?.type === "invalid_request_error" && event.error?.message === "Conversation has none active response") {
+							if (!options.route.route.managed && cancellationPending && event.error?.type === "invalid_request_error" && event.error?.message === "Conversation has none active response") {
 								cancellationPending = false;
 								return;
 							}
@@ -297,9 +297,11 @@ function createOmniVoiceEngine(options) {
 							modalities: ["text", "audio"],
 							voice: options.route.voice,
 							instructions: options.route.instructions,
-							input_audio_format: "pcm",
-							output_audio_format: "pcm",
-							input_audio_transcription: { model: "gummy-realtime-v1" },
+							...!options.route.route.managed ? {
+								input_audio_format: "pcm",
+								output_audio_format: "pcm",
+								input_audio_transcription: { model: "gummy-realtime-v1" }
+							} : {},
 							turn_detection: {
 								type: "server_vad",
 								threshold: .5,
@@ -309,6 +311,7 @@ function createOmniVoiceEngine(options) {
 							}
 						} });
 						else if (event.type === "session.updated" && !ready) {
+							if (options.route.route.managed && (event.session?.input_sample_rate !== 16e3 || event.session?.output_sample_rate !== 24e3)) throw new Error("Unsupported platform audio format");
 							ready = true;
 							clearTimeout(timer);
 							rejectStart = void 0;

package/dist/src/voice/realtime/omniRoute.d.ts

@@ -6,5 +6,6 @@ export interface OmniRoute {
     apiKey: string;
     voice: string;
     instructions: string;
+    maxSessionSeconds?: number;
 }
 export declare function resolveOmniRoute(config: Config): Promise<OmniRoute>;

package/dist/src/voice/realtime/omniRoute.js

@@ -1,12 +1,20 @@
 import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../../providers/xopc-cloud-config.js";
 import { getProviderAuthService, init_provider_auth_service } from "../../providers/provider-auth-service.js";
+import { requirePlatformVoiceModel } from "../platform-catalog.js";
 //#region src/voice/realtime/omniRoute.ts
 init_provider_auth_service();
 init_xopc_cloud_config();
 async function resolveOmniRoute(config) {
 	const slice = config.voice?.realtime?.omni;
 	if (!slice) throw new Error("Natural conversation is not configured");
-	if (slice.model !== "qwen3-omni-flash-realtime") throw new Error("This Omni model has not been certified");
+	let maxSessionSeconds;
+	let serviceVersion;
+	if (slice.provider === "xopc-cloud") {
+		const model = requirePlatformVoiceModel(slice.model, "conversation");
+		maxSessionSeconds = model.voice.limits.maxSessionSeconds;
+		serviceVersion = model.voice.serviceVersion;
+		if (!model.voice.voices.some((voice) => voice.id === slice.voice)) throw new Error("Selected voice is unavailable");
+	}
 	const managed = slice.provider === "xopc-cloud";
 	const url = new URL(managed ? `${resolveXopcModelRouterUrl(slice.baseUrl)}/audio/conversations/realtime` : slice.baseUrl ?? "wss://dashscope.aliyuncs.com/api-ws/v1/realtime");
 	if (managed && url.protocol === "https:") url.protocol = "wss:";
@@ -15,7 +23,9 @@ async function resolveOmniRoute(config) {
 	const apiKey = managed ? await getProviderAuthService().resolveApiKey("xopc-cloud") : slice.apiKey ?? config.tools?.media?.audio?.providers?.alibaba?.apiKey ?? await getProviderAuthService().resolveApiKey("dashscope");
 	if (!apiKey) throw new Error("Omni credentials are unavailable");
 	url.search = new URLSearchParams({ model: slice.model }).toString();
+	if (serviceVersion) url.searchParams.set("service_version", String(serviceVersion));
 	return {
+		maxSessionSeconds,
 		route: {
 			provider: slice.provider,
 			model: slice.model,

package/dist/src/voice/realtime/persona-context.d.ts

@@ -14,6 +14,6 @@ export declare function buildVoicePersonaBlock(input: {
 }): string;
 export declare function buildVoicePersonaContext(input: {
     getConfig: () => Config;
-    sessionKey: string;
+    conversationId: string;
     maxChars?: number;
 }): VoicePersonaSnapshot;

package/dist/src/voice/realtime/persona-context.js

@@ -84,8 +84,8 @@ function fileSignature(profileDir) {
 		}
 	}).join("|");
 }
-function profileVersion(config, sessionKey) {
-	const profile = resolveEffectiveAgentProfileForSession(config, sessionKey);
+function profileVersion(config, conversationId) {
+	const profile = resolveEffectiveAgentProfileForSession(config, conversationId);
 	return JSON.stringify({
 		agentId: profile.agentId,
 		name: profile.config.profile?.name,
@@ -95,12 +95,12 @@ function profileVersion(config, sessionKey) {
 }
 function buildVoicePersonaContext(input) {
 	const config = input.getConfig();
-	const profile = resolveEffectiveAgentProfileForSession(config, input.sessionKey);
+	const profile = resolveEffectiveAgentProfileForSession(config, input.conversationId);
 	const profileDir = resolveAgentProfileDir(config, profile.agentId);
 	const files = loadProfileBootstrapFiles(profileDir);
 	const identity = files.find((file) => file.name === "IDENTITY.md" && !file.missing)?.content;
 	const soul = files.find((file) => file.name === "SOUL.md" && !file.missing)?.content;
-	const version = profileVersion(config, input.sessionKey);
+	const version = profileVersion(config, input.conversationId);
 	const signature = fileSignature(profileDir);
 	return {
 		block: buildVoicePersonaBlock({
@@ -114,8 +114,8 @@ function buildVoicePersonaContext(input) {
 		isCurrent: () => {
 			try {
 				const currentConfig = input.getConfig();
-				const currentDir = resolveAgentProfileDir(currentConfig, resolveEffectiveAgentProfileForSession(currentConfig, input.sessionKey).agentId);
-				return profileVersion(currentConfig, input.sessionKey) === version && currentDir === profileDir && fileSignature(currentDir) === signature;
+				const currentDir = resolveAgentProfileDir(currentConfig, resolveEffectiveAgentProfileForSession(currentConfig, input.conversationId).agentId);
+				return profileVersion(currentConfig, input.conversationId) === version && currentDir === profileDir && fileSignature(currentDir) === signature;
 			} catch {
 				return false;
 			}

package/dist/src/voice/realtime/runtime.d.ts

@@ -26,7 +26,7 @@ export declare class VoiceRealtimeRuntime {
     preflight(request: CreateVoiceSessionRequest): Promise<void>;
     createSession(request: CreateVoiceSessionRequest, principalId: string, now?: number): Promise<CreateVoiceSessionResponse>;
     handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
-    hasConversation(sessionKey: string): boolean;
+    hasConversation(conversationId: string): boolean;
     cancelSession(sessionId: string, ticket: string, principalId: string): Promise<boolean>;
     disconnectPrincipal(principalId: string): void;
     close(): void;