@xopcai/xopc 0.0.242 → 0.0.243

package/dist/packages/realtime-protocol/src/voice-audio.js

@@ -0,0 +1,20 @@
+//#region packages/realtime-protocol/src/voice-audio.ts
+const HEADER_BYTES = 12;
+const MAGIC = 1481592882;
+const MAX_FRAME_BYTES = 64 * 1024;
+const encoder = new TextEncoder();
+new TextDecoder("utf-8", { fatal: true });
+function encodeVoiceAudioFrame(frame) {
+	const id = encoder.encode(frame.responseId);
+	if (!id.length || id.length > 160 || !Number.isInteger(frame.seq) || frame.seq < 1 || frame.seq > 4294967295 || !frame.audio.length || frame.audio.length % 2 || HEADER_BYTES + id.length + frame.audio.length > MAX_FRAME_BYTES) throw new Error("Invalid voice audio frame");
+	const bytes = new Uint8Array(HEADER_BYTES + id.length + frame.audio.length);
+	const header = new DataView(bytes.buffer);
+	header.setUint32(0, MAGIC);
+	header.setUint32(4, frame.seq);
+	header.setUint32(8, id.length);
+	bytes.set(id, HEADER_BYTES);
+	bytes.set(frame.audio, HEADER_BYTES + id.length);
+	return bytes;
+}
+//#endregion
+export { encodeVoiceAudioFrame };

package/dist/packages/realtime-protocol/src/voice.js

