@xopcai/xopc 0.0.241 → 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/agent-manager.js

@@ -241,6 +241,7 @@ var AgentManager = class {
 			getConfig: () => this.mergedConfig(),
 			getPrimaryModel: () => this.resolveModelStringToModel(this.pickDefaultModelRef()),
 			getMemoryManager: () => this.getCurrentWorkspaceRuntime().memoryManager,
+			getSkillManager: () => this.getCurrentWorkspaceRuntime().skillManager,
 			getSessionStore: this.config.getSessionStore,
 			gatewayClarify: this.config.gatewayClarify,
 			getAutomationService: this.config.getAutomationService,

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/agent/skills/installer.d.ts

@@ -13,6 +13,7 @@ export interface InstallContext {
     installSpec: SkillInstallSpec;
     timeoutMs: number;
 }
+export declare function skillEnvironmentId(skill: Pick<SkillEntry['skill'], 'name' | 'filePath'>, installSpec: SkillInstallSpec): string;
 /**
  * Check if a binary exists
  */

package/dist/src/agent/skills/installer.js

@@ -19,6 +19,13 @@ import { execFile } from "child_process";
 init_logger();
 const execFileAsync = promisify(execFile);
 const log = createLogger("SkillInstaller");
+function skillEnvironmentId(skill, installSpec) {
+	return createHash("sha256").update(JSON.stringify({
+		skill: skill.name,
+		path: skill.filePath,
+		installSpec
+	})).digest("hex").slice(0, 24);
+}
 /**
 * Check if a binary exists
 */
@@ -202,11 +209,7 @@ async function installSkill(ctx) {
 	if (installSpec.kind === "go") {
 		if (!hasBinary("go")) return createInstallFailure({ message: "go not installed — install it explicitly from https://go.dev/doc/install" });
 	}
-	const environmentId = createHash("sha256").update(JSON.stringify({
-		skill: ctx.skillEntry.skill.name,
-		path: ctx.skillEntry.skill.filePath,
-		installSpec
-	})).digest("hex").slice(0, 24);
+	const environmentId = skillEnvironmentId(ctx.skillEntry.skill, installSpec);
 	const environmentDir = join(ctx.stateDir, "tools", "environments", "skills", environmentId);
 	await mkdir(environmentDir, { recursive: true });
 	if ([
@@ -285,4 +288,4 @@ async function installSkill(ctx) {
 	});
 }
 //#endregion
-export { findInstallSpec, hasBinary, installSkill, resolveBrewExecutable };
+export { findInstallSpec, hasBinary, installSkill, resolveBrewExecutable, skillEnvironmentId };

package/dist/src/agent/tools/factory.d.ts

@@ -44,6 +44,8 @@ export interface ToolFactoryDeps {
     getPrimaryModel?: () => Model<Api>;
     /** Memory orchestration (prefetch/sync + external tools). */
     getMemoryManager?: () => MemoryManager;
+    /** Skill runtime for the current workspace/session. */
+    getSkillManager?: () => SkillManager;
     /** Session store for `session_search`. */
     getSessionStore?: () => SessionStore;
     /** When set (gateway webchat), enables the `clarify` tool. */

package/dist/src/agent/tools/factory.js

@@ -9,6 +9,7 @@ import { wrapToolsWithProtection } from "./executor.js";
 import { buildRuntimeEnvironment } from "../../runtime-tools/environment.js";
 import { createDefaultExternalToolGatewayTools } from "../external-tools/index.js";
 import { createReadFileTool } from "./read.js";
+import { skillEnvironmentId } from "../skills/installer.js";
 import { createWriteFileTool } from "./write.js";
 import { createListDirTool } from "./list-dir.js";
 import { createPublishArtifactsTool } from "./publish-artifacts.js";
@@ -81,10 +82,13 @@ var AgentToolsFactory = class {
 	prepareRuntimeEnv = async (baseEnv) => {
 		const config = this.deps.getConfig?.();
 		if (!config) return baseEnv;
+		const indexing = this.deps.getSkillIndexingContext?.();
+		const skillEnvironmentIds = this.deps.getSkillManager?.()?.getEnabledSkillsForAgentSession(indexing).flatMap((skill) => (skill.metadata.install ?? []).map((installSpec) => skillEnvironmentId(skill, installSpec)));
 		return (await buildRuntimeEnvironment({
 			stateDir: resolveStateDir(),
 			config: config.runtimeTools,
-			baseEnv
+			baseEnv,
+			skillEnvironmentIds
 		})).env;
 	};
 	browserReadinessKey() {

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>;