@flowingspring/dsh-voco 0.3.0 → 0.3.2

package/cordis.patch.yml

@@ -24,7 +24,8 @@
       name: '@flowingspring/dsh-voco/voice-assistant'
       config:
         maxPendingObservations: 64
-        restoreConversation: true
+        restoreConversation: true
+        memoryRecallTimeoutMs: 250
         maxRestoredUtterances: 24
         taskSessionPolicy: continuous
         completedAnnouncement: 任务已完成。

package/lib/client.js

@@ -18,11 +18,11 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var VoiceControl_module_css_default = {
+			"controls": "TFZsua_controls",
+			"button": "TFZsua_button",
 			"interruptButton": "TFZsua_interruptButton",
-			"active": "TFZsua_active",
 			"voice-pulse": "TFZsua_voice-pulse",
-			"button": "TFZsua_button",
-			"controls": "TFZsua_controls"
+			"active": "TFZsua_active"
 		};
 		//#endregion
 		//#region ../ui-voice/src/client/VoiceControl.tsx
@@ -141,23 +141,23 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var VoiceNodeViews_module_css_default = {
-			"taskLink": "Kt2smW_taskLink",
-			"taskCard": "Kt2smW_taskCard",
-			"utterance": "Kt2smW_utterance",
+			"taskCancel": "Kt2smW_taskCancel",
+			"taskSummary": "Kt2smW_taskSummary",
+			"meta": "Kt2smW_meta",
 			"taskDot": "Kt2smW_taskDot",
-			"bubble": "Kt2smW_bubble",
-			"voiceBadge": "Kt2smW_voiceBadge",
+			"taskStatus": "Kt2smW_taskStatus",
+			"taskInput": "Kt2smW_taskInput",
+			"taskTitle": "Kt2smW_taskTitle",
 			"taskActions": "Kt2smW_taskActions",
+			"taskLink": "Kt2smW_taskLink",
+			"voiceBadge": "Kt2smW_voiceBadge",
+			"bubble": "Kt2smW_bubble",
 			"taskChevron": "Kt2smW_taskChevron",
-			"taskSummary": "Kt2smW_taskSummary",
-			"miniWave": "Kt2smW_miniWave",
-			"meta": "Kt2smW_meta",
-			"taskDetails": "Kt2smW_taskDetails",
 			"taskUpdate": "Kt2smW_taskUpdate",
-			"taskCancel": "Kt2smW_taskCancel",
-			"taskInput": "Kt2smW_taskInput",
-			"taskStatus": "Kt2smW_taskStatus",
-			"taskTitle": "Kt2smW_taskTitle"
+			"taskCard": "Kt2smW_taskCard",
+			"taskDetails": "Kt2smW_taskDetails",
+			"miniWave": "Kt2smW_miniWave",
+			"utterance": "Kt2smW_utterance"
 		};
 		//#endregion
 		//#region ../ui-voice/src/client/VoiceNodeViews.tsx
@@ -285,11 +285,11 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var VoiceOverlay_module_css_default = {
-			"root": "GPPB2G_root",
-			"status": "GPPB2G_status",
-			"wave": "GPPB2G_wave",
 			"voice-wave": "GPPB2G_voice-wave",
-			"stop": "GPPB2G_stop"
+			"wave": "GPPB2G_wave",
+			"root": "GPPB2G_root",
+			"stop": "GPPB2G_stop",
+			"status": "GPPB2G_status"
 		};
 		//#endregion
 		//#region ../ui-voice/src/client/VoiceOverlay.tsx

package/lib/plugins/voice-assistant.js

@@ -129,7 +129,8 @@ const Config = z.object({
 	completedAnnouncement: z.string().default("任务已完成。"),
 	failedAnnouncement: z.string().default("任务失败了，请查看屏幕上的错误信息。"),
 	cancelledAnnouncement: z.string().default("任务已取消。"),
-	interruptedAnnouncement: z.string().default("上次任务因服务关闭而中断，没有自动重放。你可以告诉我是否继续。")
+	interruptedAnnouncement: z.string().default("上次任务因服务关闭而中断，没有自动重放。你可以告诉我是否继续。"),
+	memoryRecallTimeoutMs: z.natural().min(1).default(250)
 });
 /** Plugin-owned durable session event types, registered with core at load. */
 const VOICE_SESSION_EVENT_TYPES = [
@@ -166,6 +167,34 @@ function optionalSessionTitle(ctx) {
 		return;
 	}
 }
