@openclaw/voice-call 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/index.js

@@ -1,18 +1,20 @@
 import { definePluginEntry, sleep } from "./runtime-api.js";
 import "./api.js";
 import { VOICE_CALL_CLI_DESCRIPTOR } from "./cli-output-mode.js";
-import { S as validateProviderConfig, b as resolveVoiceCallConfig, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoute, g as resolveUserPath, l as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime, u as getTailscaleSelfInfo, y as VoiceCallConfigSchema } from "./runtime-entry-CQtitvRd.js";
-import { g as setVoiceCallStateRuntime, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-nYL-yM0S.js";
+import { S as validateProviderConfig, b as resolveVoiceCallConfig, c as resolveWebhookExposureStatus, d as setupTailscaleExposureRoute, g as resolveUserPath, l as cleanupTailscaleExposureRoute, t as createVoiceCallRuntime, u as getTailscaleSelfInfo, y as VoiceCallConfigSchema } from "./runtime-entry-F13eJ4pp.js";
+import { b as setVoiceCallStateRuntime, t as resolveDefaultVoiceCallStoreDir, u as getCallHistoryFromStore } from "./store-path-51_oC_xn.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ErrorCodes, callGatewayFromCli, errorShape } from "openclaw/plugin-sdk/gateway-runtime";
-import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-import { asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
+import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { asNonArrayRecord, asOptionalRecord, isRecord, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
 import fs from "node:fs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
+import { MAX_TCP_PORT, MAX_TIMER_TIMEOUT_MS, addTimerTimeoutGraceMs, clampTimerTimeoutMs, parseStrictNonNegativeInteger, resolveTimerTimeoutMs, timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
+import { StringDecoder } from "node:string_decoder";
 import { format } from "node:util";
 //#region extensions/voice-call/src/cli.ts
 const VOICE_CALL_GATEWAY_DEFAULT_TIMEOUT_MS = 5e3;
@@ -429,22 +431,33 @@ function registerVoiceCallCli(params) {
 			}
 		};
 		if (fs.existsSync(file) && path.basename(file) !== "calls.jsonl") {
-			const initial = fs.readFileSync(file, "utf8");
-			const lines = initial.split("\n").filter(Boolean);
+			const initial = fs.readFileSync(file);
+			let decoder = new StringDecoder("utf8");
+			const initialLines = decoder.write(initial).split("\n");
+			let pendingLine = initialLines.pop() ?? "";
+			const lines = initialLines.filter(Boolean);
 			for (const line of lines.slice(Math.max(0, lines.length - since))) writeStdoutLine(line);
-			let offset = Buffer.byteLength(initial, "utf8");
+			let offset = initial.length;
+			let lastObservedSize = initial.length;
 			for (;;) {
 				try {
 					const stat = fs.statSync(file);
-					if (stat.size < offset) offset = 0;
+					if (stat.size < lastObservedSize) {
+						offset = 0;
+						decoder = new StringDecoder("utf8");
+						pendingLine = "";
+					}
+					lastObservedSize = stat.size;
 					if (stat.size > offset) {
 						const fd = fs.openSync(file, "r");
 						try {
 							const buf = Buffer.alloc(stat.size - offset);
-							fs.readSync(fd, buf, 0, buf.length, offset);
-							offset = stat.size;
-							const text = buf.toString("utf8");
-							for (const line of text.split("\n").filter(Boolean)) writeStdoutLine(line);
+							const bytesRead = fs.readSync(fd, buf, 0, buf.length, offset);
+							offset += bytesRead;
+							const text = decoder.write(buf.subarray(0, bytesRead));
+							const completeLines = `${pendingLine}${text}`.split("\n");
+							pendingLine = completeLines.pop() ?? "";
+							for (const line of completeLines.filter(Boolean)) writeStdoutLine(line);
 						} finally {
 							fs.closeSync(fd);
 						}
@@ -531,6 +544,126 @@ function registerVoiceCallCli(params) {
 	});
 }
 //#endregion
+//#region extensions/voice-call/src/command-service.ts
+var VoiceCallCommandInputError = class extends Error {};
+function toVoiceCallStatus(call) {
+	return {
+		callId: call.callId,
+		...call.providerCallId !== void 0 ? { providerCallId: call.providerCallId } : {},
+		provider: call.provider,
+		direction: call.direction,
+		state: call.state,
+		startedAt: call.startedAt,
+		...call.answeredAt !== void 0 ? { answeredAt: call.answeredAt } : {},
+		...call.endedAt !== void 0 ? { endedAt: call.endedAt } : {},
+		...call.endReason !== void 0 ? { endReason: call.endReason } : {}
+	};
+}
+function requireInput(value, message) {
+	if (!value) throw new VoiceCallCommandInputError(message);
+	return value;
+}
+function requireSuccess(result, fallback) {
+	if (!result.success) throw new Error(result.error || fallback);
+}
+function createVoiceCallCommandService(ensureRuntime) {
+	const describeHistoricalCall = async (rt, callId) => {
+		const call = await rt.manager.getCallFromMemoryOrStore(callId);
+		if (!call) return;
+		const endedAt = timestampMsToIsoString(call.endedAt);
+		return `call is not active (${[
+			`last state=${call.state}`,
+			call.endReason ? `endReason=${call.endReason}` : void 0,
+			endedAt ? `endedAt=${endedAt}` : void 0
+		].filter(Boolean).join(", ")})`;
+	};
+	const resolveCallMessage = async (callId, message) => {
+		const resolvedCallId = requireInput(callId, "callId and message required");
+		const resolvedMessage = requireInput(message, "callId and message required");
+		const rt = await ensureRuntime();
+		const activeCall = rt.manager.getCall(resolvedCallId) ?? rt.manager.getCallByProviderCallId(resolvedCallId);
+		if (!activeCall) throw new VoiceCallCommandInputError(await describeHistoricalCall(rt, resolvedCallId) ?? "Call not found");
+		return {
+			rt,
+			callId: activeCall.callId,
+			message: resolvedMessage
+		};
+	};
+	const prepareContinue = async (callId, message) => {
+		const request = await resolveCallMessage(callId, message);
+		return {
+			rt: request.rt,
+			callId: request.callId,
+			run: async () => {
+				const result = await request.rt.manager.continueCall(request.callId, request.message);
+				requireSuccess(result, "continue failed");
+				return {
+					success: true,
+					transcript: result.transcript
+				};
+			}
+		};
+	};
+	return {
+		prepareContinue,
+		async initiate(params, missingToMessage = "to required") {
+			const rt = await ensureRuntime();
+			const to = requireInput(params.to ?? rt.config.toNumber, missingToMessage);
+			const result = await rt.manager.initiateCall(to, params.sessionKey, {
+				message: params.message,
+				mode: params.mode,
+				dtmfSequence: params.dtmfSequence,
+				...params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {},
+				...params.agentId ? { agentId: params.agentId } : {}
+			});
+			requireSuccess(result, "initiate failed");
+			return {
+				callId: result.callId,
+				initiated: true
+			};
+		},
+		async continueCall(callId, message) {
+			return await (await prepareContinue(callId, message)).run();
+		},
+		async speak(params) {
+			const request = await resolveCallMessage(params.callId, params.message);
+			if (request.rt.config.realtime.enabled) {
+				const realtimeResult = request.rt.webhookServer.speakRealtime(request.callId, request.message);
+				if (realtimeResult.success) return { success: true };
+				if (params.allowTwimlFallback === false) return {
+					success: false,
+					error: realtimeResult.error ?? "Realtime bridge is not active"
+				};
+			}
+			requireSuccess(await request.rt.manager.speak(request.callId, request.message), "speak failed");
+			return { success: true };
+		},
+		async sendDtmf(callId, digits) {
+			const resolvedCallId = requireInput(callId, "callId and digits required");
+			const resolvedDigits = requireInput(digits, "callId and digits required");
+			requireSuccess(await (await ensureRuntime()).manager.sendDtmf(resolvedCallId, resolvedDigits), "dtmf failed");
+			return { success: true };
+		},
+		async endCall(callId) {
+			const resolvedCallId = requireInput(callId, "callId required");
+			requireSuccess(await (await ensureRuntime()).manager.endCall(resolvedCallId), "end failed");
+			return { success: true };
+		},
+		async status(callId) {
+			const rt = await ensureRuntime();
+			if (!callId) return {
+				found: true,
+				calls: rt.manager.getActiveCalls().map(toVoiceCallStatus)
+			};
+			const call = await rt.manager.getCallFromMemoryOrStore(callId);
+			return call ? {
+				found: true,
+				call: toVoiceCallStatus(call)
+			} : { found: false };
+		}
+	};
+}
+//#endregion
 //#region extensions/voice-call/src/gateway-continue-operation.ts
 const VOICE_CALL_CONTINUE_OPERATION_BUFFER_MS = 3e4;
 const VOICE_CALL_CONTINUE_OPERATION_CLEANUP_MS = 300 * 1e3;
@@ -557,21 +690,9 @@ function createVoiceCallContinueOperationStore(params) {
 			startedAtMs,
 			pollTimeoutMs
 		});
-		request.rt.manager.continueCall(request.callId, request.message).then((result) => {
+		request.run().then((result) => {
 			const current = operations.get(operationId);
 			if (!current || current.status !== "pending") return;
-			if (!result.success) {
-				operations.set(operationId, {
-					operationId,
-					status: "failed",
-					callId: request.callId,
-					startedAtMs,
-					completedAtMs: Date.now(),
-					pollTimeoutMs,
-					error: result.error || "continue failed"
-				});
-				return;
-			}
 			operations.set(operationId, {
 				operationId,
 				status: "completed",
@@ -649,223 +770,15 @@ function createVoiceCallContinueOperationStore(params) {
 //#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)
-		});
-	},
-	uiHints: {
-		provider: {
-			label: "Provider",
-			help: "Use twilio, telnyx, or mock for dev/no-network."
-		},
-		fromNumber: {
-			label: "From Number",
-			placeholder: "+15550001234"
-		},
-		toNumber: {
-			label: "Default To Number",
-			placeholder: "+15550001234"
-		},
-		inboundPolicy: { label: "Inbound Policy" },
-		allowFrom: { label: "Inbound Allowlist" },
-		inboundGreeting: {
-			label: "Inbound Greeting",
-			advanced: true
-		},
-		numbers: {
-			label: "Per-number Routing",
-			help: "Inbound overrides keyed by dialed E.164 number.",
-			advanced: true
-		},
-		"telnyx.apiKey": {
-			label: "Telnyx API Key",
-			sensitive: true
-		},
-		"telnyx.connectionId": { label: "Telnyx Connection ID" },
-		"telnyx.publicKey": {
-			label: "Telnyx Public Key",
-			sensitive: true
-		},
-		"twilio.accountSid": { label: "Twilio Account SID" },
-		"twilio.authToken": {
-			label: "Twilio Auth Token",
-			sensitive: true
-		},
-		"twilio.region": {
-			label: "Twilio Region",
-			advanced: true
-		},
-		"outbound.defaultMode": { label: "Default Call Mode" },
-		"outbound.notifyHangupDelaySec": {
-			label: "Notify Hangup Delay (sec)",
-			advanced: true
-		},
-		"serve.port": { label: "Webhook Port" },
-		"serve.bind": { label: "Webhook Bind" },
-		"serve.path": { label: "Webhook Path" },
-		"tailscale.mode": {
-			label: "Tailscale Mode",
-			advanced: true
-		},
-		"tailscale.path": {
-			label: "Tailscale Path",
-			advanced: true
-		},
-		"tunnel.provider": {
-			label: "Tunnel Provider",
-			advanced: true
-		},
-		"tunnel.ngrokAuthToken": {
-			label: "ngrok Auth Token",
-			sensitive: true,
-			advanced: true
-		},
-		"tunnel.ngrokDomain": {
-			label: "ngrok Domain",
-			advanced: true
-		},
-		"tunnel.allowNgrokFreeTierLoopbackBypass": {
-			label: "Allow ngrok Free Tier (Loopback Bypass)",
-			advanced: true
-		},
-		"streaming.enabled": {
-			label: "Enable Streaming",
-			help: "Classic streaming transcription currently requires the Twilio call provider.",
-			advanced: true
-		},
-		"streaming.provider": {
-			label: "Streaming Provider",
-			help: "Uses the first registered realtime transcription provider when unset.",
-			advanced: true
-		},
-		"streaming.providers": {
-			label: "Streaming Provider Config",
-			advanced: true
-		},
-		"streaming.streamPath": {
-			label: "Media Stream Path",
-			advanced: true
-		},
-		"realtime.enabled": {
-			label: "Enable Realtime Voice",
-			advanced: true
-		},
-		"realtime.provider": {
-			label: "Realtime Voice Provider",
-			help: "Uses the first registered realtime voice provider when unset.",
-			advanced: true
-		},
-		"realtime.streamPath": {
-			label: "Realtime Stream Path",
-			advanced: true
-		},
-		"realtime.instructions": {
-			label: "Realtime Instructions",
-			advanced: true
-		},
-		"realtime.toolPolicy": {
-			label: "Realtime Tool Policy",
-			help: "Controls the shared openclaw_agent_consult tool.",
-			advanced: true
-		},
-		"realtime.consultPolicy": {
-			label: "Realtime Consult Policy",
-			help: "Guides when the realtime voice model should call openclaw_agent_consult.",
-			advanced: true
-		},
-		"realtime.fastContext.enabled": {
-			label: "Enable Fast Realtime Context",
-			help: "Searches memory/session context before the full consult agent.",
-			advanced: true
-		},
-		"realtime.fastContext.timeoutMs": {
-			label: "Fast Context Timeout",
-			advanced: true
-		},
-		"realtime.fastContext.maxResults": {
-			label: "Fast Context Result Limit",
-			advanced: true
-		},
-		"realtime.fastContext.sources": {
-			label: "Fast Context Sources",
-			advanced: true
-		},
-		"realtime.fastContext.fallbackToConsult": {
-			label: "Fallback To Full Consult",
-			advanced: true
-		},
-		"realtime.agentContext.enabled": {
-			label: "Enable Agent Voice Context",
-			help: "Injects a compact agent identity and workspace context capsule into realtime voice instructions.",
-			advanced: true
-		},
-		"realtime.agentContext.maxChars": {
-			label: "Agent Voice Context Limit",
-			advanced: true
-		},
-		"realtime.agentContext.includeIdentity": {
-			label: "Include Agent Identity",
-			advanced: true
-		},
-		"realtime.agentContext.includeWorkspaceFiles": {
-			label: "Include Agent Workspace Files",
-			advanced: true
-		},
-		"realtime.agentContext.files": {
-			label: "Agent Voice Context Files",
-			advanced: true
-		},
-		"realtime.providers": {
-			label: "Realtime Provider Config",
-			advanced: true
-		},
-		"tts.provider": {
-			label: "TTS Provider Override",
-			help: "Deep-merges with tts (Microsoft is ignored for calls).",
-			advanced: true
-		},
-		"tts.providers": {
-			label: "TTS Provider Config",
-			advanced: true
-		},
-		publicUrl: {
-			label: "Public Webhook URL",
-			advanced: true
-		},
-		skipSignatureVerification: {
-			label: "Skip Signature Verification",
-			advanced: true
-		},
-		store: {
-			label: "Call Log Store Path",
-			advanced: true
-		},
-		agentId: {
-			label: "Response Agent ID",
-			help: "Agent workspace used for voice response generation. Defaults to \"main\".",
-			advanced: true
-		},
-		responseModel: {
-			label: "Response Model",
-			help: "Optional override. Falls back to the runtime default model when unset.",
-			advanced: true
-		},
-		responseSystemPrompt: {
-			label: "Response System Prompt",
-			advanced: true
-		},
-		responseTimeoutMs: {
-			label: "Response Timeout (ms)",
-			advanced: true
-		}
-	}
-};
+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)
+	});
+} };
 const VoiceCallToolSchema = Type.Union([
 	Type.Object({
 		action: Type.Literal("initiate_call"),
@@ -873,7 +786,6 @@ const VoiceCallToolSchema = Type.Union([
 		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" })),
-		requesterSessionKey: Type.Optional(Type.String({ description: "OpenClaw session key that initiated the call" })),
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	}),
 	Type.Object({
@@ -905,38 +817,28 @@ const VoiceCallToolSchema = Type.Union([
 		sid: Type.Optional(Type.String({ description: "Call SID" })),
 		message: Type.Optional(Type.String({ description: "Optional intro message" })),
 		sessionKey: Type.Optional(Type.String({ description: "OpenClaw session key for the call" })),
-		requesterSessionKey: Type.Optional(Type.String({ description: "OpenClaw session key that initiated the call" })),
 		dtmfSequence: Type.Optional(Type.String({ description: "DTMF digits to play before connect" }))
 	})
 ]);
-function asParamRecord(params) {
-	return params && typeof params === "object" && !Array.isArray(params) ? params : {};
-}
 function isCliOnlyProcess() {
 	return process.env.OPENCLAW_CLI === "1" && !process.argv.slice(2).includes("gateway");
 }
-function toVoiceCallStatus(call) {
-	return {
-		callId: call.callId,
-		...call.providerCallId !== void 0 ? { providerCallId: call.providerCallId } : {},
-		provider: call.provider,
-		direction: call.direction,
-		state: call.state,
-		startedAt: call.startedAt,
-		...call.answeredAt !== void 0 ? { answeredAt: call.answeredAt } : {},
-		...call.endedAt !== void 0 ? { endedAt: call.endedAt } : {},
-		...call.endReason !== void 0 ? { endReason: call.endReason } : {}
-	};
+const VOICE_CALL_RUNTIME_COORDINATOR_KEY = Symbol.for("openclaw.voice-call.runtimeCoordinator");
+var VoiceCallRuntimeLifecycleError = class extends Error {};
+function getVoiceCallRuntimeCoordinator() {
+	return resolveGlobalSingleton(VOICE_CALL_RUNTIME_COORDINATOR_KEY, () => ({
+		epochCounter: 0,
+		registeredEpoch: 0
+	}));
 }
-const VOICE_CALL_RUNTIME_KEY = Symbol.for("openclaw.voice-call.runtime");
-const VOICE_CALL_RUNTIME_PROMISE_KEY = Symbol.for("openclaw.voice-call.runtimePromise");
-const VOICE_CALL_RUNTIME_STOP_PROMISE_KEY = Symbol.for("openclaw.voice-call.runtimeStopPromise");
-function getVoiceCallRuntimeGlobalState() {
-	const state = globalThis;
-	state[VOICE_CALL_RUNTIME_KEY] ??= null;
-	state[VOICE_CALL_RUNTIME_PROMISE_KEY] ??= null;
-	state[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] ??= null;
-	return state;
+function activateVoiceCallRuntimeGeneration(coordinator, generation) {
+	if (generation.epoch < coordinator.registeredEpoch) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation was superseded; use the current plugin registration");
+	if (generation.retired) throw new VoiceCallRuntimeLifecycleError("Voice call runtime generation is retired; use the current plugin registration");
+	if (coordinator.current !== generation) {
+		if (coordinator.current) coordinator.current.retired = true;
+		coordinator.current = generation;
+		coordinator.registeredEpoch = generation.epoch;
+	}
 }
 var voice_call_default = definePluginEntry({
 	id: "voice-call",
@@ -946,304 +848,122 @@ var voice_call_default = definePluginEntry({
 	register(api) {
 		const config = resolveVoiceCallConfig(voiceCallConfigSchema.parse(api.pluginConfig));
 		const validation = validateProviderConfig(config);
-		const runtimeState = getVoiceCallRuntimeGlobalState();
+		const runtimeCoordinator = getVoiceCallRuntimeCoordinator();
+		const runtimeGeneration = api.registrationMode !== "full" && runtimeCoordinator.current ? runtimeCoordinator.current : {
+			epoch: ++runtimeCoordinator.epochCounter,
+			retired: false
+		};
 		const continueOperationStore = createVoiceCallContinueOperationStore({
 			config,
 			coreConfig: api.config
 		});
 		const ensureRuntime = async () => {
+			activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
 			if (!config.enabled) throw new Error("Voice call disabled in plugin config");
 			if (!validation.valid) throw new Error(validation.errors.join("; "));
 			while (true) {
-				if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) {
-					await runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY];
-					continue;
-				}
-				const runtime = runtimeState[VOICE_CALL_RUNTIME_KEY];
-				if (runtime) return runtime;
-				let runtimePromise = runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY];
-				if (!runtimePromise) {
-					runtimePromise = createVoiceCallRuntime({
-						config,
-						coreConfig: api.config,
-						fullConfig: api.config,
-						agentRuntime: api.runtime.agent,
-						stateRuntime: api.runtime.state,
-						ttsRuntime: api.runtime.tts,
-						logger: api.logger
-					});
-					runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = runtimePromise;
-				}
-				try {
-					const createdRuntime = await runtimePromise;
-					if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) continue;
-					if (runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] !== runtimePromise) continue;
-					runtimeState[VOICE_CALL_RUNTIME_KEY] = createdRuntime;
-					return createdRuntime;
-				} catch (err) {
-					if (runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] === runtimePromise) {
-						runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = null;
-						runtimeState[VOICE_CALL_RUNTIME_KEY] = null;
+				activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+				const slot = runtimeCoordinator.slot;
+				if (slot) {
+					if (slot.owner !== runtimeGeneration) {
+						if (slot.state === "stopping") {
+							await slot.promise;
+							continue;
+						}
+						throw new VoiceCallRuntimeLifecycleError("A previous voice call runtime generation is still active; retry after it stops");
 					}
-					throw err;
-				}
-			}
-		};
-		const respondError = (respond, message, code = ErrorCodes.UNAVAILABLE) => {
-			respond(false, void 0, errorShape(code, message));
-		};
-		const sendError = (respond, err) => {
-			respondError(respond, formatErrorMessage(err));
-		};
-		const describeHistoricalCall = async (rt, callId) => {
-			const call = await rt.manager.getCallFromMemoryOrStore(callId);
-			if (!call) return;
-			const endedAt = timestampMsToIsoString(call.endedAt);
-			return `call is not active (${[
-				`last state=${call.state}`,
-				call.endReason ? `endReason=${call.endReason}` : void 0,
-				endedAt ? `endedAt=${endedAt}` : void 0
-			].filter(Boolean).join(", ")})`;
-		};
-		const resolveCallMessageRequest = async (params) => {
-			const callId = normalizeOptionalString(params?.callId) ?? "";
-			const message = normalizeOptionalString(params?.message) ?? "";
-			if (!callId || !message) return { error: "callId and message required" };
-			const rt = await ensureRuntime();
-			const activeCall = rt.manager.getCall(callId) ?? rt.manager.getCallByProviderCallId(callId);
-			if (activeCall) return {
-				rt,
-				callId: activeCall.callId,
-				message
-			};
-			return { error: await describeHistoricalCall(rt, callId) ?? "Call not found" };
-		};
-		const initiateCallAndRespond = async (params) => {
-			const result = await params.rt.manager.initiateCall(params.to, params.sessionKey, {
-				message: params.message,
-				mode: params.mode,
-				dtmfSequence: params.dtmfSequence,
-				...params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {},
-				...params.agentId ? { agentId: params.agentId } : {}
-			});
-			if (!result.success) {
-				respondError(params.respond, result.error || "initiate failed");
-				return;
-			}
-			params.respond(true, {
-				callId: result.callId,
-				initiated: true
-			});
-		};
-		const respondToCallMessageAction = async (params) => {
-			const request = await resolveCallMessageRequest(params.requestParams);
-			if ("error" in request) {
-				respondError(params.respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-				return;
-			}
-			const result = await params.action(request);
-			if (!result.success) {
-				respondError(params.respond, result.error || params.failure);
-				return;
-			}
-			params.respond(true, params.includeTranscript ? {
-				success: true,
-				transcript: result.transcript
-			} : { success: true });
-		};
-		api.registerGatewayMethod("voicecall.initiate", async ({ params, respond }) => {
-			try {
-				const message = normalizeOptionalString(params?.message) ?? "";
-				if (!message) {
-					respondError(respond, "message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const rt = await ensureRuntime();
-				const to = normalizeOptionalString(params?.to) ?? rt.config.toNumber;
-				if (!to) {
-					respondError(respond, "to required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const mode = params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0;
-				await initiateCallAndRespond({
-					rt,
-					respond,
-					to,
-					message,
-					mode,
-					sessionKey: normalizeOptionalString(params?.sessionKey),
-					requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue", async ({ params, respond }) => {
-			try {
-				await respondToCallMessageAction({
-					requestParams: params,
-					respond,
-					action: (request) => request.rt.manager.continueCall(request.callId, request.message),
-					failure: "continue failed",
-					includeTranscript: true
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue.start", async ({ params, respond }) => {
-			try {
-				const request = await resolveCallMessageRequest(params);
-				if ("error" in request) {
-					respondError(respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				respond(true, continueOperationStore.start(request));
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.continue.result", async ({ params, respond }) => {
-			try {
-				const operationId = normalizeOptionalString(params?.operationId) ?? "";
-				if (!operationId) {
-					respondError(respond, "operationId required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const operation = continueOperationStore.read(operationId);
-				if (!operation.ok) {
-					respondError(respond, operation.error, ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				respond(true, operation.payload);
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_READ_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.speak", async ({ params, respond }) => {
-			try {
-				const request = await resolveCallMessageRequest(params);
-				if ("error" in request) {
-					respondError(respond, request.error ?? "callId and message required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				if (request.rt.config.realtime.enabled) {
-					const realtimeResult = request.rt.webhookServer.speakRealtime(request.callId, request.message);
-					if (realtimeResult.success) {
-						respond(true, { success: true });
-						return;
+					if (slot.state === "running") return slot.runtime;
+					if (slot.state === "stopping") {
+						await slot.promise;
+						continue;
 					}
-					if (params?.allowTwimlFallback === false) {
-						respond(true, {
-							success: false,
-							error: realtimeResult.error ?? "Realtime bridge is not active"
-						});
-						return;
+					let createdRuntime;
+					try {
+						createdRuntime = await slot.promise;
+					} catch (err) {
+						if (runtimeCoordinator.slot === slot) runtimeCoordinator.slot = void 0;
+						throw err;
 					}
+					activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+					if (runtimeCoordinator.slot !== slot) continue;
+					runtimeCoordinator.slot = {
+						state: "running",
+						owner: runtimeGeneration,
+						runtime: createdRuntime
+					};
+					return createdRuntime;
 				}
-				const result = await request.rt.manager.speak(request.callId, request.message);
-				if (!result.success) {
-					respondError(respond, result.error || "speak failed");
-					return;
-				}
-				respond(true, { success: true });
-			} catch (err) {
-				sendError(respond, err);
-			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.dtmf", async ({ params, respond }) => {
-			try {
-				const callId = normalizeOptionalString(params?.callId) ?? "";
-				const digits = normalizeOptionalString(params?.digits) ?? "";
-				if (!callId || !digits) {
-					respondError(respond, "callId and digits required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const result = await (await ensureRuntime()).manager.sendDtmf(callId, digits);
-				if (!result.success) {
-					respondError(respond, result.error || "dtmf failed");
-					return;
-				}
-				respond(true, { success: true });
-			} catch (err) {
-				sendError(respond, err);
+				const runtimePromise = createVoiceCallRuntime({
+					config,
+					coreConfig: api.config,
+					fullConfig: api.config,
+					agentRuntime: api.runtime.agent,
+					stateRuntime: api.runtime.state,
+					ttsRuntime: api.runtime.tts,
+					logger: api.logger
+				});
+				runtimeCoordinator.slot = {
+					state: "starting",
+					owner: runtimeGeneration,
+					promise: runtimePromise
+				};
 			}
-		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.end", async ({ params, respond }) => {
-			try {
-				const callId = normalizeOptionalString(params?.callId) ?? "";
-				if (!callId) {
-					respondError(respond, "callId required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const result = await (await ensureRuntime()).manager.endCall(callId);
-				if (!result.success) {
-					respondError(respond, result.error || "end failed");
-					return;
+		};
+		const commands = createVoiceCallCommandService(ensureRuntime);
+		const registerGatewayCommand = (method, handler, scope) => {
+			api.registerGatewayMethod(method, async (options) => {
+				try {
+					options.respond(true, await handler(options));
+				} catch (err) {
+					const code = err instanceof VoiceCallCommandInputError ? ErrorCodes.INVALID_REQUEST : ErrorCodes.UNAVAILABLE;
+					options.respond(false, void 0, errorShape(code, formatErrorMessage(err)));
 				}
-				respond(true, { success: true });
-			} catch (err) {
-				sendError(respond, err);
-			}
+			}, scope);
+		};
+		registerGatewayCommand("voicecall.initiate", async ({ params }) => {
+			const message = normalizeOptionalString(params?.message);
+			if (!message) throw new VoiceCallCommandInputError("message required");
+			return await commands.initiate({
+				to: normalizeOptionalString(params?.to),
+				message,
+				mode: params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0,
+				sessionKey: normalizeOptionalString(params?.sessionKey),
+				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
+			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.status", async ({ params, respond }) => {
-			try {
-				const raw = normalizeOptionalString(params?.callId) ?? normalizeOptionalString(params?.sid) ?? "";
-				const rt = await ensureRuntime();
-				if (!raw) {
-					respond(true, {
-						found: true,
-						calls: rt.manager.getActiveCalls().map(toVoiceCallStatus)
-					});
-					return;
-				}
-				const call = await rt.manager.getCallFromMemoryOrStore(raw);
-				if (!call) {
-					respond(true, { found: false });
-					return;
-				}
-				respond(true, {
-					found: true,
-					call: toVoiceCallStatus(call)
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
+		registerGatewayCommand("voicecall.continue", ({ params }) => commands.continueCall(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.message)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.continue.start", async ({ params }) => continueOperationStore.start(await commands.prepareContinue(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.message))), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.continue.result", ({ params }) => {
+			const operationId = normalizeOptionalString(params?.operationId);
+			if (!operationId) throw new VoiceCallCommandInputError("operationId required");
+			const operation = continueOperationStore.read(operationId);
+			if (!operation.ok) throw new VoiceCallCommandInputError(operation.error);
+			return operation.payload;
 		}, VOICE_CALL_READ_METHOD_SCOPE);
-		api.registerGatewayMethod("voicecall.start", async ({ params, client, respond }) => {
-			try {
-				const to = normalizeOptionalString(params?.to) ?? "";
-				const message = normalizeOptionalString(params?.message) ?? "";
-				const dtmfSequence = normalizeOptionalString(params?.dtmfSequence);
-				const sessionKey = normalizeOptionalString(params?.sessionKey);
-				const requesterSessionKey = normalizeOptionalString(params?.requesterSessionKey);
-				const requestedAgentId = normalizeOptionalString(params?.agentId);
-				const normalizedAgentId = requestedAgentId ? normalizeAgentId(requestedAgentId) : void 0;
-				const pluginOwnerId = normalizeOptionalString(client?.internal?.pluginRuntimeOwnerId);
-				if (requestedAgentId && (!pluginOwnerId || normalizedAgentId !== requestedAgentId.toLowerCase())) {
-					respondError(respond, "agentId requires a trusted plugin caller and a valid agent id", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				if (!to) {
-					respondError(respond, "to required", ErrorCodes.INVALID_REQUEST);
-					return;
-				}
-				const mode = params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0;
-				const rt = await ensureRuntime();
-				await initiateCallAndRespond({
-					rt,
-					respond,
-					to,
-					message: message || void 0,
-					mode,
-					dtmfSequence,
-					sessionKey,
-					...requesterSessionKey ? { requesterSessionKey } : {},
-					...normalizedAgentId ? { agentId: normalizedAgentId } : {}
-				});
-			} catch (err) {
-				sendError(respond, err);
-			}
+		registerGatewayCommand("voicecall.speak", ({ params }) => commands.speak({
+			callId: normalizeOptionalString(params?.callId),
+			message: normalizeOptionalString(params?.message),
+			allowTwimlFallback: params?.allowTwimlFallback !== false
+		}), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.dtmf", ({ params }) => commands.sendDtmf(normalizeOptionalString(params?.callId), normalizeOptionalString(params?.digits)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.end", ({ params }) => commands.endCall(normalizeOptionalString(params?.callId)), VOICE_CALL_WRITE_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.status", ({ params }) => commands.status(normalizeOptionalString(params?.callId) ?? normalizeOptionalString(params?.sid)), VOICE_CALL_READ_METHOD_SCOPE);
+		registerGatewayCommand("voicecall.start", async ({ params, client }) => {
+			const to = normalizeOptionalString(params?.to);
+			const requestedAgentId = normalizeOptionalString(params?.agentId);
+			const normalizedAgentId = requestedAgentId ? normalizeAgentId(requestedAgentId) : void 0;
+			const pluginOwnerId = normalizeOptionalString(client?.internal?.pluginRuntimeOwnerId);
+			if (requestedAgentId && (!pluginOwnerId || normalizedAgentId !== requestedAgentId.toLowerCase())) throw new VoiceCallCommandInputError("agentId requires a trusted plugin caller and a valid agent id");
+			if (!to) throw new VoiceCallCommandInputError("to required");
+			return await commands.initiate({
+				to,
+				message: normalizeOptionalString(params?.message),
+				mode: params?.mode === "notify" || params?.mode === "conversation" ? params.mode : void 0,
+				dtmfSequence: normalizeOptionalString(params?.dtmfSequence),
+				sessionKey: normalizeOptionalString(params?.sessionKey),
+				requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey),
+				agentId: normalizedAgentId
+			});
 		}, VOICE_CALL_WRITE_METHOD_SCOPE);
 		api.registerTool((toolContext) => ({
 			name: "voice_call",
@@ -1251,94 +971,52 @@ var voice_call_default = definePluginEntry({
 			description: "Make phone calls and have voice conversations via the voice-call plugin.",
 			parameters: VoiceCallToolSchema,
 			async execute(_toolCallId, params) {
-				const rawParams = asParamRecord(params);
-				const agentId = normalizeOptionalString(toolContext.agentId);
+				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();
+					await ensureRuntime();
 					if (typeof rawParams.action === "string") switch (rawParams.action) {
 						case "initiate_call": {
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!message) throw new Error("message required");
-							const to = normalizeOptionalString(rawParams.to) ?? rt.config.toNumber;
-							if (!to) throw new Error("to required");
-							const result = await rt.manager.initiateCall(to, void 0, {
+							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,
-								...agentId ? { agentId } : {}
-							});
-							if (!result.success) throw new Error(result.error || "initiate failed");
-							return jsonResult({
-								callId: result.callId,
-								initiated: true
-							});
-						}
-						case "continue_call": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!callId || !message) throw new Error("callId and message required");
-							const result = await rt.manager.continueCall(callId, message);
-							if (!result.success) throw new Error(result.error || "continue failed");
-							return jsonResult({
-								success: true,
-								transcript: result.transcript
-							});
-						}
-						case "speak_to_user": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const message = normalizeOptionalString(rawParams.message) ?? "";
-							if (!callId || !message) throw new Error("callId and message required");
-							const result = await rt.manager.speak(callId, message);
-							if (!result.success) throw new Error(result.error || "speak failed");
-							return jsonResult({ success: true });
-						}
-						case "send_dtmf": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							const digits = normalizeOptionalString(rawParams.digits) ?? "";
-							if (!callId || !digits) throw new Error("callId and digits required");
-							const result = await rt.manager.sendDtmf(callId, digits);
-							if (!result.success) throw new Error(result.error || "dtmf failed");
-							return jsonResult({ success: true });
-						}
-						case "end_call": {
-							const callId = normalizeOptionalString(rawParams.callId) ?? "";
-							if (!callId) throw new Error("callId required");
-							const result = await rt.manager.endCall(callId);
-							if (!result.success) throw new Error(result.error || "end failed");
-							return jsonResult({ success: true });
+								sessionKey: normalizeOptionalString(rawParams.sessionKey),
+								agentId,
+								requesterSessionKey
+							}));
 						}
+						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 Error("callId required");
-							const call = await rt.manager.getCallFromMemoryOrStore(callId);
-							return jsonResult(call ? {
-								found: true,
-								call: toVoiceCallStatus(call)
-							} : { found: false });
+							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");
-						const call = await rt.manager.getCallFromMemoryOrStore(sid);
-						return jsonResult(call ? {
-							found: true,
-							call: toVoiceCallStatus(call)
-						} : { found: false });
+						return jsonResult(await commands.status(sid));
 					}
-					const to = normalizeOptionalString(rawParams.to) ?? rt.config.toNumber;
-					if (!to) throw new Error("to required for call");
-					const result = await rt.manager.initiateCall(to, normalizeOptionalString(rawParams.sessionKey), {
+					return jsonResult(await commands.initiate({
+						to: normalizeOptionalString(rawParams.to),
 						dtmfSequence: normalizeOptionalString(rawParams.dtmfSequence),
 						message: normalizeOptionalString(rawParams.message),
-						...agentId ? { agentId } : {},
-						...normalizeOptionalString(rawParams.requesterSessionKey) ? { requesterSessionKey: normalizeOptionalString(rawParams.requesterSessionKey) } : {}
-					});
-					if (!result.success) throw new Error(result.error || "initiate failed");
-					return jsonResult({
-						callId: result.callId,
-						initiated: true
-					});
+						sessionKey: normalizeOptionalString(rawParams.sessionKey),
+						agentId,
+						requesterSessionKey
+					}, "to required for call"));
 				} catch (err) {
 					return jsonResult({ error: formatErrorMessage(err) });
 				}
@@ -1358,33 +1036,46 @@ var voice_call_default = definePluginEntry({
 			id: "voicecall",
 			start: () => {
 				if (isCliOnlyProcess()) return;
+				try {
+					activateVoiceCallRuntimeGeneration(runtimeCoordinator, runtimeGeneration);
+				} catch (err) {
+					if (err instanceof VoiceCallRuntimeLifecycleError) return;
+					throw err;
+				}
 				if (!config.enabled) return;
 				if (!validation.valid) {
 					api.logger.warn(`[voice-call] Runtime not started; setup incomplete: ${validation.errors.join("; ")}`);
 					return;
 				}
 				ensureRuntime().catch((err) => {
+					const staleGeneration = runtimeGeneration.retired || runtimeGeneration.epoch < runtimeCoordinator.registeredEpoch;
+					if (err instanceof VoiceCallRuntimeLifecycleError && staleGeneration) return;
 					api.logger.error(`[voice-call] Failed to start runtime: ${formatErrorMessage(err)}`);
 				});
 			},
 			stop: async () => {
-				if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY]) {
-					await runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY];
-					return;
-				}
-				const runtime = runtimeState[VOICE_CALL_RUNTIME_KEY];
-				const runtimePromise = runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY];
-				if (!runtime && !runtimePromise) return;
-				runtimeState[VOICE_CALL_RUNTIME_KEY] = null;
-				runtimeState[VOICE_CALL_RUNTIME_PROMISE_KEY] = null;
-				const stopPromise = (async () => {
-					await (runtime ?? await runtimePromise).stop();
-				})();
-				runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] = stopPromise;
+				if (runtimeGeneration.stopPromise) return await runtimeGeneration.stopPromise;
+				runtimeGeneration.retired = true;
+				const ownedSlot = runtimeCoordinator.slot?.owner === runtimeGeneration ? runtimeCoordinator.slot : void 0;
+				let stoppingSlot;
+				const stopPromise = ownedSlot?.state === "stopping" ? ownedSlot.promise : Promise.resolve().then(async () => {
+					if (!ownedSlot) return;
+					await (ownedSlot.state === "running" ? ownedSlot.runtime : await ownedSlot.promise).stop();
+				});
+				runtimeGeneration.stopPromise = stopPromise;
+				if (ownedSlot && ownedSlot.state !== "stopping") {
+					stoppingSlot = {
+						state: "stopping",
+						owner: runtimeGeneration,
+						promise: stopPromise
+					};
+					if (runtimeCoordinator.slot === ownedSlot) runtimeCoordinator.slot = stoppingSlot;
+				} else if (ownedSlot) stoppingSlot = ownedSlot;
 				try {
 					await stopPromise;
 				} finally {
-					if (runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] === stopPromise) runtimeState[VOICE_CALL_RUNTIME_STOP_PROMISE_KEY] = null;
+					if (stoppingSlot && runtimeCoordinator.slot === stoppingSlot) runtimeCoordinator.slot = void 0;
+					if (runtimeCoordinator.current === runtimeGeneration) runtimeCoordinator.current = void 0;
 				}
 			}
 		});