@xopcai/xopc 0.0.286 → 0.0.291

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

@@ -1,262 +1,271 @@
-import "./voice-audio.js";
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+import { init_voice_catalog } from "./voice-catalog.js";
+import { init_voice_audio } from "./voice-audio.js";
 import { z } from "zod";
-const VOICE_REALTIME_WS_PATH = "/api/voice/realtime/v3/ws";
-const VOICE_REALTIME_PROXY_WS_PATH = "/api/realtime/v1/ws?transport=voice-v3";
-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 voiceModeSchema = z.enum(["natural", "assistant"]);
-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(),
-	defaultMode: voiceModeSchema,
-	omni: voiceProviderRouteSchema.nullable(),
-	stt: voiceProviderRouteSchema.nullable(),
-	tts: voiceProviderRouteSchema.extend({ voice: z.string().optional() }).nullable(),
-	capabilities: z.strictObject({
-		dictation: availabilitySchema,
-		assistant: availabilitySchema,
-		natural: availabilitySchema,
-		languages: z.array(voiceLanguageSchema),
-		bargeIn: z.boolean(),
-		mediaTransports: z.tuple([z.literal("websocket-pcm")])
-	})
-});
-const createVoiceSessionRequestSchema = z.strictObject({
-	purpose: voicePurposeSchema,
-	mode: voiceModeSchema.optional(),
-	conversationId: z.string().min(1).max(512).optional(),
-	language: voiceLanguageSchema.optional(),
-	supportedProtocolVersions: z.tuple([z.literal(3)]),
-	mediaPreferences: z.tuple([z.literal("websocket-pcm")])
-}).superRefine((value, context) => {
-	if (value.purpose === "conversation" && !value.conversationId) context.addIssue({
-		code: "custom",
-		path: ["conversationId"],
-		message: "conversationId is required for conversation"
+//#region packages/realtime-protocol/src/voice.ts
+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);
+}
+var VOICE_REALTIME_WS_PATH, VOICE_REALTIME_PROXY_WS_PATH, VOICE_REALTIME_MAX_BINARY_FRAME_BYTES, VOICE_REALTIME_START_TIMEOUT_MS, VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, idSchema, timestampSchema, voicePurposeSchema, voiceModeSchema, voiceInputModeSchema, voiceLanguageSchema, voicePcmFormatSchema, voiceProviderRouteSchema, voiceRouteSchema, availabilitySchema, createVoiceSessionRequestSchema, clientEnvelope, voiceClientMessageSchema, transcriptPayloadSchema, serverEnvelope;
+var init_voice = __esmMin((() => {
+	init_voice_catalog();
+	init_voice_audio();
+	VOICE_REALTIME_WS_PATH = "/api/voice/realtime/v3/ws";
+	VOICE_REALTIME_PROXY_WS_PATH = "/api/realtime/v1/ws?transport=voice-v3";
+	VOICE_REALTIME_MAX_BINARY_FRAME_BYTES = 64 * 1024;
+	VOICE_REALTIME_START_TIMEOUT_MS = 1e4;
+	VOICE_REALTIME_HEARTBEAT_INTERVAL_MS = 15e3;
+	idSchema = z.uuid();
+	timestampSchema = z.number().int().nonnegative();
+	voicePurposeSchema = z.enum(["dictation", "conversation"]);
+	voiceModeSchema = z.enum(["natural", "assistant"]);
+	voiceInputModeSchema = z.literal("server_vad");
+	voiceLanguageSchema = z.enum(["zh", "en"]);
+	voicePcmFormatSchema = z.strictObject({
+		encoding: z.literal("pcm_s16le"),
+		sampleRate: z.union([z.literal(16e3), z.literal(24e3)]),
+		channels: z.literal(1)
 	});
-	if (value.purpose !== "conversation" && value.mode !== void 0) context.addIssue({
-		code: "custom",
-		path: ["mode"],
-		message: "mode is only supported for conversation"
+	voiceProviderRouteSchema = z.strictObject({
+		provider: z.string().min(1).max(100),
+		model: z.string().min(1).max(200),
+		managed: z.boolean()
 	});
-});
-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(3),
-	connectionEpoch: z.number().int().positive(),
-	purpose: voicePurposeSchema,
-	mode: voiceModeSchema.optional(),
-	inputMode: voiceInputModeSchema,
-	bargeIn: z.boolean(),
-	inputFormat: voicePcmFormatSchema,
-	media: z.strictObject({
-		transport: z.literal("websocket-pcm"),
-		codec: z.literal("pcm_s16le"),
-		frameDurationMs: z.literal(20)
-	}),
-	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(3),
-	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.stop_playback", z.strictObject({ responseId: z.string().min(1).max(160) })),
-	clientEnvelope("task.cancel", z.strictObject({ taskId: z.string().min(1).max(160) })),
-	clientEnvelope("response.audio.played", z.strictObject({
-		responseId: z.string().min(1).max(160),
-		playedDurationMs: z.number().int().nonnegative().max(36e5)
-	})),
-	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(3),
-	eventId: idSchema,
-	seq: z.number().int().positive(),
-	type: z.literal(type),
-	sentAt: timestampSchema,
-	sessionId: idSchema,
-	payload
-});
-z.discriminatedUnion("type", [
-	serverEnvelope("session.ready", z.strictObject({
+	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
+		})
+	]);
+	availabilitySchema = z.strictObject({
+		available: z.boolean(),
+		reasonCode: z.enum(["VOICE_DISABLED", "PROVIDER_UNAVAILABLE"]).optional()
+	});
+	z.object({
+		enabled: z.boolean(),
+		defaultMode: voiceModeSchema,
+		omni: voiceProviderRouteSchema.nullable(),
+		stt: voiceProviderRouteSchema.nullable(),
+		tts: voiceProviderRouteSchema.extend({ voice: z.string().optional() }).nullable(),
+		capabilities: z.strictObject({
+			dictation: availabilitySchema,
+			assistant: availabilitySchema,
+			natural: availabilitySchema,
+			languages: z.array(voiceLanguageSchema),
+			bargeIn: z.boolean(),
+			mediaTransports: z.tuple([z.literal("websocket-pcm")])
+		})
+	});
+	createVoiceSessionRequestSchema = z.strictObject({
 		purpose: voicePurposeSchema,
 		mode: voiceModeSchema.optional(),
+		conversationId: z.string().min(1).max(512).optional(),
+		language: voiceLanguageSchema.optional(),
+		supportedProtocolVersions: z.tuple([z.literal(3)]),
+		mediaPreferences: z.tuple([z.literal("websocket-pcm")])
+	}).superRefine((value, context) => {
+		if (value.purpose === "conversation" && !value.conversationId) context.addIssue({
+			code: "custom",
+			path: ["conversationId"],
+			message: "conversationId is required for conversation"
+		});
+		if (value.purpose !== "conversation" && value.mode !== void 0) context.addIssue({
+			code: "custom",
+			path: ["mode"],
+			message: "mode 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(3),
 		connectionEpoch: z.number().int().positive(),
+		purpose: voicePurposeSchema,
+		mode: voiceModeSchema.optional(),
 		inputMode: voiceInputModeSchema,
+		bargeIn: z.boolean(),
 		inputFormat: voicePcmFormatSchema,
 		media: z.strictObject({
 			transport: z.literal("websocket-pcm"),
 			codec: z.literal("pcm_s16le"),
 			frameDurationMs: z.literal(20)
 		}),
-		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("turn.decision", z.strictObject({
-		turnId: z.string().min(1).max(160),
-		disposition: z.enum([
-			"complete",
-			"incomplete",
-			"backchannel",
-			"wait"
-		]),
-		confidence: z.number().min(0).max(1),
-		source: z.enum([
-			"provider",
-			"semantic",
-			"heuristic"
-		]),
-		committed: z.boolean()
-	})),
-	serverEnvelope("turn.committed", z.strictObject({ turnId: z.string().min(1).max(160) })),
-	serverEnvelope("response.created", z.strictObject({ responseId: z.string().min(1).max(160) })),
-	serverEnvelope("task.created", z.strictObject({
-		responseId: z.string().min(1).max(160),
-		taskId: z.string().min(1).max(160)
-	})),
-	serverEnvelope("task.activity", z.strictObject({
-		taskId: 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("task.done", z.strictObject({
-		taskId: z.string().min(1).max(160),
-		status: z.enum([
-			"completed",
-			"failed",
-			"cancelled",
-			"suspended"
-		])
-	})),
-	serverEnvelope("response.clarification", z.strictObject({
-		responseId: z.string().min(1).max(160),
-		requestId: z.string().min(1).max(160),
-		kind: z.enum(["input", "approval"]),
-		question: z.string().min(1).max(8e3),
-		choices: z.array(z.string().max(1e3)).max(20).optional(),
-		suggestedAnswer: z.string().max(1e3).optional(),
-		version: z.number().int().positive(),
-		createdAt: z.number().nonnegative(),
-		expiresAt: z.number().nonnegative().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);
-}
+		limits: z.strictObject({
+			maxBinaryFrameBytes: z.literal(VOICE_REALTIME_MAX_BINARY_FRAME_BYTES),
+			maxSessionMs: z.number().int().positive(),
+			idleTimeoutMs: z.number().int().positive()
+		}),
+		route: voiceRouteSchema
+	});
+	clientEnvelope = (type, payload) => z.strictObject({
+		protocolVersion: z.literal(3),
+		messageId: idSchema,
+		type: z.literal(type),
+		sentAt: timestampSchema,
+		payload
+	});
+	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.stop_playback", z.strictObject({ responseId: z.string().min(1).max(160) })),
+		clientEnvelope("task.cancel", z.strictObject({ taskId: z.string().min(1).max(160) })),
+		clientEnvelope("response.audio.played", z.strictObject({
+			responseId: z.string().min(1).max(160),
+			playedDurationMs: z.number().int().nonnegative().max(36e5)
+		})),
+		clientEnvelope("session.stop", z.strictObject({ reason: z.enum([
+			"user_finished",
+			"surface_closed",
+			"replaced"
+		]) })),
+		clientEnvelope("session.ping", z.strictObject({}))
+	]);
+	transcriptPayloadSchema = z.strictObject({
+		utteranceId: z.string().min(1).max(160),
+		revision: z.number().int().positive(),
+		text: z.string().max(32 * 1024),
+		language: voiceLanguageSchema.optional()
+	});
+	serverEnvelope = (type, payload) => z.strictObject({
+		protocolVersion: z.literal(3),
+		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,
+			mode: voiceModeSchema.optional(),
+			connectionEpoch: z.number().int().positive(),
+			inputMode: voiceInputModeSchema,
+			inputFormat: voicePcmFormatSchema,
+			media: z.strictObject({
+				transport: z.literal("websocket-pcm"),
+				codec: z.literal("pcm_s16le"),
+				frameDurationMs: z.literal(20)
+			}),
+			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("turn.decision", z.strictObject({
+			turnId: z.string().min(1).max(160),
+			disposition: z.enum([
+				"complete",
+				"incomplete",
+				"backchannel",
+				"wait"
+			]),
+			confidence: z.number().min(0).max(1),
+			source: z.enum([
+				"provider",
+				"semantic",
+				"heuristic"
+			]),
+			committed: z.boolean()
+		})),
+		serverEnvelope("turn.committed", z.strictObject({ turnId: z.string().min(1).max(160) })),
+		serverEnvelope("response.created", z.strictObject({ responseId: z.string().min(1).max(160) })),
+		serverEnvelope("task.created", z.strictObject({
+			responseId: z.string().min(1).max(160),
+			taskId: z.string().min(1).max(160)
+		})),
+		serverEnvelope("task.activity", z.strictObject({
+			taskId: 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("task.done", z.strictObject({
+			taskId: z.string().min(1).max(160),
+			status: z.enum([
+				"completed",
+				"failed",
+				"cancelled",
+				"suspended"
+			])
+		})),
+		serverEnvelope("response.clarification", z.strictObject({
+			responseId: z.string().min(1).max(160),
+			requestId: z.string().min(1).max(160),
+			kind: z.enum(["input", "approval"]),
+			question: z.string().min(1).max(8e3),
+			choices: z.array(z.string().max(1e3)).max(20).optional(),
+			suggestedAnswer: z.string().max(1e3).optional(),
+			version: z.number().int().positive(),
+			createdAt: z.number().nonnegative(),
+			expiresAt: z.number().nonnegative().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) }))
+	]);
+}));
 //#endregion
-export { VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, VOICE_REALTIME_MAX_BINARY_FRAME_BYTES, VOICE_REALTIME_PROXY_WS_PATH, VOICE_REALTIME_START_TIMEOUT_MS, VOICE_REALTIME_WS_PATH, createVoiceSessionRequestSchema, parseVoiceClientJsonFrame, parseVoiceClientMessage };
+init_voice();
+export { VOICE_REALTIME_HEARTBEAT_INTERVAL_MS, VOICE_REALTIME_MAX_BINARY_FRAME_BYTES, VOICE_REALTIME_PROXY_WS_PATH, VOICE_REALTIME_START_TIMEOUT_MS, VOICE_REALTIME_WS_PATH, createVoiceSessionRequestSchema, init_voice, parseVoiceClientJsonFrame, parseVoiceClientMessage };

package/dist/src/agent/agent-manager.d.ts

@@ -28,6 +28,7 @@ export interface SkillCatalogEntry {
     directoryId: string;
     name: string;
     description: string;
+    localizations?: Skill['localizations'];
     category?: string;
     source: Skill['source'];
     origin: Skill['origin']['id'];

package/dist/src/agent/agent-manager.js

@@ -7,17 +7,17 @@ import { getInteractionState } from "../storage/sqlite/interaction-state-reposit
 import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { expandWorkspacePathString, init_workspace_path } from "../config/workspace-path.js";
 import { init_agent_scope, resolveAgentProfileDir } from "./agent-scope.js";
+import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
+import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getConversationRouting } from "../storage/sqlite/conversation-repository.js";
 import { init_session_key } from "../routing/session-key.js";
-import { resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
-import { init_paths, resolveBundledSkillsDir } from "../config/paths.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../auth/sync-provider-auth.js";
-import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { getApiKeySync, getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
+import { applyConfigOverrides } from "../config/runtime-overrides.js";
+import { resolveEffectiveAgentProfile, resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { extractTextContent } from "./context/workspace.js";
 import { buildExecutionScopeContextForPrompt } from "./context/execution-scope.js";
 import { clearBootstrapSnapshot } from "./bootstrap/bootstrap-cache.js";
@@ -483,6 +483,7 @@ var AgentManager = class {
 			directoryId,
 			name: s.name,
 			description: s.description,
+			...s.localizations ? { localizations: s.localizations } : {},
 			category: s.category,
 			source: s.source,
 			origin: s.origin.id,

package/dist/src/agent/background-review/run-background-review.js

@@ -4,10 +4,10 @@ import { finishContextExtractionRun } from "../../storage/sqlite/context-extract
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
-import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { getApiKeySync, init_providers, resolveModel } from "../../providers/index.js";
 import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
+import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { extractTextContent } from "../context/workspace.js";
 import { listUserAssertions } from "../../user-model/repository.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";

package/dist/src/agent/embedded/model-runtime.js

@@ -1,6 +1,6 @@
 import { init_paths, resolveModelsJsonPath } from "../../config/paths.js";
-import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
+import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { XopcModelCredentialStore, init_model_credential_store } from "../../auth/model-credential-store.js";
 import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "../../providers/register-bundled-oauth-flows.js";
 import { init_register_runtime_providers, registerRuntimeProviders } from "../../providers/register-runtime-providers.js";

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

@@ -2,8 +2,8 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-outcome.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";

package/dist/src/agent/embedded/run-turn.js

@@ -1,7 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { getClarificationResumeInput, isClarificationSuspended } from "../../storage/sqlite/clarification-wait-repository.js";
+import { getClarification, getClarificationResumeInput, isClarificationSuspended } from "../../storage/sqlite/clarification-wait-repository.js";
 import { getConnectionResumeInput, init_connection_wait_repository, isConnectionSuspended } from "../../storage/sqlite/connection-wait-repository.js";
+import { isComputerControlActive, stopComputerControl } from "../../computer/control-guard.js";
 import { EmbeddedRunConflictError, abortEmbeddedRun, acquireEmbeddedRunLease, queueEmbeddedSteer } from "./runs.js";
 import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
 import { isContextOverflowError } from "../orchestration/context-overflow.js";
@@ -282,6 +283,13 @@ async function runXopcEmbeddedTurn(params) {
 		let clarificationStopped = false;
 		params.turnPolicy?.reset();
 		session.agent.beforeToolCall = async (context, signal) => {
+			const resume = getClarificationResumeInput(conversationId, runId);
+			const wait = resume?.payload?.waitId ? getClarification(resume.payload.waitId) : void 0;
+			if (wait?.approvalKey?.startsWith("computer:") && wait.answer !== "已在桌面端处理，继续") await stopComputerControl(conversationId);
+			if (isComputerControlActive(conversationId) && !["computer_use", "clarify"].includes(context.toolCall.name)) return {
+				block: true,
+				reason: "A desktop-control lease is active. Only computer_use and clarification are admitted until it is released. Never use shell, browser or raw MCP to bypass a desktop refusal."
+			};
 			if (connectionStopped) return {
 				block: true,
 				reason: "Waiting for the user to connect an app.",