+function recallWithSoftTimeout(operation, timeoutMs) {
+	const deadline = Math.max(1, timeoutMs);
+	return new Promise((resolve) => {
+		let settled = false;
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			resolve({ kind: "timeout" });
+		}, deadline);
+		operation().then((value) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({
+				kind: "resolved",
+				value
+			});
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({
+				kind: "error",
+				error
+			});
+		});
+	});
+}
 function workspaceMemoryReference(memory) {
 	const sections = [];
 	if (memory.summary.trim() !== "") sections.push(`稳定摘要：\n${memory.summary.trim()}`);
@@ -254,8 +283,10 @@ function apply(ctx, config = {}) {
 	const bindings = /* @__PURE__ */ new Map();
 	const taskBindings = /* @__PURE__ */ new Map();
 	const handles = /* @__PURE__ */ new Map();
+	const audioResponsesSeen = /* @__PURE__ */ new Set();
 	const maxPending = config.maxPendingObservations ?? 64;
 	const maxRestoredUtterances = config.maxRestoredUtterances ?? 24;
+	const memoryRecallTimeoutMs = config.memoryRecallTimeoutMs ?? 250;
 	const loadConversationMemory = async (sessionId) => {
 		const events = ctx.sessions.get(sessionId)?.events ?? (await ctx.get("sessionPersistence")?.inspect(sessionId))?.events;
 		if (events === void 0) return void 0;
@@ -865,26 +896,69 @@ function apply(ctx, config = {}) {
 					});
 					return;
 				}
+				const routeStartedAt = Date.now();
+				const input = call.command.input;
+				debugVoiceLatency("route-command-received", {
+					callId: String(call.id),
+					inputLength: input.length
+				});
 				let route;
 				try {
 					let memoryReference = "";
 					const memory = optionalWorkspaceMemory(ctx);
-					if (memory !== void 0) try {
-						memoryReference = workspaceMemoryReference(await memory.recall({
+					if (memory !== void 0) {
+						const memoryStartedAt = Date.now();
+						debugVoiceLatency("memory-recall-start", { callId: String(call.id) });
+						const recallResult = await recallWithSoftTimeout(() => memory.recall({
 							sessionId: binding.sessionId,
-							query: call.command.input,
+							query: input,
 							maxBytes: 5e3
-						}));
-					} catch (error) {
-						ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
+						}), memoryRecallTimeoutMs);
+						if (recallResult.kind === "resolved") {
+							memoryReference = workspaceMemoryReference(recallResult.value);
+							debugVoiceLatency("memory-recall-end", {
+								callId: String(call.id),
+								durationMs: Date.now() - memoryStartedAt,
+								referenceLength: memoryReference.length
+							});
+						} else if (recallResult.kind === "timeout") debugVoiceLatency("memory-recall-timeout", {
+							callId: String(call.id),
+							durationMs: Date.now() - memoryStartedAt,
+							timeoutMs: memoryRecallTimeoutMs,
+							fallback: "empty-reference"
+						});
+						else {
+							debugVoiceLatency("memory-recall-error", {
+								callId: String(call.id),
+								durationMs: Date.now() - memoryStartedAt,
+								error: String(recallResult.error)
+							});
+							ctx.logger.warn(recallResult.error instanceof Error ? recallResult.error : new Error(String(recallResult.error)));
+						}
 					}
-					route = await routeFrontendInput(ctx, requireSourceSession(binding).events, call.command.input, memoryReference);
+					route = await routeFrontendInput(ctx, requireSourceSession(binding).events, input, memoryReference);
+					debugVoiceLatency("route-decision", {
+						callId: String(call.id),
+						action: route.action,
+						durationMs: Date.now() - routeStartedAt
+					});
 				} catch (error) {
+					debugVoiceLatency("route-error", {
+						callId: String(call.id),
+						durationMs: Date.now() - routeStartedAt,
+						error: String(error)
+					});
 					ctx.logger.warn(error instanceof Error ? error : new Error(String(error)));
-					route = fallbackDelegation(call.command.input, recentConversationText(requireSourceSession(binding).events));
+					route = fallbackDelegation(input, recentConversationText(requireSourceSession(binding).events));
 				}
 				if (route.action === "delegate") {
 					const taskId = VoiceTaskId(randomUUID());
+					debugVoiceLatency("ack-queued", {
+						callId: String(call.id),
+						taskId,
+						routeDurationMs: Date.now() - routeStartedAt,
+						textLength: route.acknowledgement.length
+					});
 					speakFragment(binding, taskId, route.acknowledgement);
 					await onTaskCommand(binding, voiceSessionId, {
 						id: call.id,
@@ -915,6 +989,12 @@ function apply(ctx, config = {}) {
 				const taskId = delegationOverride?.taskId ?? VoiceTaskId(randomUUID());
 				const requestText = delegationOverride?.requestText ?? call.command.input;
 				const continuous = (config.taskSessionPolicy ?? "isolated") === "continuous";
+				const delegationStartedAt = Date.now();
+				debugVoiceLatency("delegation-init-start", {
+					callId: String(call.id),
+					taskId,
+					policy: continuous ? "continuous" : "isolated"
+				});
 				let created;
 				try {
 					if (continuous) created = await ensureContinuousTaskAgent(binding);
@@ -926,7 +1006,19 @@ function apply(ctx, config = {}) {
 							...await createTaskAgent(binding, taskSessionId, selection)
 						};
 					}
+					debugVoiceLatency("delegation-init-end", {
+						callId: String(call.id),
+						taskId,
+						taskSessionId: created.taskSessionId,
+						durationMs: Date.now() - delegationStartedAt
+					});
 				} catch (error) {
+					debugVoiceLatency("delegation-init-error", {
+						callId: String(call.id),
+						taskId,
+						durationMs: Date.now() - delegationStartedAt,
+						error: String(error)
+					});
 					backendUnavailable(error);
 					return;
 				}
@@ -1153,6 +1245,11 @@ function apply(ctx, config = {}) {
 				});
 				return;
 			case "transcription.completed":
+				debugVoiceLatency("transcription-completed", {
+					voiceSessionId: String(session.id),
+					utteranceId: String(event.utteranceId),
+					textLength: event.text.length
+				});
 				enqueue(binding, async () => {
 					endUtterance(binding, event.utteranceId, "user", "completed", event.text);
 					if (session.interactionMode === "speech-shell" && binding.voiceSessionId === session.id) await onTranscription(binding, event.text);
@@ -1191,7 +1288,17 @@ function apply(ctx, config = {}) {
 				debugVoiceLatency("audio-started");
 				return;
 			case "output_audio.delta":
+				if (!audioResponsesSeen.has(String(event.responseId))) {
+					audioResponsesSeen.add(String(event.responseId));
+					debugVoiceLatency("audio-first-delta", {
+						responseId: String(event.responseId),
+						audioBytes: event.audio.byteLength
+					});
+				}
+				return;
 			case "output_audio.done":
+				audioResponsesSeen.delete(String(event.responseId));
+				return;
 			case "task.observation":
 			case "error":
 			case "closed": return;
@@ -1301,7 +1408,7 @@ function speechFragments(text, flush) {
 		rest
 	};
 }
-const DEFAULT_DELEGATION_ACKNOWLEDGEMENT = "我先查看一下。";
+const DEFAULT_DELEGATION_ACKNOWLEDGEMENT = "我看看。";
 const MAX_DELEGATION_ACKNOWLEDGEMENT_LENGTH = 40;
 const MAX_DELEGATED_TASK_LENGTH = 1e3;
 const MAX_DELEGATION_BACKGROUND_LENGTH = 2e3;
@@ -1379,20 +1486,30 @@ async function routeFrontendInput(ctx, events, input, workspaceMemory = "") {
 	const recentConversation = recentConversationText(events);
 	if (llm === void 0) return fallbackDelegation(input, recentConversation);
 	const selection = ctx.agentDefaultModel.currentSelection();
+	const routeLlmStartedAt = Date.now();
+	let routeLlmFirstTextAt;
+	debugVoiceLatency("route-llm-start", {
+		provider: selection.provider,
+		model: selection.model,
+		reasoningEffort: selection.reasoningEffort,
+		inputLength: input.length,
+		recentConversationLength: recentConversation.length,
+		workspaceMemoryLength: workspaceMemory.length
+	});
 	const message = createUserMessage({
 		content: [{
 			type: "text",
 			text: [
 				"结合最近对话判断当前用户原话应该由语音前台聊天、轻量工具还是后台编码 Agent 处理。",
-				"普通寒暄、日常对话、解释性知识以及无需外部事实或工具即可回答的问题，选择 chat，并直接给出自然简洁的中文回复。",
+				"只有普通寒暄、日常对话，以及无需外部事实或工具就能可靠回答的稳定知识，才选择 chat，并直接给出自然简洁的中文回复。",
 				"时间、日期等会随现实变化的事实不能猜测。查询本机当前时间、日期或星期时必须选择 tool=local_datetime。",
-				"其他必须查询才能确认的动态事实，如果没有对应的前台工具，应选择 delegate，不能选择 chat 编造答案。",
+				"凡是需要搜索、查询、核实、最新信息，或涉及陌生、不确定、可能过时的术语和事实，一律选择 delegate；不能选择 chat 编造答案。",
 				"需要查看或修改工作区文件、运行命令、测试、安装依赖或执行其他复杂工具操作时，选择 delegate。",
 				"选择 delegate 时，必须结合最近对话补全省略指代，输出自包含的 task、只用于消歧的 background，并原样复制 user_request。",
 				"task 是后台当前唯一要执行的任务；background 不能包含新的要求，也不要把旧任务写成待办。",
-				"同时给出一句简短自然的 acknowledgement，表示接下来要做什么。不能声称任务已经完成、已经找到结果，也不要提后台 Agent、工具或路由。",
-				"acknowledgement 只能有一句，最多 40 个字符；不要固定使用“好的”或其他相同开头，要根据任务自然变化，并尽量避免重复最近对话中的句式。",
-				"可以使用“我先核实一下”“我来检查一下”“我去确认一下”等自然表达，只有语气合适时才使用“好的”。",
+				"同时给出一句非常短、自然口语化的 acknowledgement，只说接下来要做的动作，不复述用户问题，不解释原因，不使用书面汇报语气。不能声称任务已经完成、已经找到结果，也不要提后台 Agent、工具或路由。",
+				"acknowledgement 尽量简短，通常不超过 16 个汉字，硬上限为 40 个字符；避免使用“核实”“确认”“具体含义”“相关内容”等书面化表达，也不要把用户的术语或问题改写进去。",
+				"根据任务语境使用日常说法，例如“我去查查”“我看看”“我帮你找找”“我去搜一下”。不要固定使用同一句，也不要强行添加“哈”。",
 				"任务边界与写操作规则：task 只能重述用户明确表达的目标，不得擅自增加新的交付物。",
 				"搜索、查询、核实、阅读和分析类任务默认只读，不创建或修改工作区文件。",
 				"“给我一个结果”“给我一个产物”“整理一下”“形成说明”等模糊表达，不代表允许写文件。",
@@ -1420,13 +1537,28 @@ async function routeFrontendInput(ctx, events, input, workspaceMemory = "") {
 		}
 	});
 	let output = "";
-	for await (const chunk of llm.stream({
-		provider: selection.provider,
-		model: selection.model,
-		...selection.reasoningEffort === void 0 ? {} : { reasoningEffort: selection.reasoningEffort },
-		messages: [message],
-		system: "你是语音前台路由器。严格按要求输出一个 JSON 对象。不要把普通对话委派给后台编码 Agent。"
-	})) if (chunk.type === "text-delta") output += chunk.text;
+	try {
+		for await (const chunk of llm.stream({
+			provider: selection.provider,
+			model: selection.model,
+			...selection.reasoningEffort === void 0 ? {} : { reasoningEffort: selection.reasoningEffort },
+			messages: [message],
+			system: "你是语音前台路由器。严格按要求输出一个 JSON 对象。不要把普通对话委派给后台编码 Agent。"
+		})) {
+			if (chunk.type !== "text-delta") continue;
+			if (routeLlmFirstTextAt === void 0) {
+				routeLlmFirstTextAt = Date.now();
+				debugVoiceLatency("route-llm-first-text", { delayMs: routeLlmFirstTextAt - routeLlmStartedAt });
+			}
+			output += chunk.text;
+		}
+	} finally {
+		debugVoiceLatency("route-llm-end", {
+			durationMs: Date.now() - routeLlmStartedAt,
+			firstTextDelayMs: routeLlmFirstTextAt === void 0 ? void 0 : routeLlmFirstTextAt - routeLlmStartedAt,
+			outputLength: output.length
+		});
+	}
 	const normalized = output.trim().replace(/^```(?:json)?\s*/iu, "").replace(/\s*```$/u, "");
 	const parsed = JSON.parse(normalized);
 	if (parsed.action === "chat" && typeof parsed.reply === "string" && parsed.reply.trim() !== "") return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flowingspring/dsh-voco",
   "description": "Persistent voice conversations for DSH with cloud speech recognition, Edge TTS, and background Agent delegation",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "keywords": [
     "deepseek-harness",
     "dsh",