@xopcai/xopc 0.0.367 → 0.0.369

package/dist/src/storage/sqlite/clarification-wait-repository.js

@@ -185,6 +185,7 @@ function createClarificationWait(input) {
         id, principal_id, conversation_id, transcript_id, status, version, data_json,
         origin_run_id, origin_tool_call_id
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(wait.id, wait.principalId, wait.conversationId, wait.transcriptId, wait.status, wait.version, JSON.stringify(wait), wait.originRunId, wait.originToolCallId);
+		db.prepare("INSERT INTO clarification_notification_outbox(wait_id, created_at) VALUES (?, ?)").run(wait.id, wait.createdAt);
 		markTaskWaiting(wait);
 		bumpSessionInputRevision(db, input.conversationId);
 		return wait;

package/dist/src/storage/sqlite/migrations/238_browser_record_replay.sql

@@ -0,0 +1,45 @@
+CREATE TABLE browser_automation_versions (
+  automation_id TEXT NOT NULL REFERENCES browser_automations(automation_id) ON DELETE CASCADE,
+  revision INTEGER NOT NULL,
+  definition_json TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (automation_id, revision)
+);
+INSERT INTO browser_automation_versions SELECT automation_id, revision, definition_json, updated_at_ms FROM browser_automations;
+
+CREATE TABLE browser_automation_verifications (
+  automation_id TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  run_id TEXT NOT NULL REFERENCES browser_automation_runs(run_id) ON DELETE CASCADE,
+  verified_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (automation_id, revision),
+  FOREIGN KEY (automation_id, revision) REFERENCES browser_automation_versions(automation_id, revision) ON DELETE CASCADE
+);
+ALTER TABLE browser_automation_runs ADD COLUMN client_request_id TEXT;
+ALTER TABLE browser_automation_runs ADD COLUMN business_outcome TEXT;
+CREATE UNIQUE INDEX idx_browser_run_request ON browser_automation_runs(client_request_id) WHERE client_request_id IS NOT NULL;
+
+CREATE TABLE browser_recordings (
+  recording_id TEXT PRIMARY KEY,
+  principal_id TEXT NOT NULL,
+  state TEXT NOT NULL,
+  ack_seq INTEGER NOT NULL DEFAULT 0,
+  final_seq INTEGER,
+  automation_id TEXT REFERENCES browser_automations(automation_id) ON DELETE CASCADE,
+  error TEXT,
+  created_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);
+CREATE TABLE browser_recording_events (
+  recording_id TEXT NOT NULL REFERENCES browser_recordings(recording_id) ON DELETE CASCADE,
+  seq INTEGER NOT NULL,
+  event_id TEXT NOT NULL UNIQUE,
+  payload_json TEXT NOT NULL,
+  PRIMARY KEY (recording_id, seq)
+);
+
+UPDATE automations SET action_json=json_set(action_json, '$.revision', COALESCE((SELECT revision FROM browser_automations WHERE automation_id=json_extract(automations.action_json, '$.automationId')), 1)), enabled=0
+WHERE json_extract(action_json, '$.kind')='browser_automation';
+
+UPDATE devices SET scopes_json=json_insert(scopes_json, '$[#]', 'automations.read') WHERE platform='chrome' AND NOT EXISTS(SELECT 1 FROM json_each(scopes_json) WHERE value='automations.read');
+UPDATE devices SET scopes_json=json_insert(scopes_json, '$[#]', 'automations.write') WHERE platform='chrome' AND NOT EXISTS(SELECT 1 FROM json_each(scopes_json) WHERE value='automations.write');

package/dist/src/storage/sqlite/migrations/239_clarification_notifications.sql

@@ -0,0 +1,26 @@
+CREATE TABLE clarification_notification_outbox (
+  wait_id TEXT PRIMARY KEY REFERENCES session_clarification_waits(id) ON DELETE CASCADE,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'settled')),
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX idx_clarification_notification_pending ON clarification_notification_outbox(status, created_at);
+INSERT INTO clarification_notification_outbox(wait_id, created_at)
+SELECT id, CAST(json_extract(data_json, '$.createdAt') AS INTEGER)
+FROM session_clarification_waits WHERE status = 'open';
+
+ALTER TABLE notification_deliveries RENAME TO notification_deliveries_old;
+CREATE TABLE notification_deliveries (
+  event_id TEXT NOT NULL REFERENCES notification_events(event_id) ON DELETE CASCADE,
+  device_id TEXT NOT NULL REFERENCES device_push_endpoints(device_id) ON DELETE CASCADE,
+  status TEXT NOT NULL CHECK(status IN ('pending', 'accepted', 'delivered', 'dead', 'cancelled')),
+  attempts INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at INTEGER NOT NULL,
+  provider_ticket_id TEXT,
+  last_error TEXT,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY(event_id, device_id)
+);
+INSERT INTO notification_deliveries SELECT * FROM notification_deliveries_old;
+DROP TABLE notification_deliveries_old;
+CREATE INDEX idx_notification_deliveries_due ON notification_deliveries(status, next_attempt_at);
+CREATE INDEX idx_notification_deliveries_device ON notification_deliveries(device_id);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 237;
+export declare const XOPC_DB_SCHEMA_VERSION = 239;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -57,7 +57,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 */
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 237;
+	const targetVersion = options.targetVersion ?? 239;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -95,7 +95,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 237;
+	const appVersion = options.targetVersion ?? 239;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -137,7 +137,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 237;
+	XOPC_DB_SCHEMA_VERSION = 239;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/schema.js

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 237,
+		targetVersion: 239,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