@@ -0,0 +1,208 @@
+import "./voice-audio.js";
+import { z } from "zod";
+const VOICE_REALTIME_WS_PATH = "/api/voice/realtime/v2/ws";
+const VOICE_REALTIME_MAX_BINARY_FRAME_BYTES = 64 * 1024;
+const VOICE_REALTIME_START_TIMEOUT_MS = 1e4;
+const VOICE_REALTIME_HEARTBEAT_INTERVAL_MS = 15e3;
+const idSchema = z.uuid();
+const timestampSchema = z.number().int().nonnegative();
+const voicePurposeSchema = z.enum(["dictation", "conversation"]);
+const voiceEngineSchema = z.enum(["agent", "omni"]);
+const voiceInputModeSchema = z.literal("server_vad");
+const voiceLanguageSchema = z.enum(["zh", "en"]);
+const voicePcmFormatSchema = z.strictObject({
+	encoding: z.literal("pcm_s16le"),
+	sampleRate: z.union([z.literal(16e3), z.literal(24e3)]),
+	channels: z.literal(1)
+});
+const voiceProviderRouteSchema = z.strictObject({
+	provider: z.string().min(1).max(100),
+	model: z.string().min(1).max(200),
+	managed: z.boolean()
+});
+const voiceRouteSchema = z.discriminatedUnion("engine", [
+	z.strictObject({
+		engine: z.literal("dictation"),
+		stt: voiceProviderRouteSchema
+	}),
+	z.strictObject({
+		engine: z.literal("agent"),
+		stt: voiceProviderRouteSchema,
+		tts: voiceProviderRouteSchema
+	}),
+	z.strictObject({
+		engine: z.literal("omni"),
+		omni: voiceProviderRouteSchema
+	})
+]);
+const availabilitySchema = z.strictObject({
+	available: z.boolean(),
+	reasonCode: z.enum(["VOICE_DISABLED", "PROVIDER_UNAVAILABLE"]).optional()
+});
+z.object({
+	enabled: z.boolean(),
+	defaultEngine: voiceEngineSchema,
+	omni: voiceProviderRouteSchema.nullable(),
+	stt: voiceProviderRouteSchema.nullable(),
+	tts: voiceProviderRouteSchema.extend({ voice: z.string().optional() }).nullable(),
+	capabilities: z.strictObject({
+		dictation: availabilitySchema,
+		agent: availabilitySchema,
+		omni: availabilitySchema,
+		languages: z.array(voiceLanguageSchema),
+		bargeIn: z.boolean()
+	})
+});
+const createVoiceSessionRequestSchema = z.strictObject({
+	purpose: voicePurposeSchema,
+	engine: voiceEngineSchema.optional(),
+	sessionKey: z.string().min(1).max(512).optional(),
+	language: voiceLanguageSchema.optional()
+}).superRefine((value, context) => {
+	if (value.purpose === "conversation" && !value.sessionKey) context.addIssue({
+		code: "custom",
+		path: ["sessionKey"],
+		message: "sessionKey is required for conversation"
+	});
+	if (value.purpose !== "conversation" && value.engine !== void 0) context.addIssue({
+		code: "custom",
+		path: ["engine"],
+		message: "engine is only supported for conversation"
+	});
+});
+z.strictObject({
+	sessionId: idSchema,
+	ticket: z.string().min(32).max(512),
+	ticketExpiresAt: z.iso.datetime(),
+	websocketPath: z.literal(VOICE_REALTIME_WS_PATH),
+	protocolVersion: z.literal(2),
+	purpose: voicePurposeSchema,
+	inputMode: voiceInputModeSchema,
+	bargeIn: z.boolean(),
+	inputFormat: voicePcmFormatSchema,
+	limits: z.strictObject({
+		maxBinaryFrameBytes: z.literal(VOICE_REALTIME_MAX_BINARY_FRAME_BYTES),
+		maxSessionMs: z.number().int().positive(),
+		idleTimeoutMs: z.number().int().positive()
+	}),
+	route: voiceRouteSchema
+});
+const clientEnvelope = (type, payload) => z.strictObject({
+	protocolVersion: z.literal(2),
+	messageId: idSchema,
+	type: z.literal(type),
+	sentAt: timestampSchema,
+	payload
+});
+const voiceClientMessageSchema = z.discriminatedUnion("type", [
+	clientEnvelope("session.start", z.strictObject({
+		sessionId: idSchema,
+		ticket: z.string().min(32).max(512)
+	})),
+	clientEnvelope("session.metric", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		metric: z.enum(["speech_end_to_audio_received", "local_stop"]),
+		durationMs: z.number().finite().min(0).max(6e5)
+	})),
+	clientEnvelope("input.mute", z.strictObject({ muted: z.boolean() })),
+	clientEnvelope("input.commit", z.strictObject({})),
+	clientEnvelope("response.cancel", z.strictObject({ responseId: z.string().min(1).max(160) })),
+	clientEnvelope("response.audio.played", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		playedBytes: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).multipleOf(2)
+	})),
+	clientEnvelope("session.stop", z.strictObject({ reason: z.enum([
+		"user_finished",
+		"surface_closed",
+		"replaced"
+	]) })),
+	clientEnvelope("session.ping", z.strictObject({}))
+]);
+const transcriptPayloadSchema = z.strictObject({
+	utteranceId: z.string().min(1).max(160),
+	revision: z.number().int().positive(),
+	text: z.string().max(32 * 1024),
+	language: voiceLanguageSchema.optional()
+});
+const serverEnvelope = (type, payload) => z.strictObject({
+	protocolVersion: z.literal(2),
+	eventId: idSchema,
+	seq: z.number().int().positive(),
+	type: z.literal(type),
+	sentAt: timestampSchema,
+	sessionId: idSchema,
+	payload
+});
+z.discriminatedUnion("type", [
+	serverEnvelope("session.ready", z.strictObject({
+		purpose: voicePurposeSchema,
+		inputMode: voiceInputModeSchema,
+		inputFormat: voicePcmFormatSchema,
+		route: voiceRouteSchema,
+		heartbeatIntervalMs: z.literal(VOICE_REALTIME_HEARTBEAT_INTERVAL_MS)
+	})),
+	serverEnvelope("input.speech_started", z.strictObject({ utteranceId: z.string().min(1).max(160) })),
+	serverEnvelope("input.speech_stopped", z.strictObject({ utteranceId: z.string().min(1).max(160) })),
+	serverEnvelope("input.transcript.delta", transcriptPayloadSchema),
+	serverEnvelope("input.transcript.final", transcriptPayloadSchema),
+	serverEnvelope("response.created", z.strictObject({ responseId: z.string().min(1).max(160) })),
+	serverEnvelope("response.activity", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		toolCallId: z.string().min(1).max(160),
+		toolName: z.string().min(1).max(256),
+		status: z.enum([
+			"running",
+			"completed",
+			"failed"
+		])
+	})),
+	serverEnvelope("response.clarification", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		requestId: z.string().min(1).max(160),
+		question: z.string().min(1).max(8e3),
+		choices: z.array(z.string().max(1e3)).max(20).optional()
+	})),
+	serverEnvelope("response.text.delta", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		delta: z.string().max(32 * 1024)
+	})),
+	serverEnvelope("response.text.done", z.strictObject({ responseId: z.string().min(1).max(160) })),
+	serverEnvelope("response.audio.started", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		format: voicePcmFormatSchema
+	})),
+	serverEnvelope("response.audio.done", z.strictObject({ responseId: z.string().min(1).max(160) })),
+	serverEnvelope("response.done", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		finishReason: z.enum([
+			"completed",
+			"text_only",
+			"audio_partial"
+		]),
+		audio: z.boolean()
+	})),
+	serverEnvelope("response.cancelled", z.strictObject({
+		responseId: z.string().min(1).max(160),
+		reason: z.enum([
+			"barge_in",
+			"client_cancelled",
+			"session_closed"
+		])
+	})),
+	serverEnvelope("session.pong", z.strictObject({})),
+	serverEnvelope("session.error", z.strictObject({
+		code: z.string().min(1).max(80),
+		message: z.string().min(1).max(500),
+		recoverable: z.boolean()
+	})),
+	serverEnvelope("session.closed", z.strictObject({ reason: z.string().min(1).max(160) }))
+]);
+function parseVoiceClientMessage(value) {
+	return voiceClientMessageSchema.parse(value);
+}
+function parseVoiceClientJsonFrame(text) {
+	if (new TextEncoder().encode(text).byteLength > 16 * 1024) throw new Error("Voice control frame exceeds 16384 bytes");
+	return JSON.parse(text);
+}
+//#endregion
+export { VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, VOICE_REALTIME_MAX_BINARY_FRAME_BYTES, VOICE_REALTIME_START_TIMEOUT_MS, VOICE_REALTIME_WS_PATH, createVoiceSessionRequestSchema, parseVoiceClientJsonFrame, parseVoiceClientMessage };

