@openclaw/voice-call 2026.10.2 → 2026.10.5-beta.2

package/dist/index.js

@@ -1,17 +1,18 @@
 import { definePluginEntry } from "./api.js";
 import { VOICE_CALL_CLI_DESCRIPTOR } from "./cli-output-mode.js";
-import { i as resolveVoiceCallConfig, t as VoiceCallConfigSchema, u as validateProviderConfig } from "./.setup/config-CX9J-053.mjs";
-import { t as createVoiceCallRuntime } from "./.setup/runtime-entry-CbSKxSKk.mjs";
+import { g as CallBriefSchema, i as resolveVoiceCallConfig, t as VoiceCallConfigSchema, u as validateProviderConfig } from "./.setup/config-CsrGuamE.mjs";
+import { C as TerminalStates, t as createVoiceCallRuntime } from "./.setup/runtime-entry-STjFmi_B.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolvePluginServiceScheduler } from "openclaw/plugin-sdk/runtime";
-import { asNonArrayRecord, asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asNonArrayRecord, asOptionalRecord, isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
-import { Type } from "typebox";
 import { resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { randomUUID } from "node:crypto";
+import { Type } from "typebox";
 //#region extensions/voice-call/src/command-service.ts
 var VoiceCallCommandInputError = class extends Error {};
 function toVoiceCallStatus(call) {
@@ -76,9 +77,12 @@ function createVoiceCallCommandService(ensureRuntime) {
 		async initiate(params, missingToMessage = "to required") {
 			const rt = await ensureRuntime();
 			const to = requireInput(params.to ?? rt.config.toNumber, missingToMessage);
+			const parsedBrief = CallBriefSchema.optional().safeParse(params.brief);
+			if (!parsedBrief.success) throw new VoiceCallCommandInputError(`Invalid brief: ${parsedBrief.error.message}`);
 			const result = await rt.manager.initiateCall(to, params.sessionKey, {
 				message: params.message,
 				mode: params.mode,
+				brief: parsedBrief.data,
 				dtmfSequence: params.dtmfSequence,
 				...params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {},
 				...params.agentId ? { agentId: params.agentId } : {}
@@ -92,6 +96,30 @@ function createVoiceCallCommandService(ensureRuntime) {
 		async continueCall(callId, message) {
 			return await (await prepareContinue(callId, message)).run();
 		},
+		async steer(params) {
+			const callId = requireInput(params.callId, "callId and message required");
+			const message = requireInput(params.message?.trim(), "callId and message required");
+			if (message.length > 500) throw new VoiceCallCommandInputError("Steering message must be at most 500 characters");
+			const rt = await ensureRuntime();
+			params.assertCurrent?.();
+			const call = rt.manager.getCall(callId);
+			if (!call || TerminalStates.has(call.state)) throw new VoiceCallCommandInputError("Call is not active");
+			const requester = call.metadata?.requesterSessionKey;
+			if (!params.operator && (!params.requesterSessionKey || requester !== params.requesterSessionKey)) throw new VoiceCallCommandInputError("Only the requester session or an operator may steer this call");
+			if (!rt.config.realtime.enabled) throw new VoiceCallCommandInputError("Steering requires an active realtime call");
+			await rt.manager.updateCallMetadata(call, (metadata) => ({
+				...metadata,
+				ownerInstructions: [...Array.isArray(metadata?.ownerInstructions) ? metadata.ownerInstructions : [], message].slice(-8)
+			}), {
+				persist: true,
+				assertCurrent: params.assertCurrent
+			});
+			params.assertCurrent?.();
+			if (rt.manager.getCall(callId) !== call || TerminalStates.has(call.state)) throw new VoiceCallCommandInputError("Call is not active");
+			const instruction = params.mode === "say" ? `Owner instruction for this call: say this now, verbatim, then listen. Answer: ${JSON.stringify(message)}` : `Owner instruction for this call: ${JSON.stringify(message)}. Apply this guidance from now on while respecting the call brief's disclosure and approval limits.`;
+			requireSuccess(rt.webhookServer.speakRealtime(callId, instruction), "Steering failed");
+			return { success: true };
+		},
 		async speak(params) {
 			const request = await resolveCallMessage(params.callId, params.message);
 			if (request.rt.config.realtime.enabled) {
@@ -111,9 +139,11 @@ function createVoiceCallCommandService(ensureRuntime) {
 			requireSuccess(await (await ensureRuntime()).manager.sendDtmf(resolvedCallId, resolvedDigits), "dtmf failed");
 			return { success: true };
 		},
-		async endCall(callId) {
+		async endCall(callId, execution) {
 			const resolvedCallId = requireInput(callId, "callId required");
-			requireSuccess(await (await ensureRuntime()).manager.endCall(resolvedCallId), "end failed");
+			const rt = execution?.runtime ?? await ensureRuntime();
+			execution?.assertAuthority?.();
+			requireSuccess(await rt.manager.endCall(resolvedCallId), "end failed");
 			return { success: true };
 		},
 		async status(callId) {
@@ -193,27 +223,62 @@ function createVoiceCallContinueOperationStore(params) {
 	};
 }
 //#endregion
-//#region extensions/voice-call/index.ts
-const VOICE_CALL_WRITE_METHOD_SCOPE = { scope: "operator.write" };
-const VOICE_CALL_READ_METHOD_SCOPE = { scope: "operator.read" };
-const voiceCallConfigSchema = { parse(value) {
-	const config = asOptionalRecord(value) ?? {};
-	const enabled = typeof config.enabled === "boolean" ? config.enabled : true;
-	return VoiceCallConfigSchema.parse({
-		...config,
-		enabled,
-		provider: config.provider ?? (enabled ? "mock" : void 0)
-	});
-} };
+//#region extensions/voice-call/src/tool-call-scope.ts
+async function resolveActiveVoiceCallToolScope(params) {
+	if (!isRecord(params.binding)) return;
+	const binding = params.binding;
+	const callId = normalizeOptionalString(binding.callId);
+	if (binding.kind !== "active-call" || !callId) return;
+	if (params.action !== "end_call") throw new VoiceCallCommandInputError("This realtime consult may only end_call.");
+	const requestedCallId = normalizeOptionalString(params.requestedCallId);
+	if (requestedCallId && requestedCallId !== callId) throw new VoiceCallCommandInputError(`This realtime consult is bound to call ${callId}.`);
+	params.assertAuthority();
+	params.signal?.throwIfAborted();
+	const activeCall = await params.runtime.manager.getCallForStream(callId);
+	if (!activeCall || activeCall.callId !== callId) throw new VoiceCallCommandInputError("The bound realtime call is no longer active.");
+	return {
+		callId,
+		execution: {
+			runtime: params.runtime,
+			assertAuthority: params.assertAuthority
+		}
+	};
+}
+//#endregion
+//#region extensions/voice-call/src/tool-schema.ts
+const VoiceCallBriefToolSchema = Type.Object({
+	task: Type.Optional(Type.String({ maxLength: 2e3 })),
+	context: Type.Optional(Type.String({ maxLength: 4e3 })),
+	language: Type.Optional(Type.String({ maxLength: 100 })),
+	identity: Type.Optional(Type.Union([Type.String({ maxLength: 500 }), Type.Object({
+		introduction: Type.String({ maxLength: 500 }),
+		disclose: Type.Optional(Type.Union([Type.Literal("volunteer"), Type.Literal("when-asked")]))
+	}, { additionalProperties: false })])),
+	disclosures: Type.Optional(Type.Array(Type.String({ maxLength: 500 }), { maxItems: 20 })),
+	approvals: Type.Optional(Type.String({ maxLength: 2e3 })),
+	voicemailMessage: Type.Optional(Type.String({ maxLength: 1e3 })),
+	successCriteria: Type.Optional(Type.String({ maxLength: 1e3 })),
+	maxDurationSeconds: Type.Optional(Type.Integer({ minimum: 1 }))
+}, { additionalProperties: false });
 const VoiceCallToolSchema = Type.Union([
 	Type.Object({
 		action: Type.Literal("initiate_call"),
+		brief: Type.Optional(VoiceCallBriefToolSchema),
 		to: Type.Optional(Type.String({ description: "Call target" })),
 		message: Type.String({ description: "Intro message" }),
 		mode: Type.Optional(Type.Union([Type.Literal("notify"), Type.Literal("conversation")])),
 		sessionKey: Type.Optional(Type.String({ description: "OpenClaw session key for the call" })),
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	}),
+	Type.Object({
+		action: Type.Literal("steer_call"),
+		callId: Type.String({ description: "Exact active call ID" }),
+		message: Type.String({
+			maxLength: 500,
+			description: "Owner instruction for the live call"
+		}),
+		mode: Type.Optional(Type.Union([Type.Literal("say"), Type.Literal("guidance")]))
+	}),
 	Type.Object({
 		action: Type.Literal("continue_call"),
 		callId: Type.String({ description: "Call ID" }),
@@ -246,6 +311,19 @@ const VoiceCallToolSchema = Type.Union([
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	})
 ]);
+//#endregion
+//#region extensions/voice-call/index.ts
+const VOICE_CALL_WRITE_METHOD_SCOPE = { scope: "operator.write" };
+const VOICE_CALL_READ_METHOD_SCOPE = { scope: "operator.read" };
+const voiceCallConfigSchema = { parse(value) {
+	const config = asOptionalRecord(value) ?? {};
+	const enabled = typeof config.enabled === "boolean" ? config.enabled : true;
+	return VoiceCallConfigSchema.parse({
+		...config,
+		enabled,
+		provider: config.provider ?? (enabled ? "mock" : void 0)
+	});
+} };
 function isCliOnlyProcess() {
 	return process.env.OPENCLAW_CLI === "1" && !process.argv.slice(2).includes("gateway");
 }
@@ -287,9 +365,10 @@ var voice_call_default = definePluginEntry({
 		const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
 		const validation = validateProviderConfig(config);
 		const runtimeCoordinator = getVoiceCallRuntimeCoordinator();
-		const runtimeRegistration = api.registrationMode !== "full" && runtimeCoordinator.current ? runtimeCoordinator.current : {
+		const runtimeRegistration = {
 			epoch: ++runtimeCoordinator.epochCounter,
-			generation: { retired: false }
+			generation: { retired: false },
+			ensureRuntime: () => ensureRegisteredRuntime()
 		};
 		const continueOperationStore = createVoiceCallContinueOperationStore({
 			config,
@@ -300,6 +379,7 @@ var voice_call_default = definePluginEntry({
 			activateRuntimeGeneration(runtimeGeneration);
 			if (!config.enabled) throw new Error("Voice call disabled in plugin config");
 			if (!validation.valid) throw new Error(validation.errors.join("; "));
+			if ((config.reports.enabled || config.live.transcript) && !runtimeGeneration.runInServiceContext) throw new VoiceCallRuntimeLifecycleError("Voice call requester reporting requires service startup");
 			while (true) {
 				activateRuntimeGeneration(runtimeGeneration);
 				const slot = runtimeCoordinator.slot;
@@ -334,24 +414,26 @@ var voice_call_default = definePluginEntry({
 				}
 				const scheduler = runtimeGeneration.scheduler;
 				if (!scheduler || scheduler.signal.aborted) throw new VoiceCallRuntimeLifecycleError("Voice call service is not running; start the Gateway and retry");
-				const startingSlot = {
+				const runtimePromise = createVoiceCallRuntime({
+					scheduler,
+					config,
+					coreConfig: api.config,
+					fullConfig: api.config,
+					agentRuntime: api.runtime.agent,
+					stateRuntime: api.runtime.state,
+					ttsRuntime: api.runtime.tts,
+					deliveryRuntime: api.runtime,
+					runInServiceContext: runtimeGeneration.runInServiceContext,
+					logger: api.logger
+				});
+				runtimeCoordinator.slot = {
 					state: "starting",
 					owner: runtimeGeneration,
-					promise: createVoiceCallRuntime({
-						scheduler,
-						config,
-						coreConfig: api.config,
-						fullConfig: api.config,
-						agentRuntime: api.runtime.agent,
-						stateRuntime: api.runtime.state,
-						ttsRuntime: api.runtime.tts,
-						logger: api.logger
-					})
+					promise: runtimePromise
 				};
-				runtimeCoordinator.slot = startingSlot;
 			}
 		};
-		const ensureRuntime = async (runtimeGeneration = runtimeRegistration.generation) => {
+		const ensureRegisteredRuntime = async (runtimeGeneration = runtimeRegistration.generation) => {
 			try {
 				const runtime = await ensureRuntimeForGeneration(runtimeGeneration);
 				runtimeGeneration.serviceHealth?.clearFailure();
@@ -361,6 +443,7 @@ var voice_call_default = definePluginEntry({
 				throw err;
 			}
 		};
+		const ensureRuntime = () => (runtimeCoordinator.current ?? runtimeRegistration).ensureRuntime();
 		const commands = createVoiceCallCommandService(ensureRuntime);
 		const registerGatewayCommand = (method, handler, scope) => {
 			api.registerGatewayMethod(method, async (options) => {
@@ -380,7 +463,24 @@ var voice_call_default = definePluginEntry({
 				message,
 				mode: params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0,
 				sessionKey: normalizeOptionalString(params?.sessionKey),
-				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
+				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey),
+				brief: params?.brief
+			});
+		}, VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.steer", ({ params, client, hasCurrentClientAuthority, signal }) => {
+			const scopes = client?.connect.scopes ?? [];
+			const operator = scopes.includes("operator.write") || scopes.includes("operator.admin");
+			if (params.mode !== void 0 && params.mode !== "say" && params.mode !== "guidance") throw new VoiceCallCommandInputError("mode must be say or guidance");
+			return commands.steer({
+				callId: normalizeOptionalString(params.callId),
+				message: normalizeOptionalString(params.message),
+				mode: params.mode,
+				requesterSessionKey: client?.internal?.agentToolCaller?.sessionKey,
+				operator,
+				assertCurrent: () => {
+					signal?.throwIfAborted();
+					if (hasCurrentClientAuthority && !hasCurrentClientAuthority()) throw new VoiceCallCommandInputError("Steering caller authority expired");
+				}
 			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
 		registerGatewayCommand("voicecall.continue", ({ params }) => commands.continueCall(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.message)), VOICE_CALL_WRITE_METHOD_SCOPE);
@@ -414,68 +514,90 @@ var voice_call_default = definePluginEntry({
 				dtmfSequence: normalizeOptionalString(params?.dtmfSequence),
 				sessionKey: normalizeOptionalString(params?.sessionKey),
 				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey),
+				brief: params?.brief,
 				agentId: normalizedAgentId
 			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerTool((toolContext) => ({
-			name: "voice_call",
-			label: "Voice Call",
-			description: "Make phone calls and have voice conversations via the voice-call plugin.",
-			parameters: VoiceCallToolSchema,
-			async execute(_toolCallId, params) {
-				const rawParams = asNonArrayRecord(params);
-				const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
-				const contextAgentId = normalizeOptionalString(toolContext.agentId) ?? parseAgentSessionKey(requesterSessionKey)?.agentId;
-				const agentId = contextAgentId ? normalizeAgentId(contextAgentId) : void 0;
-				try {
-					await ensureRuntime();
-					if (typeof rawParams.action === "string") switch (rawParams.action) {
-						case "initiate_call": {
-							const message = normalizeOptionalString(rawParams.message);
-							if (!message) throw new VoiceCallCommandInputError("message required");
-							return jsonResult(await commands.initiate({
-								to: normalizeOptionalString(rawParams.to),
-								message,
-								dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
-								mode: rawParams.mode === "notify" || rawParams.mode === "conversation" ? rawParams.mode : void 0,
-								sessionKey: normalizeOptionalString(rawParams.sessionKey),
-								agentId,
-								requesterSessionKey
+		api.registerTool((toolContext) => {
+			const boundRuntimeRegistration = asOptionalRecord(toolContext.toolBindings?.voice_call)?.kind === "active-call" ? runtimeCoordinator.current : void 0;
+			const boundRuntimeGeneration = boundRuntimeRegistration?.generation;
+			const assertActiveCallAuthority = () => {
+				if (!boundRuntimeRegistration || !boundRuntimeGeneration || runtimeCoordinator.current !== boundRuntimeRegistration || boundRuntimeRegistration.generation !== boundRuntimeGeneration || boundRuntimeGeneration.retired) throw new VoiceCallCommandInputError("The bound realtime call service is no longer active.");
+			};
+			return {
+				name: "voice_call",
+				label: "Voice Call",
+				description: "Make phone calls and have voice conversations via the voice-call plugin.",
+				parameters: VoiceCallToolSchema,
+				async execute(_toolCallId, params, signal) {
+					const rawParams = asNonArrayRecord(params);
+					const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
+					const contextAgentId = normalizeOptionalString(toolContext.agentId) ?? parseAgentSessionKey(requesterSessionKey)?.agentId;
+					const agentId = contextAgentId ? normalizeAgentId(contextAgentId) : void 0;
+					try {
+						const rt = await ensureRuntime();
+						const callScope = await resolveActiveVoiceCallToolScope({
+							action: rawParams.action,
+							binding: toolContext.toolBindings?.voice_call,
+							requestedCallId: rawParams.callId,
+							runtime: rt,
+							assertAuthority: assertActiveCallAuthority,
+							signal
+						});
+						const initiateParams = {
+							to: normalizeOptionalString(rawParams.to),
+							message: normalizeOptionalString(rawParams.message),
+							dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
+							sessionKey: normalizeOptionalString(rawParams.sessionKey),
+							agentId,
+							requesterSessionKey,
+							brief: rawParams.brief
+						};
+						if (typeof rawParams.action === "string") switch (rawParams.action) {
+							case "initiate_call":
+								if (!initiateParams.message) throw new VoiceCallCommandInputError("message required");
+								return jsonResult(await commands.initiate({
+									...initiateParams,
+									mode: rawParams.mode === "notify" || rawParams.mode === "conversation" ? rawParams.mode : void 0
+								}));
+							case "steer_call":
+								if (rawParams.mode !== void 0 && rawParams.mode !== "say" && rawParams.mode !== "guidance") throw new VoiceCallCommandInputError("mode must be say or guidance");
+								return jsonResult(await commands.steer({
+									callId: normalizeOptionalString(rawParams.callId),
+									message: normalizeOptionalString(rawParams.message),
+									mode: rawParams.mode,
+									requesterSessionKey,
+									assertCurrent: () => signal?.throwIfAborted()
+								}));
+							case "continue_call": return jsonResult(await commands.continueCall(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.message)));
+							case "speak_to_user": return jsonResult(await commands.speak({
+								callId: normalizeOptionalString(rawParams.callId),
+								message: normalizeOptionalString(rawParams.message)
 							}));
+							case "send_dtmf": return jsonResult(await commands.sendDtmf(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.digits)));
+							case "end_call":
+								if (!callScope) signal?.throwIfAborted();
+								return jsonResult(await commands.endCall(callScope?.callId ?? normalizeOptionalString(rawParams.callId), callScope?.execution));
+							case "get_status": {
+								const callId = normalizeOptionalString(rawParams.callId);
+								if (!callId) throw new VoiceCallCommandInputError("callId required");
+								return jsonResult(await commands.status(callId));
+							}
 						}
-						case "continue_call": return jsonResult(await commands.continueCall(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.message)));
-						case "speak_to_user": return jsonResult(await commands.speak({
-							callId: normalizeOptionalString(rawParams.callId),
-							message: normalizeOptionalString(rawParams.message)
-						}));
-						case "send_dtmf": return jsonResult(await commands.sendDtmf(normalizeOptionalString(rawParams.callId), normalizeOptionalString(rawParams.digits)));
-						case "end_call": return jsonResult(await commands.endCall(normalizeOptionalString(rawParams.callId)));
-						case "get_status": {
-							const callId = normalizeOptionalString(rawParams.callId);
-							if (!callId) throw new VoiceCallCommandInputError("callId required");
-							return jsonResult(await commands.status(callId));
+						if ((rawParams.mode ?? "call") === "status") {
+							const sid = normalizeOptionalString(rawParams.sid) ?? "";
+							if (!sid) throw new Error("sid required for status");
+							return jsonResult(await commands.status(sid));
 						}
+						return jsonResult(await commands.initiate(initiateParams, "to required for call"));
+					} catch (err) {
+						return jsonResult({ error: formatErrorMessage(err) });
 					}
-					if ((rawParams.mode ?? "call") === "status") {
-						const sid = normalizeOptionalString(rawParams.sid) ?? "";
-						if (!sid) throw new Error("sid required for status");
-						return jsonResult(await commands.status(sid));
-					}
-					return jsonResult(await commands.initiate({
-						to: normalizeOptionalString(rawParams.to),
-						dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
-						message: normalizeOptionalString(rawParams.message),
-						sessionKey: normalizeOptionalString(rawParams.sessionKey),
-						agentId,
-						requesterSessionKey
-					}, "to required for call"));
-				} catch (err) {
-					return jsonResult({ error: formatErrorMessage(err) });
 				}
-			}
-		}));
+			};
+		});
 		api.registerCli(async ({ program }) => {
-			const { registerVoiceCallCli } = await import("./.setup/cli-Cn1leykM.mjs");
+			const { registerVoiceCallCli } = await import("./.setup/cli-dyyK8Upw.mjs");
 			registerVoiceCallCli({
 				program,
 				config,
@@ -501,6 +623,8 @@ var voice_call_default = definePluginEntry({
 						runtimeRegistration.generation = { retired: false };
 					}
 					runtimeRegistration.generation.scheduler = ctx.scheduler;
+					const serviceContext = AsyncLocalStorage.snapshot();
+					runtimeRegistration.generation.runInServiceContext = (run) => serviceContext(run);
 					runtimeRegistration.generation.serviceHealth = ctx.serviceHealth;
 					activateRuntimeGeneration(runtimeRegistration.generation);
 				} catch (err) {
@@ -515,8 +639,7 @@ var voice_call_default = definePluginEntry({
 					api.logger.error(`[voice-call] Runtime not started: ${error.message}`);
 					return;
 				}
-				const startingGeneration = runtimeRegistration.generation;
-				ensureRuntime(startingGeneration).catch((err) => {
+				ensureRegisteredRuntime().catch((err) => {
 					if (err instanceof VoiceCallRuntimeLifecycleError) return;
 					ctx.serviceHealth?.reportFailure(err);
 					api.logger.error(`[voice-call] Failed to start runtime: ${formatErrorMessage(err)}`);

package/dist/runtime-entry.js

@@ -1,2 +1,2 @@
-import { t as createVoiceCallRuntime } from "./.setup/runtime-entry-CbSKxSKk.mjs";
+import { t as createVoiceCallRuntime } from "./.setup/runtime-entry-STjFmi_B.mjs";
 export { createVoiceCallRuntime };

package/dist/setup-api.js

@@ -109,12 +109,13 @@ function migrateVoiceCallPluginConfig(config) {
 	});
 	if (migration.changes.length === 0) return null;
 	const plugins = structuredClone(config.plugins ?? {});
-	const entries = { ...plugins.entries };
-	entries["voice-call"] = {
-		...isRecord(entries["voice-call"]) ? entries["voice-call"] : {},
-		config: migration.config
+	plugins.entries = {
+		...plugins.entries,
+		"voice-call": {
+			...plugins.entries?.["voice-call"],
+			config: migration.config
+		}
 	};
-	plugins.entries = entries;
 	return {
 		config: {
 			...config,
@@ -129,7 +130,7 @@ var setup_api_default = definePluginEntry({
 	name: "Voice Call Setup",
 	description: "Lightweight Voice Call setup hooks",
 	register(api) {
-		api.registerConfigMigration((config) => migrateVoiceCallPluginConfig(config));
+		api.registerConfigMigration(migrateVoiceCallPluginConfig);
 	}
 });
 //#endregion