package/dist/src/tasks/home-query-service.d.ts

@@ -58,7 +58,7 @@ export declare class HomeQueryService {
     #private;
     private readonly service;
     private readonly getAdvisor;
-    constructor(service: HomeGatewayPort, getAdvisor?: () => HomeAdvisor);
+    constructor(service: HomeGatewayPort, getAdvisor?: (locale?: string) => HomeAdvisor);
     getSnapshot(locale?: string): Promise<HomeResponse>;
 }
 export {};

package/dist/src/tasks/home-query-service.js

@@ -104,7 +104,11 @@ function decisionFromTask(model, projectName, locale) {
 		},
 		kind: "task",
 		title: task.title,
-		detail: item.summary,
+		detail: isChinese ? {
+			"Agent run returned no result or evidence": "本次执行没有返回结果或依据，请重试。",
+			"The latest run failed": "最近一次执行失败，请查看详情后重试。",
+			"Task is overdue": "任务已逾期。"
+		}[item.summary] ?? item.summary : item.summary,
 		reason,
 		urgency: "now",
 		href: `/tasks/${encodeURIComponent(task.id)}`,
@@ -412,7 +416,7 @@ var HomeQueryService = class {
 			}),
 			runningConversations,
 			decisions,
-			advisor: this.getAdvisor(),
+			advisor: this.getAdvisor(locale),
 			attentionPolicy: governed.policy
 		};
 	}

package/dist/src/voice/dashscope/streaming-tts-stream.d.ts