package/dist/src/agent/embedded/run-for-session.d.ts

@@ -13,6 +13,7 @@ export type RunEmbeddedForSessionParams = {
     agentManager: AgentInstanceGateway;
     modelManager: ModelManager;
     thinkingOverride?: string | null;
+    presentation?: 'voice';
     abortSignal?: AbortSignal;
     /** Absolute parent deadline. The turn's own timeout is capped to the remaining budget. */
     deadlineAtMs?: number;

package/dist/src/agent/embedded/run-for-session.js

@@ -9,6 +9,7 @@ import { evaluateContextBudget } from "../memory/context-budget.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { projectTurnOutcome } from "../../session/turn-outcome-projector.js";
 import { runXopcEmbeddedTurn } from "./run-turn.js";
+import { voicePresentationPrompt } from "../prompt/voice-presentation.js";
 import { applyStartupContextToUserMessage } from "../reply/apply-turn-user-enrichment.js";
 import { AgentRunSupervisor } from "../orchestration/agent-run-supervisor.js";
 import crypto from "node:crypto";
@@ -95,7 +96,7 @@ async function runEmbeddedTurnForSession(params) {
 		agentManager.setModelForSession(sessionKey, modelRef);
 		const tools = agent.state.tools;
 		const turnPolicy = agentManager.createAgentTurnPolicy(sessionKey);
-		const systemPrompt = agent.state.systemPrompt ?? "";
+		const systemPrompt = [agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n");
 		const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
 		const workspaceDir = agentManager.getResolvedWorkspaceForSession(sessionKey);
 		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(config, sessionKey).config.runtime.promptCache : void 0);

package/dist/src/agent/inbound/turn-dispatcher.d.ts

@@ -75,6 +75,7 @@ export declare class TurnDispatcher {
         signal?: AbortSignal;
         runId?: string;
         sourceContexts?: AgentSourceContext[];
+        presentation?: 'voice';
     }): AsyncGenerator<ProcessDirectStreamEvent, void, unknown>;
     /** Push an out-of-band event into the live webchat stream for a session. */
     enqueueWebchatStreamEvent(sessionKey: string, event: {

package/dist/src/agent/inbound/turn-dispatcher.js

@@ -34,7 +34,8 @@ var TurnDispatcher = class {
 			thinking,
 			signal: options?.signal,
 			runId: options?.runId,
-			sourceContexts: options?.sourceContexts
+			sourceContexts: options?.sourceContexts,
+			presentation: options?.presentation
 		});
 	}
 	/** Push an out-of-band event into the live webchat stream for a session. */

package/dist/src/agent/prompt/voice-presentation.d.ts

@@ -0,0 +1,2 @@
+/** Per-turn presentation only; never persisted as a user message or Agent identity. */
+export declare const voicePresentationPrompt = "This turn is a live voice conversation in the same Chat.\nLead with the useful answer. Prefer one to three natural spoken sentences unless the user asks for detail.\nAllow silence. Do not repeatedly greet, recap unrelated old tasks, or end every reply with a question.\nFor work, briefly say what you are doing, use the available tools, then report the actual result.\nKeep code, long URLs, tables and detailed reference material in Chat; introduce them with a short spoken explanation.\nDo not imply a task continues in the background unless an existing task or workflow actually started it.\nUse the existing clarification and approval mechanisms. A background sound or ambiguous interjection is not permission for an action.\nStopping speech does not undo a completed tool action. State consequential results accurately.";

package/dist/src/agent/prompt/voice-presentation.js

@@ -0,0 +1,12 @@
+//#region src/agent/prompt/voice-presentation.ts
+/** Per-turn presentation only; never persisted as a user message or Agent identity. */
+const voicePresentationPrompt = `This turn is a live voice conversation in the same Chat.
+Lead with the useful answer. Prefer one to three natural spoken sentences unless the user asks for detail.
+Allow silence. Do not repeatedly greet, recap unrelated old tasks, or end every reply with a question.
+For work, briefly say what you are doing, use the available tools, then report the actual result.
+Keep code, long URLs, tables and detailed reference material in Chat; introduce them with a short spoken explanation.
+Do not imply a task continues in the background unless an existing task or workflow actually started it.
+Use the existing clarification and approval mechanisms. A background sound or ambiguous interjection is not permission for an action.
+Stopping speech does not undo a completed tool action. State consequential results accurately.`;
+//#endregion
+export { voicePresentationPrompt };

package/dist/src/agent/service/direct-turn-helpers.d.ts

@@ -69,6 +69,7 @@ export interface RunDirectAgentTurnInput {
     deadlineAtMs?: number;
     sourceImages?: ImageContent[];
     sourceContexts?: AgentSourceContext[];
+    presentation?: 'voice';
     onEvent?: (event: EmbeddedStreamEvent) => void;
 }
 export interface RunDirectAgentTurnResult {

package/dist/src/agent/service/direct-turn-helpers.js

@@ -107,6 +107,7 @@ async function runDirectAgentTurn(deps, input) {
 		runId: turnId,
 		userMessage: userMessageForModel,
 		llmImages,
+		presentation: input.presentation,
 		sessionStore: deps.sessionStore,
 		agentManager: deps.agentManager,
 		modelManager: deps.modelManager,

package/dist/src/agent/service/process-direct-streaming.d.ts

@@ -66,6 +66,7 @@ export interface ProcessDirectStreamingInput {
     signal?: AbortSignal;
     runId?: string;
     sourceContexts?: AgentSourceContext[];
+    presentation?: 'voice';
 }
 export type ProcessDirectStreamEvent = {
     type: string;

package/dist/src/agent/service/process-direct-streaming.js

@@ -298,6 +298,7 @@ async function* runProcessDirectStreaming(deps, input) {
 					userMessage,
 					abortSignal: signal,
 					sourceContexts,
+					presentation: input.presentation,
 					runId: input.runId,
 					onEvent: (embeddedEvent) => {
 						const event = { ...embeddedEvent };
@@ -332,7 +333,7 @@ async function* runProcessDirectStreaming(deps, input) {
 				sessionKey,
 				droppedEvents: queue.droppedCount
 			}, "Coalesced stream progress events because the consumer fell behind");
-			if (!userAborted && !streamOverflowed && channel === "webchat" && !explicitTtsEmitted) try {
+			if (!userAborted && !streamOverflowed && channel === "webchat" && !explicitTtsEmitted && input.presentation !== "voice") try {
 				const ttsAudioEvent = await deps.maybeEmitWebchatTts(sessionKey, inboundVoice);
 				if (ttsAudioEvent) queue.push(ttsAudioEvent);
 			} catch (ttsErr) {

package/dist/src/agent/session/session-config-service.js

@@ -76,8 +76,10 @@ var SessionConfigService = class {
 				});
 				this.opts.modelManager.restoreSessionModel(sessionKey, modelRef, updated.fixedModel === true);
 				try {
-					this.opts.agentManager.setModelForSession(sessionKey, modelRef);
-					this.opts.agentManager.setThinkingLevel(sessionKey, thinkingLevel);
+					if (this.opts.agentManager.getAgent(sessionKey)) {
+						this.opts.agentManager.setModelForSession(sessionKey, modelRef);
+						this.opts.agentManager.setThinkingLevel(sessionKey, thinkingLevel);
+					}
 				} catch (err) {
 					this.opts.agentManager.removeAgent(sessionKey);
 					log.warn({

package/dist/src/automations/draft/automation-draft-service.js

@@ -2,8 +2,8 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
-import { resolveDraftModelRef } from "../../workflows/draft/workflow-draft-service.js";
 import { buildAutomationDraftPrompt, buildAutomationDraftRepairPrompt, buildAutomationRunRepairPrompt, buildAutomationRunRepairRetryPrompt } from "./automation-draft-prompt.js";
+import { resolveDraftModelRef } from "../../workflows/draft/workflow-draft-service.js";
 import { buildAutomationDraftResponse, parseGeneratedAutomationDraft, parseGeneratedAutomationRepairDraft } from "./automation-draft-validator.js";
 //#region src/automations/draft/automation-draft-service.ts
 init_providers();

package/dist/src/config/models-json.d.ts

@@ -29,11 +29,11 @@ export declare const OpenAICompletionsCompatSchema: z.ZodObject<{
     requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
     requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
     thinkingFormat: z.ZodOptional<z.ZodEnum<{
-        zai: "zai";
         "ant-ling": "ant-ling";
         openai: "openai";
         deepseek: "deepseek";
         openrouter: "openrouter";
+        zai: "zai";
         together: "together";
         baseten: "baseten";
         dashscope: "dashscope";
@@ -67,11 +67,11 @@ export declare const OpenAICompatSchema: z.ZodUnion<readonly [z.ZodObject<{
     requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
     requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
     thinkingFormat: z.ZodOptional<z.ZodEnum<{
-        zai: "zai";
         "ant-ling": "ant-ling";
         openai: "openai";
         deepseek: "deepseek";
         openrouter: "openrouter";
+        zai: "zai";
         together: "together";
         baseten: "baseten";
         dashscope: "dashscope";
@@ -312,11 +312,11 @@ export declare const CustomModelSchema: z.ZodObject<{
         requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
         requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
         thinkingFormat: z.ZodOptional<z.ZodEnum<{
-            zai: "zai";
             "ant-ling": "ant-ling";
             openai: "openai";
             deepseek: "deepseek";
             openrouter: "openrouter";
+            zai: "zai";
             together: "together";
             baseten: "baseten";
             dashscope: "dashscope";
@@ -375,11 +375,11 @@ export declare const ModelOverrideSchema: z.ZodObject<{
         requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
         requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
         thinkingFormat: z.ZodOptional<z.ZodEnum<{
-            zai: "zai";
             "ant-ling": "ant-ling";
             openai: "openai";
             deepseek: "deepseek";
             openrouter: "openrouter";
+            zai: "zai";
             together: "together";
             baseten: "baseten";
             dashscope: "dashscope";
@@ -466,11 +466,11 @@ export declare const ProviderConfigSchema: z.ZodObject<{
             requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
             requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
             thinkingFormat: z.ZodOptional<z.ZodEnum<{
-                zai: "zai";
                 "ant-ling": "ant-ling";
                 openai: "openai";
                 deepseek: "deepseek";
                 openrouter: "openrouter";
+                zai: "zai";
                 together: "together";
                 baseten: "baseten";
                 dashscope: "dashscope";
@@ -529,11 +529,11 @@ export declare const ProviderConfigSchema: z.ZodObject<{
             requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
             requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
             thinkingFormat: z.ZodOptional<z.ZodEnum<{
-                zai: "zai";
                 "ant-ling": "ant-ling";
                 openai: "openai";
                 deepseek: "deepseek";
                 openrouter: "openrouter";
+                zai: "zai";
                 together: "together";
                 baseten: "baseten";
                 dashscope: "dashscope";
@@ -701,11 +701,11 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                 requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
                 requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
                 thinkingFormat: z.ZodOptional<z.ZodEnum<{
-                    zai: "zai";
                     "ant-ling": "ant-ling";
                     openai: "openai";
                     deepseek: "deepseek";
                     openrouter: "openrouter";
+                    zai: "zai";
                     together: "together";
                     baseten: "baseten";
                     dashscope: "dashscope";
@@ -764,11 +764,11 @@ export declare const ModelsJsonSchema: z.ZodObject<{
                 requiresThinkingAsText: z.ZodOptional<z.ZodBoolean>;
                 requiresMistralToolIds: z.ZodOptional<z.ZodBoolean>;
                 thinkingFormat: z.ZodOptional<z.ZodEnum<{
-                    zai: "zai";
                     "ant-ling": "ant-ling";
                     openai: "openai";
                     deepseek: "deepseek";
                     openrouter: "openrouter";
+                    zai: "zai";
                     together: "together";
                     baseten: "baseten";
                     dashscope: "dashscope";

package/dist/src/config/schema.d.ts

@@ -1071,6 +1071,36 @@ export declare const VoiceConfigSchema: z.ZodOptional<z.ZodObject<{
             customInstruction: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    realtime: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        defaultEngine: z.ZodDefault<z.ZodEnum<{
+            agent: "agent";
+            omni: "omni";
+        }>>;
+        silenceDurationMs: z.ZodDefault<z.ZodNumber>;
+        idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxDictationMs: z.ZodDefault<z.ZodNumber>;
+        maxConversationMs: z.ZodDefault<z.ZodNumber>;
+        bargeIn: z.ZodDefault<z.ZodBoolean>;
+        tts: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                alibaba: "alibaba";
+                "xopc-cloud": "xopc-cloud";
+            }>;
+            voice: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        omni: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                alibaba: "alibaba";
+                "xopc-cloud": "xopc-cloud";
+            }>;
+            model: z.ZodString;
+            voice: z.ZodString;
+            baseUrl: z.ZodOptional<z.ZodString>;
+            apiKey: z.ZodOptional<z.ZodString>;
+            instructions: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>>;
 export declare const MessagesConfigSchema: z.ZodOptional<z.ZodObject<{
     tts: z.ZodOptional<z.ZodObject<{
@@ -2183,6 +2213,36 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 customInstruction: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
         }, z.core.$strict>>;
+        realtime: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            defaultEngine: z.ZodDefault<z.ZodEnum<{
+                agent: "agent";
+                omni: "omni";
+            }>>;
+            silenceDurationMs: z.ZodDefault<z.ZodNumber>;
+            idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxDictationMs: z.ZodDefault<z.ZodNumber>;
+            maxConversationMs: z.ZodDefault<z.ZodNumber>;
+            bargeIn: z.ZodDefault<z.ZodBoolean>;
+            tts: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    alibaba: "alibaba";
+                    "xopc-cloud": "xopc-cloud";
+                }>;
+                voice: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            omni: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodEnum<{
+                    alibaba: "alibaba";
+                    "xopc-cloud": "xopc-cloud";
+                }>;
+                model: z.ZodString;
+                voice: z.ZodString;
+                baseUrl: z.ZodOptional<z.ZodString>;
+                apiKey: z.ZodOptional<z.ZodString>;
+                instructions: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
     update: z.ZodOptional<z.ZodObject<{
         checkOnStart: z.ZodDefault<z.ZodBoolean>;

package/dist/src/config/schema.js

@@ -800,7 +800,37 @@ activityDetailDefault: z.enum([
 	VoiceConfigSchema = z.object({
 		languageMode: z.enum(["auto", "manual"]).optional(),
 		language: z.enum(["en", "zh"]).optional(),
-		input: z.object({ refinement: VoiceRefinementConfigSchema.optional() }).strict().optional()
+		input: z.object({ refinement: VoiceRefinementConfigSchema.optional() }).strict().optional(),
+		realtime: z.object({
+			enabled: z.boolean().default(false),
+			defaultEngine: z.enum(["agent", "omni"]).default("agent"),
+			silenceDurationMs: z.number().int().min(300).max(2e3).default(700),
+			idleTimeoutMs: z.number().int().min(1e4).max(3e5).default(6e4),
+			maxDictationMs: z.number().int().min(1e4).max(36e5).default(6e5),
+			maxConversationMs: z.number().int().min(1e4).max(72e5).default(36e5),
+			bargeIn: z.boolean().default(true),
+			/** Conversation output selection; credentials stay in the provider configuration. */
+			tts: z.object({
+				provider: z.enum(["alibaba", "xopc-cloud"]),
+				voice: z.string().trim().min(1).max(200).optional()
+			}).strict().optional(),
+			omni: z.object({
+				provider: z.enum(["alibaba", "xopc-cloud"]),
+				model: z.string().min(1).max(200),
+				voice: z.string().min(1).max(100),
+				baseUrl: z.string().url().optional(),
+				apiKey: z.string().min(1).optional(),
+				instructions: z.string().max(8e3).default("You are a friendly voice companion. Keep replies conversational and concise. You cannot execute tools or perform actions.")
+			}).strict().optional()
+		}).strict().default({
+			enabled: false,
+			defaultEngine: "agent",
+			silenceDurationMs: 700,
+			idleTimeoutMs: 6e4,
+			maxDictationMs: 6e5,
+			maxConversationMs: 36e5,
+			bargeIn: true
+		})
 	}).strict().optional();
 	MessagesConfigSchema = z.object({ 
 	/** Voice (text-to-speech) output configuration. */

package/dist/src/files/file-service.d.ts

@@ -40,5 +40,6 @@ export declare class FileSpaceService {
         resource: FileResource;
         absolutePath: string;
     }>;
+    rootResource(spaceId: string): Promise<FileResource>;
     children(spaceId: string, path?: string): Promise<FileResource[]>;
 }

package/dist/src/files/file-service.js

@@ -289,6 +289,10 @@ var FileSpaceService = class {
 			absolutePath
 		};
 	}
+	async rootResource(spaceId) {
+		const space = await this.get(spaceId);
+		return fileResourceFromPath(space, await resolveFilePath(space.root, ""));
+	}
 	async children(spaceId, path = "") {
 		const space = await this.get(spaceId);
 		const directory = await resolveFilePath(space.root, path);

package/dist/src/gateway/chat-stream/thinking-delta-coalescer.js

@@ -35,7 +35,12 @@ async function* coalesceThinkingDeltas(source, options = {}) {
 	if (!Number.isFinite(windowMs) || windowMs <= 0) throw new Error("thinking delta coalescer windowMs must be greater than zero");
 	if (!Number.isInteger(maxChars) || maxChars <= 0) throw new Error("thinking delta coalescer maxChars must be a positive integer");
 	const iterator = source[Symbol.asyncIterator]();
-	let next = iterator.next();
+	const readNext = () => {
+		const result = iterator.next();
+		result.catch(() => {});
+		return result;
+	};
+	let next = readNext();
 	let pending;
 	let deadlineAt = 0;
 	try {
@@ -43,7 +48,7 @@ async function* coalesceThinkingDeltas(source, options = {}) {
 			if (!pending) {
 				const result = await next;
 				if (result.done) break;
-				next = iterator.next();
+				next = readNext();
 				if (!isThinkingDelta(result.value)) {
 					yield result.value;
 					continue;
@@ -68,7 +73,7 @@ async function* coalesceThinkingDeltas(source, options = {}) {
 				pending = void 0;
 				break;
 			}
-			next = iterator.next();
+			next = readNext();
 			const event = result.value;
 			if (!isThinkingDelta(event) || !belongsToSameThinkingStream(pending, event)) {
 				yield pending;

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -274,17 +274,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
     };
     stt: unknown;
     tts: unknown;
-    voice: {
-        languageMode?: "manual" | "auto";
-        language?: "en" | "zh";
-        input?: {
-            refinement?: {
-                mode: "off" | "custom" | "punctuation" | "light";
-                model?: string;
-                customInstruction?: string;
-            };
-        };
-    };
+    voice: unknown;
     tools: {
         web: {
             region: "cn" | "global" | null;