@@ -1,4 +1,4 @@
-import type { SpeechSynthesisStreamResult } from '../tts/speech-provider-types.js';
+import type { SpeechStreamSession, SpeechSynthesisStreamResult } from '../tts/speech-provider-types.js';
 export interface DashScopeStreamingTtsRequest {
     apiKey: string;
     baseUrl?: string;
@@ -11,3 +11,4 @@ export interface DashScopeStreamingTtsRequest {
     timeoutMs: number;
 }
 export declare function openDashScopeStreamingTts(request: DashScopeStreamingTtsRequest): Promise<SpeechSynthesisStreamResult>;
+export declare function openDashScopeTtsSession(request: Omit<DashScopeStreamingTtsRequest, 'text'>): Promise<SpeechStreamSession>;

package/dist/src/voice/dashscope/streaming-tts-stream.js

@@ -47,6 +47,18 @@ function event(type, extra = {}) {
 	});
 }
 async function openDashScopeStreamingTts(request) {
+	const session = await openDashScopeTtsSession(request);
+	try {
+		return {
+			...await session.synthesize(request.text),
+			release: () => session.close()
+		};
+	} catch (error) {
+		await session.close();
+		throw error;
+	}
+}
+async function openDashScopeTtsSession(request) {
 	const volume = request.volume ?? DEFAULT_REALTIME_VOLUME;
 	if (!Number.isInteger(volume) || volume < 0 || volume > 100) throw new Error("DashScope realtime TTS volume must be an integer from 0 to 100");
 	request = {
@@ -79,58 +91,48 @@ async function openDashScopeStreamingTts(request) {
 }
 async function openStreamingTtsAttempt(request) {
 	if (!request.apiKey) throw new Error("DashScope TTS API key is unavailable");
-	if (request.signal.aborted) throw request.signal.reason;
+	request.signal.throwIfAborted();
+	const startedAt = Date.now();
 	const socket = new WebSocket(realtimeUrl(request.baseUrl, request.model), {
 		headers: { Authorization: `Bearer ${request.apiKey}` },
 		perMessageDeflate: false
 	});
-	let controller;
 	let settled = false;
-	let streamClosed = false;
+	let closed = false;
+	let failure;
+	let active;
 	let resolveReady;
 	let rejectReady;
-	const readyPromise = new Promise((resolve, reject) => {
+	const ready = new Promise((resolve, reject) => {
 		resolveReady = resolve;
 		rejectReady = reject;
 	});
-	const audioStream = new ReadableStream({
-		start(next) {
-			controller = next;
-		},
-		cancel() {
-			streamClosed = true;
-			socket.close(1e3, "Consumer cancelled");
-		}
-	});
-	const fail = (error, closeSocket = true) => {
+	const closeSocket = (code, reason) => {
+		request.signal.removeEventListener("abort", onAbort);
+		if (socket.readyState === WebSocket.OPEN) socket.close(code, reason);
+		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+	};
+	const fail = (error, code = 1011) => {
+		if (closed) return;
+		failure = error;
+		closed = true;
 		if (!settled) rejectReady(error);
-		if (!streamClosed) {
-			streamClosed = true;
-			controller?.error(error);
-		}
-		if (closeSocket) {
-			if (socket.readyState === WebSocket.OPEN) socket.close(1011, "Provider stream failed");
-			else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+		if (active) {
+			clearTimeout(active.timer);
+			if (!active.audioDone) active.controller.error(error);
+			active.reject(error);
 		}
+		closeSocket(code, code === 1e3 ? "Aborted" : "Provider stream failed");
 	};
-	const finishStream = () => {
-		if (streamClosed) return;
-		streamClosed = true;
-		controller?.close();
-	};
-	const onAbort = () => {
-		fail(request.signal.reason instanceof Error ? request.signal.reason : new DOMException("Realtime TTS aborted", "AbortError"), false);
-		if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Aborted");
-		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
-	};
+	const onAbort = () => fail(request.signal.reason instanceof Error ? request.signal.reason : new DOMException("Realtime TTS aborted", "AbortError"), 1e3);
 	request.signal.addEventListener("abort", onAbort, { once: true });
+	if (request.signal.aborted) onAbort();
 	socket.on("unexpected-response", (_request, response) => {
 		fail(new TtsHandshakeError(response.statusCode ?? 0, parseRetryAfter(response.headers["retry-after"])));
 		response.destroy();
 	});
 	socket.on("message", (data, isBinary) => {
-		if (streamClosed || request.signal.aborted) return;
-		if (isBinary) return;
+		if (closed || isBinary) return;
 		let message;
 		try {
 			message = JSON.parse(rawText(data));
@@ -138,43 +140,54 @@ async function openStreamingTtsAttempt(request) {
 			fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid JSON"));
 			return;
 		}
-		if (message.type === "session.created") {
-			socket.send(event("session.update", { session: {
-				voice: request.voice,
-				mode: "commit",
-				language_type: "Auto",
-				response_format: "pcm",
-				sample_rate: 24e3,
-				volume: request.volume,
-				...request.instructions ? {
-					instructions: request.instructions,
-					optimize_instructions: false
-				} : {}
-			} }));
-			return;
-		}
-		if (message.type === "session.updated") {
+		if (message.type === "session.created") socket.send(event("session.update", { session: {
+			voice: request.voice,
+			mode: "commit",
+			language_type: "Auto",
+			response_format: "pcm",
+			sample_rate: 24e3,
+			volume: request.volume,
+			...request.instructions ? {
+				instructions: request.instructions,
+				optimize_instructions: false
+			} : {}
+		} }));
+		else if (message.type === "session.updated" && !settled) {
 			settled = true;
+			log.info({
+				model: request.model,
+				phase: "tts_connection_ready",
+				setupMs: Date.now() - startedAt
+			}, "Realtime TTS connection ready");
 			resolveReady();
-			socket.send(event("input_text_buffer.append", { text: request.text }));
-			socket.send(event("input_text_buffer.commit"));
-			return;
-		}
-		if (message.type === "response.audio.delta") {
-			if (streamClosed) return;
+		} else if (message.type === "response.audio.delta" && active && !active.audioDone) {
 			if (typeof message.delta !== "string") {
 				fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid audio"));
 				return;
 			}
-			controller?.enqueue(Buffer.from(message.delta, "base64"));
-			return;
-		}
-		if (message.type === "response.audio.done") {
-			finishStream();
-			socket.send(event("session.finish"));
-			return;
-		}
-		if (message.type === "error") {
+			const bytes = Buffer.from(message.delta, "base64");
+			if (!bytes.byteLength) return;
+			if (!active.firstAudio) {
+				active.firstAudio = true;
+				log.info({
+					model: request.model,
+					phase: "tts_first_audio",
+					synthesisMs: Date.now() - active.submittedAt
+				}, "Realtime TTS first audio received");
+			}
+			active.controller.enqueue(bytes);
+		} else if (message.type === "response.audio.done" && active && !active.audioDone) {
+			active.audioDone = true;
+			active.controller.close();
+		} else if (message.type === "response.done" && active) {
+			if (!active.audioDone) {
+				active.audioDone = true;
+				active.controller.close();
+			}
+			clearTimeout(active.timer);
+			active.resolve();
+			active = void 0;
+		} else if (message.type === "error") {
 			const code = typeof message.error?.code === "string" ? message.error.code : void 0;
 			const detail = typeof message.error?.message === "string" ? message.error.message : void 0;
 			fail(new Error([code, detail].filter(Boolean).join(": ") || "DashScope realtime TTS failed"));
@@ -183,28 +196,71 @@ async function openStreamingTtsAttempt(request) {
 	socket.on("error", (error) => fail(error));
 	socket.on("close", () => {
 		request.signal.removeEventListener("abort", onAbort);
-		if (!streamClosed) fail(/* @__PURE__ */ new Error("DashScope realtime TTS connection closed unexpectedly"));
+		if (!closed) fail(/* @__PURE__ */ new Error("DashScope realtime TTS connection closed unexpectedly"));
 	});
-	const timeout = setTimeout(() => {
-		fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out"));
-		socket.close(1011, "Setup timeout");
-	}, request.timeoutMs);
+	const timeout = setTimeout(() => fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out")), request.timeoutMs);
 	try {
-		await readyPromise;
+		await ready;
 	} finally {
 		clearTimeout(timeout);
 	}
 	return {
-		audioStream,
-		outputFormat: "pcm",
-		fileExtension: "pcm",
-		voiceCompatible: false,
-		release: async () => {
-			request.signal.removeEventListener("abort", onAbort);
-			finishStream();
-			if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Released");
+		async synthesize(text) {
+			request.signal.throwIfAborted();
+			if (closed) throw failure ?? /* @__PURE__ */ new Error("Realtime TTS session closed");
+			if (active) throw new Error("Realtime TTS synthesis already active");
+			let resolve;
+			let reject;
+			const done = new Promise((yes, no) => {
+				resolve = yes;
+				reject = no;
+			});
+			done.catch(() => {});
+			const audioStream = new ReadableStream({
+				start(controller) {
+					active = {
+						controller,
+						audioDone: false,
+						done,
+						resolve,
+						reject,
+						submittedAt: Date.now(),
+						firstAudio: false,
+						timer: setTimeout(() => fail(/* @__PURE__ */ new Error("Realtime TTS synthesis timed out")), request.timeoutMs)
+					};
+				},
+				cancel() {
+					fail(new DOMException("Realtime TTS consumer cancelled", "AbortError"), 1e3);
+				}
+			});
+			socket.send(event("input_text_buffer.append", { text }));
+			socket.send(event("input_text_buffer.commit"));
+			return {
+				audioStream,
+				outputFormat: "pcm",
+				fileExtension: "pcm",
+				voiceCompatible: false,
+				release: async () => {
+					await done;
+				}
+			};
+		},
+		async close() {
+			if (closed) return;
+			if (active && !active.audioDone) {
+				fail(new DOMException("Realtime TTS session released", "AbortError"), 1e3);
+				return;
+			}
+			if (active) {
+				clearTimeout(active.timer);
+				active.resolve();
+				active = void 0;
+			}
+			closed = true;
+			if (socket.readyState === WebSocket.OPEN) socket.send(event("session.finish"));
+			closeSocket(1e3, "Released");
 		}
 	};
 }
 //#endregion
-export { openDashScopeStreamingTts };
+export { openDashScopeStreamingTts, openDashScopeTtsSession };

package/dist/src/voice/metadata/types.d.ts

@@ -3,6 +3,7 @@ export type VoiceConfigFieldType = 'string' | 'password' | 'number' | 'boolean'
 export interface VoiceOptionMetadata {
     id: string;
     name: string;
+    displayNames?: Partial<Record<'zh-CN' | 'en', string>>;
     description?: string;
     gender?: string;
     style?: string;

package/dist/src/voice/platform-catalog.d.ts

@@ -24,6 +24,10 @@ export declare function requirePlatformVoiceModel(id: string, mode: VoiceModeCap
             id: string;
             name: string;
             languages: string[];
+            displayNames?: {
+                'zh-CN'?: string;
+                en?: string;
+            };
             gender?: "female" | "male";
             style?: string;
             description?: string;

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

@@ -39,6 +39,7 @@ function voiceSettingsCatalog(config) {
 		models: (source?.models ?? []).flatMap((model) => model.availability === "available" && model.voice ? [{
 			id: model.id,
 			name: model.name,
+			...model.displayNames ? { displayNames: model.displayNames } : {},
 			voice: model.voice
 		}] : [])
 	};

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

@@ -1,6 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { speakStream } from "../tts/speak-core.js";
+import { prepareSpeechStreamSession, speakStream } from "../tts/speak-core.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
 import { TurnCoordinator } from "./turnPolicy.js";
 import { PlaybackEchoCandidates } from "./playback-echo.js";
@@ -12,6 +12,7 @@ init_logger();
 const log = createLogger("Voice:Agent");
 const AGENT_TTS_MAX_SEGMENT_CHARACTERS = 180;
 const AGENT_TTS_MIN_SEGMENT_CHARACTERS = 24;
+const FIRST_PHRASE_WAIT_MS = 300;
 const PLAYBACK_ECHO_TAIL_MS = 3e3;
 const TASK_UPDATE_QUIET_MS = 1500;
 function createAgentVoiceEngine(options) {
@@ -101,6 +102,7 @@ function createAgentVoiceEngine(options) {
 			expiresAt: Date.now() + PLAYBACK_ECHO_TAIL_MS
 		};
 		activeResponse = void 0;
+		clearTimeout(response.firstPhraseTimer);
 		response.abortController.abort(reason);
 		send("response.cancelled", {
 			responseId: response.id,
@@ -124,6 +126,42 @@ function createAgentVoiceEngine(options) {
 	}
 	function openSpeech(response, job) {
 		if (job.opening) return job.opening;
+		if (response.firstSynthesisAtMs === void 0) {
+			response.firstSynthesisAtMs = Date.now();
+			log.info({
+				sessionId: claim.sessionId,
+				responseId: response.id,
+				conversationId: claim.request.conversationId,
+				phase: "first_synthesis_requested",
+				textToSynthesisMs: response.firstTextAtMs === void 0 ? void 0 : response.firstSynthesisAtMs - response.firstTextAtMs
+			}, "Realtime voice first synthesis requested");
+		}
+		if (response.preparedSpeech) {
+			job.opening = response.preparedSpeech.then(async (prepared) => {
+				if ("error" in prepared) return prepared;
+				response.abortController.signal.throwIfAborted();
+				if (response.firstSubmitAtMs === void 0) {
+					response.firstSubmitAtMs = Date.now();
+					log.info({
+						sessionId: claim.sessionId,
+						responseId: response.id,
+						conversationId: claim.request.conversationId,
+						phase: "first_tts_text_submitted",
+						phraseToSubmitMs: response.firstPhraseAtMs === void 0 ? void 0 : response.firstSubmitAtMs - response.firstPhraseAtMs
+					}, "Realtime voice first TTS text submitted");
+				}
+				const result = await prepared.session.synthesize(job.phrase);
+				return { result: {
+					...result,
+					provider: claim.tts.config.provider,
+					release: result.release ?? (async () => {}),
+					ttsText: job.phrase,
+					wasPreprocessed: false,
+					wasSummarized: false
+				} };
+			}).catch((error) => ({ error }));
+			return job.opening;
+		}
 		job.opening = speakStream(job.phrase, claim.tts.config, {
 			appConfig: claim.config,
 			parseDirectives: false,
@@ -133,6 +171,7 @@ function createAgentVoiceEngine(options) {
 		return job.opening;
 	}
 	function prefetchNextSpeech(response) {
+		if (response.preparedSpeech) return;
 		const next = response.speechQueue[0];
 		if (!next || next.opening || response.abortController.signal.aborted) return;
 		openSpeech(response, next);
@@ -165,6 +204,9 @@ function createAgentVoiceEngine(options) {
 						phase: "first_response_audio",
 						latencyMs: Date.now() - response.startedAt,
 						inputToAudioMs: Date.now() - response.inputReceivedAtMs,
+						submitToAudioMs: response.firstSubmitAtMs === void 0 ? void 0 : Date.now() - response.firstSubmitAtMs,
+						synthesisToAudioMs: response.firstSynthesisAtMs === void 0 ? void 0 : Date.now() - response.firstSynthesisAtMs,
+						phraseToAudioMs: response.firstPhraseAtMs === void 0 ? void 0 : Date.now() - response.firstPhraseAtMs,
 						textToAudioMs: response.firstTextAtMs === void 0 ? void 0 : Date.now() - response.firstTextAtMs
 					}, "Realtime voice first audio ready");
 					send("response.audio.started", {
@@ -233,6 +275,18 @@ function createAgentVoiceEngine(options) {
 	function queuePhrases(response, phrases) {
 		for (const phrase of phrases) {
 			if (response.speechError || response.abortController.signal.aborted) return;
+			if (response.firstPhraseAtMs === void 0) {
+				response.firstPhraseAtMs = Date.now();
+				clearTimeout(response.firstPhraseTimer);
+				log.info({
+					sessionId: claim.sessionId,
+					responseId: response.id,
+					conversationId: claim.request.conversationId,
+					phase: "first_speech_phrase",
+					characters: phrase.length,
+					textToPhraseMs: response.firstTextAtMs === void 0 ? void 0 : response.firstPhraseAtMs - response.firstTextAtMs
+				}, "Realtime voice first speech phrase ready");
+			}
 			if (response.queuedSpeechCharacters + phrase.length > 8e3) {
 				response.speechError = /* @__PURE__ */ new Error("Voice synthesis queue limit reached");
 				return;
@@ -275,6 +329,21 @@ function createAgentVoiceEngine(options) {
 		activeResponse = response;
 		send("response.created", { responseId: response.id });
 		try {
+			const opening = prepareSpeechStreamSession(claim.tts.config, {
+				appConfig: claim.config,
+				signal: response.abortController.signal,
+				allowFallback: false
+			});
+			if (opening) response.preparedSpeech = opening.then((session) => {
+				log.info({
+					sessionId: claim.sessionId,
+					responseId: response.id,
+					conversationId: claim.request.conversationId,
+					phase: "response_tts_ready",
+					setupMs: Date.now() - response.startedAt
+				}, "Realtime voice TTS prepared");
+				return { session };
+			}, (error) => ({ error }));
 			await interruptionWrites;
 			if (response.abortController.signal.aborted || closed) return taskUpdateExposed();
 			if (!claim.conversationSessionId) throw new Error("Conversation identity is unavailable");
@@ -320,6 +389,10 @@ function createAgentVoiceEngine(options) {
 						delta: event.payload.delta
 					});
 					queuePhrases(response, response.segmenter.push(event.payload.delta));
+					if (response.firstPhraseAtMs === void 0 && response.firstPhraseTimer === void 0) response.firstPhraseTimer = setTimeout(() => {
+						response.firstPhraseTimer = void 0;
+						if (activeResponse === response && !response.abortController.signal.aborted) queuePhrases(response, response.segmenter.flushFirstPhrase());
+					}, FIRST_PHRASE_WAIT_MS);
 				}
 				if (event.type === "tool_start") queuePhrases(response, response.segmenter.flush());
 				if ((event.type === "tool_start" || event.type === "tool_end") && typeof event.payload?.toolCallId === "string" && typeof event.payload?.toolName === "string") send("task.activity", {
@@ -410,7 +483,11 @@ function createAgentVoiceEngine(options) {
 			if (activeResponse === response) activeResponse = void 0;
 			return taskUpdateExposed();
 		} finally {
+			clearTimeout(response.firstPhraseTimer);
 			await waitForSpeech(response);
+			response.abortController.abort("response_finished");
+			const prepared = await response.preparedSpeech;
+			if (prepared && "session" in prepared) await prepared.session.close();
 		}
 	}
 	async function openSttSession(consumed) {

package/dist/src/voice/realtime/speakable-segmenter.d.ts

@@ -8,6 +8,8 @@ export declare class SpeakableSegmenter {
     private emitted;
     constructor(maxCharacters?: number, minCharacters?: number, firstMinCharacters?: number);
     push(delta: string): string[];
+    /** Releases only a complete short phrase; never cuts a word or Markdown construct. */
+    flushFirstPhrase(): string[];
     flush(): string[];
     private toSpeech;
 }