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

package/dist/.setup/{telnyx-DPilutCH.mjs → telnyx-B4P0peEe.mjs}

@@ -1,6 +1,23 @@
-import { a as verifyTelnyxWebhook, n as readProviderCallStatus, t as guardedJsonApiRequest } from "./guarded-json-api-x55yqHvW.mjs";
+import { i as verifyTelnyxWebhook, t as createCarrierApi } from "./carrier-api-BYKw_fsQ.mjs";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/telnyx.ts
+const HANGUP_REASONS = /* @__PURE__ */ new Map([
+	["normal_clearing", "completed"],
+	["normal_unspecified", "completed"],
+	["originator_cancel", "hangup-bot"],
+	["call_rejected", "busy"],
+	["user_busy", "busy"],
+	["no_answer", "no-answer"],
+	["no_user_response", "no-answer"],
+	["destination_out_of_order", "failed"],
+	["network_out_of_order", "failed"],
+	["service_unavailable", "failed"],
+	["recovery_on_timer_expire", "failed"],
+	["machine_detected", "voicemail"],
+	["fax_detected", "voicemail"],
+	["user_hangup", "hangup-user"],
+	["subscriber_absent", "hangup-user"]
+]);
 function normalizeTelnyxDirection(direction) {
 	if (direction === "incoming" || direction === "inbound") return "inbound";
 	if (direction === "outgoing" || direction === "outbound") return "outbound";
@@ -16,29 +33,12 @@ function decodeClientStateBase64(value) {
 var TelnyxProvider = class {
 	constructor(config, options = {}) {
 		this.name = "telnyx";
-		this.baseUrl = "https://api.telnyx.com/v2";
-		this.apiHost = "api.telnyx.com";
 		if (!config.apiKey) throw new Error("Telnyx API key is required");
 		if (!config.connectionId) throw new Error("Telnyx connection ID is required");
-		this.apiKey = config.apiKey;
 		this.connectionId = config.connectionId;
 		this.publicKey = config.publicKey;
 		this.options = options;
-	}
-	async apiRequest(endpoint, body, options) {
-		return await guardedJsonApiRequest({
-			url: `${this.baseUrl}${endpoint}`,
-			method: "POST",
-			headers: {
-				Authorization: `Bearer ${this.apiKey}`,
-				"Content-Type": "application/json"
-			},
-			body,
-			allowNotFound: options?.allowNotFound,
-			allowedHostnames: [this.apiHost],
-			auditContext: "voice-call.telnyx.api",
-			errorPrefix: "Telnyx API error"
-		});
+		this.api = createCarrierApi("Telnyx", "https://api.telnyx.com/v2", `Bearer ${config.apiKey}`, { statusContentType: "application/json" });
 	}
 	verifyWebhook(ctx) {
 		return verifyTelnyxWebhook(ctx, this.publicKey, { skipVerification: this.options.skipVerification });
@@ -116,31 +116,11 @@ var TelnyxProvider = class {
 			default: return null;
 		}
 	}
-	/**
-	* Map Telnyx hangup cause to normalized end reason.
-	* @see https://developers.telnyx.com/docs/api/v2/call-control/Call-Commands#hangup-causes
-	*/
 	mapHangupCause(cause) {
-		switch (cause) {
-			case "normal_clearing":
-			case "normal_unspecified": return "completed";
-			case "originator_cancel": return "hangup-bot";
-			case "call_rejected":
-			case "user_busy": return "busy";
-			case "no_answer":
-			case "no_user_response": return "no-answer";
-			case "destination_out_of_order":
-			case "network_out_of_order":
-			case "service_unavailable":
-			case "recovery_on_timer_expire": return "failed";
-			case "machine_detected":
-			case "fax_detected": return "voicemail";
-			case "user_hangup":
-			case "subscriber_absent": return "hangup-user";
-			default:
-				if (cause) console.warn(`[telnyx] Unknown hangup cause: ${cause}`);
-				return "completed";
-		}
+		const reason = cause && HANGUP_REASONS.get(cause);
+		if (reason) return reason;
+		if (cause) console.warn(`[telnyx] Unknown hangup cause: ${cause}`);
+		return "completed";
 	}
 	async initiateCall(input) {
 		const body = {
@@ -154,22 +134,22 @@ var TelnyxProvider = class {
 			...buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken)
 		};
 		return {
-			providerCallId: (await this.apiRequest("/calls", body)).data.call_control_id,
+			providerCallId: (await this.api.request("/calls", body)).data.call_control_id,
 			status: "initiated"
 		};
 	}
 	async hangupCall(input) {
-		await this.apiRequest(`/calls/${input.providerCallId}/actions/hangup`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
+		await this.api.request(`/calls/${input.providerCallId}/actions/hangup`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
 	}
 	async answerCall(input) {
 		const body = {
 			command_id: `openclaw-answer-${input.callId}`,
 			...buildTelnyxStreamingFields(input.streamUrl, input.streamAuthToken)
 		};
-		await this.apiRequest(`/calls/${input.providerCallId}/actions/answer`, body);
+		await this.api.request(`/calls/${input.providerCallId}/actions/answer`, body);
 	}
 	async playTts(input) {
-		await this.apiRequest(`/calls/${input.providerCallId}/actions/speak`, {
+		await this.api.request(`/calls/${input.providerCallId}/actions/speak`, {
 			command_id: crypto.randomUUID(),
 			payload: input.text,
 			voice: input.voice || "female",
@@ -177,27 +157,16 @@ var TelnyxProvider = class {
 		});
 	}
 	async startListening(input) {
-		await this.apiRequest(`/calls/${input.providerCallId}/actions/transcription_start`, {
+		await this.api.request(`/calls/${input.providerCallId}/actions/transcription_start`, {
 			command_id: crypto.randomUUID(),
 			language: input.language || "en"
 		});
 	}
 	async stopListening(input) {
-		await this.apiRequest(`/calls/${input.providerCallId}/actions/transcription_stop`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
+		await this.api.request(`/calls/${input.providerCallId}/actions/transcription_stop`, { command_id: crypto.randomUUID() }, { allowNotFound: true });
 	}
 	async getCallStatus(input) {
-		return readProviderCallStatus(() => guardedJsonApiRequest({
-			url: `${this.baseUrl}/calls/${input.providerCallId}`,
-			method: "GET",
-			headers: {
-				Authorization: `Bearer ${this.apiKey}`,
-				"Content-Type": "application/json"
-			},
-			allowNotFound: true,
-			allowedHostnames: [this.apiHost],
-			auditContext: "telnyx-get-call-status",
-			errorPrefix: "Telnyx get call status error"
-		}), (data) => {
+		return this.api.getCallStatus(`/calls/${input.providerCallId}`, (data) => {
 			const status = data.data?.state ?? "unknown";
 			const isAlive = data.data?.is_alive;
 			return isAlive === void 0 ? {

package/dist/.setup/{twilio-BWFNGyVx.mjs → twilio-BzAYgH7M.mjs}

@@ -1,13 +1,14 @@
+import { a as mapProviderStatusToEndReason, c as getHeader, h as generateDtmfRedirectTwiml, i as isProviderStatusTerminal, o as normalizeProviderStatus } from "./runtime-entry-STjFmi_B.mjs";
 import { n as requireSupportedTwilioApiHostname, r as resolveTwilioApiBaseUrl } from "./twilio-region-wBOx-8sz.mjs";
-import { a as normalizeProviderStatus, g as generateDtmfRedirectTwiml, i as mapProviderStatusToEndReason, r as isProviderStatusTerminal, s as getHeader } from "./runtime-entry-CbSKxSKk.mjs";
-import { n as mapVoiceToPolly, t as escapeXml } from "./voice-mapping-B_iAUkER.mjs";
-import { n as readProviderCallStatus, o as verifyTwilioWebhook, t as guardedJsonApiRequest } from "./guarded-json-api-x55yqHvW.mjs";
+import { n as mapVoiceToPolly, t as escapeXml } from "./voice-mapping-1lzFmzOF.mjs";
+import { a as verifyTwilioWebhook, t as createCarrierApi } from "./carrier-api-BYKw_fsQ.mjs";
 import { asNullableObjectRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import crypto from "node:crypto";
 import { safeParseJson } from "openclaw/plugin-sdk/text-utility-runtime";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 //#region extensions/voice-call/src/providers/twilio/api.ts
 var TwilioApiError = class extends Error {
 	constructor(httpStatus, responseText) {
@@ -20,28 +21,27 @@ var TwilioApiError = class extends Error {
 		this.twilioCode = typeof parsed?.code === "number" ? parsed.code : void 0;
 	}
 };
-/** POST a form-encoded Twilio REST API request through the SSRF guard. */
-async function twilioApiRequest(params) {
-	const bodyParams = params.body instanceof URLSearchParams ? params.body : Object.entries(params.body).reduce((acc, [key, value]) => {
-		if (Array.isArray(value)) for (const entry of value) acc.append(key, entry);
-		else if (typeof value === "string") acc.append(key, value);
-		return acc;
-	}, new URLSearchParams());
-	return guardedJsonApiRequest({
-		url: `${params.baseUrl}${params.endpoint}`,
-		method: "POST",
-		headers: {
-			Authorization: `Basic ${Buffer.from(`${params.accountSid}:${params.authToken}`).toString("base64")}`,
-			"Content-Type": "application/x-www-form-urlencoded"
-		},
-		body: bodyParams,
-		allowNotFound: params.allowNotFound,
-		allowedHostnames: [requireSupportedTwilioApiHostname(params.baseUrl)],
-		auditContext: "voice-call.twilio.api",
-		errorPrefix: "Twilio API error",
+function createTwilioApi(params) {
+	requireSupportedTwilioApiHostname(params.baseUrl);
+	const api = createCarrierApi("Twilio", params.baseUrl, `Basic ${Buffer.from(`${params.accountSid}:${params.authToken}`).toString("base64")}`, {
+		contentType: "application/x-www-form-urlencoded",
 		malformedJsonMessage: "Twilio API returned malformed JSON.",
 		createError: (status, text) => new TwilioApiError(status, text)
 	});
+	return {
+		request: (endpoint, body, options) => {
+			const form = body instanceof URLSearchParams ? body : new URLSearchParams();
+			if (!(body instanceof URLSearchParams)) for (const [key, value] of Object.entries(body)) for (const entry of Array.isArray(value) ? value : [value]) form.append(key, entry);
+			return api.request(endpoint, form, options);
+		},
+		getCallStatus: ({ providerCallId }) => api.getCallStatus(`/Calls/${providerCallId}.json`, (data) => {
+			const status = normalizeProviderStatus(data.status);
+			return {
+				status,
+				isTerminal: isProviderStatusTerminal(status)
+			};
+		})
+	};
 }
 //#endregion
 //#region extensions/voice-call/src/providers/twilio.ts
@@ -87,12 +87,17 @@ var TwilioProvider = class TwilioProvider {
 		this.twimlStorage = /* @__PURE__ */ new Map();
 		if (!config.accountSid) throw new Error("Twilio Account SID is required");
 		if (!config.authToken) throw new Error("Twilio Auth Token is required");
-		this.accountSid = config.accountSid;
 		this.authToken = config.authToken;
-		this.baseUrl = resolveTwilioApiBaseUrl({
-			accountSid: this.accountSid,
-			region: config.region
+		const api = createTwilioApi({
+			accountSid: config.accountSid,
+			authToken: config.authToken,
+			baseUrl: resolveTwilioApiBaseUrl({
+				accountSid: config.accountSid,
+				region: config.region
+			})
 		});
+		this.apiRequest = api.request;
+		this.getCallStatus = api.getCallStatus;
 		this.options = options;
 		if (options.publicUrl) this.currentPublicUrl = options.publicUrl;
 	}
@@ -131,16 +136,6 @@ var TwilioProvider = class TwilioProvider {
 		if (!streamSid || !this.mediaStreamHandler) return;
 		this.mediaStreamHandler.clearTtsQueue(streamSid, reason);
 	}
-	async apiRequest(endpoint, params, options) {
-		return await twilioApiRequest({
-			baseUrl: this.baseUrl,
-			accountSid: this.accountSid,
-			authToken: this.authToken,
-			endpoint,
-			body: params,
-			allowNotFound: options?.allowNotFound
-		});
-	}
 	async updateLiveCallTwiml(providerCallId, twiml, operation) {
 		await retryAsync(() => this.apiRequest(`/Calls/${providerCallId}.json`, { Twiml: twiml }), {
 			attempts: TWILIO_CALL_UPDATE_RETRY_DELAYS_MS.length + 1,
@@ -181,7 +176,8 @@ var TwilioProvider = class TwilioProvider {
 			const event = this.normalizeEvent(params, {
 				callIdOverride: callIdFromQuery,
 				dedupeKey,
-				turnToken: turnTokenFromQuery
+				turnToken: turnTokenFromQuery,
+				amdCallback: normalizeOptionalString(ctx.query?.type) === "amd"
 			});
 			if (event?.direction === "inbound" && event.type !== "call.ended" && event.providerCallId && this.currentPublicUrl && !this.callWebhookUrls.has(event.providerCallId)) this.callWebhookUrls.set(event.providerCallId, this.currentPublicUrl);
 			return {
@@ -209,17 +205,25 @@ var TwilioProvider = class TwilioProvider {
 	normalizeEvent(params, options) {
 		const callSid = params.get("CallSid") || "";
 		const callIdOverride = options?.callIdOverride;
+		const answeredBy = params.get("AnsweredBy")?.trim().toLowerCase();
 		const baseEvent = {
 			id: crypto.randomUUID(),
 			dedupeKey: options?.dedupeKey,
 			callId: callIdOverride || callSid,
 			providerCallId: callSid,
 			timestamp: Date.now(),
+			...answeredBy ? { answeredBy } : {},
 			turnToken: options?.turnToken,
 			direction: TwilioProvider.parseDirection(params.get("Direction")),
 			from: params.get("From") || void 0,
 			to: params.get("To") || void 0
 		};
+		if (answeredBy) console.log(`[voice-call] AMD classification callId=${baseEvent.callId} answeredBy=${answeredBy} at=${baseEvent.timestamp}`);
+		if (options?.amdCallback && answeredBy) return {
+			...baseEvent,
+			type: "call.amd",
+			answeredBy
+		};
 		const speechResult = params.get("SpeechResult");
 		if (speechResult?.trim()) return {
 			...baseEvent,
@@ -234,7 +238,8 @@ var TwilioProvider = class TwilioProvider {
 			type: "call.dtmf",
 			digits
 		};
-		const callStatus = normalizeProviderStatus(params.get("CallStatus"));
+		const rawCallStatus = params.get("CallStatus");
+		const callStatus = normalizeProviderStatus(rawCallStatus);
 		if (callStatus === "initiated") return {
 			...baseEvent,
 			type: "call.initiated"
@@ -257,6 +262,10 @@ var TwilioProvider = class TwilioProvider {
 			this.releaseCallState(callSid, callIdOverride);
 			return event;
 		}
+		if (callSid && baseEvent.direction === "inbound" && rawCallStatus === null && !params.has("SpeechResult") && !params.has("Digits")) return {
+			...baseEvent,
+			type: "call.initiated"
+		};
 		return null;
 	}
 	static {
@@ -277,7 +286,8 @@ var TwilioProvider = class TwilioProvider {
 	}
 	generateTwimlResponse(ctx) {
 		const params = new URLSearchParams(ctx.rawBody);
-		const isStatusCallback = normalizeOptionalString(ctx.query?.type) === "status";
+		const callbackType = normalizeOptionalString(ctx.query?.type);
+		const isStatusCallback = callbackType === "status" || callbackType === "amd";
 		const callId = normalizeOptionalString(ctx.query?.callId);
 		const callStatus = params.get("CallStatus");
 		const direction = params.get("Direction");
@@ -299,7 +309,8 @@ var TwilioProvider = class TwilioProvider {
 	}
 	consumeInitialTwiML(ctx) {
 		const params = new URLSearchParams(ctx.rawBody);
-		const isStatusCallback = normalizeOptionalString(ctx.query?.type) === "status";
+		const callbackType = normalizeOptionalString(ctx.query?.type);
+		const isStatusCallback = callbackType === "status" || callbackType === "amd";
 		const callId = normalizeOptionalString(ctx.query?.callId);
 		const callSid = params.get("CallSid") || void 0;
 		if (!callId || isStatusCallback) return null;
@@ -361,6 +372,18 @@ var TwilioProvider = class TwilioProvider {
 			],
 			Timeout: "30"
 		};
+		if (input.voicemail?.detection === "twilio") {
+			const amdUrl = new URL(url.toString());
+			amdUrl.searchParams.set("type", "amd");
+			params.MachineDetection = input.voicemail.onMachine === "leave-message" ? "DetectMessageEnd" : "Enable";
+			params.AsyncAmd = "true";
+			params.AsyncAmdStatusCallback = amdUrl.toString();
+			params.AsyncAmdStatusCallbackMethod = "POST";
+			params.MachineDetectionSpeechThreshold = String(input.voicemail.machineDetectionSpeechThresholdMs);
+			params.MachineDetectionSpeechEndThreshold = String(input.voicemail.machineDetectionSpeechEndThresholdMs);
+			params.MachineDetectionSilenceTimeout = String(input.voicemail.machineDetectionSilenceTimeoutMs);
+			params.MachineDetectionTimeout = String(input.voicemail.machineDetectionTimeoutMs / 1e3);
+		}
 		if (input.inlineTwiml) {
 			params.Twiml = input.inlineTwiml;
 			console.log(`[voice-call] Sending direct Twilio initial TwiML for call ${input.callId} (kind=notify)`);
@@ -372,6 +395,9 @@ var TwilioProvider = class TwilioProvider {
 			status: result.status === "queued" ? "queued" : "initiated"
 		};
 	}
+	async playMessageAndHangup(input) {
+		await this.apiRequest(`/Calls/${input.providerCallId}.json`, { Twiml: `<?xml version="1.0" encoding="UTF-8"?><Response><Say voice="${escapeXml(input.voice || "alice")}">${escapeXml(input.text)}</Say><Hangup/></Response>` });
+	}
 	async hangupCall(input) {
 		await this.apiRequest(`/Calls/${input.providerCallId}.json`, { Status: "completed" }, { allowNotFound: true });
 		this.releaseCallState(input.providerCallId, input.callId);
@@ -410,11 +436,6 @@ var TwilioProvider = class TwilioProvider {
 	async sendDtmf(input) {
 		await this.updateLiveCallTwiml(input.providerCallId, generateDtmfRedirectTwiml(input.digits, this.requireCallWebhookUrl(input.providerCallId)), "sendDtmf");
 	}
-	/**
-	* Play TTS via core TTS and Twilio Media Streams.
-	* Generates audio with core TTS, converts to mu-law, and streams via WebSocket.
-	* Uses a queue to serialize playback and prevent overlapping audio.
-	*/
 	async playTtsViaStream(text, streamSid) {
 		if (!this.ttsProvider || !this.mediaStreamHandler) throw new Error("TTS provider and media stream handler required");
 		const CHUNK_SIZE = 160;
@@ -423,41 +444,23 @@ var TwilioProvider = class TwilioProvider {
 		const handler = this.mediaStreamHandler;
 		const ttsProvider = this.ttsProvider;
 		await handler.queueTts(streamSid, async (signal) => {
-			const sendKeepAlive = () => {
-				handler.sendAudio(streamSid, SILENCE_CHUNK);
-			};
-			sendKeepAlive();
+			handler.sendAudio(streamSid, SILENCE_CHUNK);
 			const keepAlive = setInterval(() => {
-				if (!signal.aborted) sendKeepAlive();
+				if (!signal.aborted) handler.sendAudio(streamSid, SILENCE_CHUNK);
 			}, CHUNK_DELAY_MS);
 			let muLawAudio;
-			let synthTimeout = null;
-			let removeAbortListener = () => {};
 			const synthTimeoutMs = ttsProvider.synthesisTimeoutMs;
 			try {
-				const synthPromise = ttsProvider.synthesizeForTelephony(text);
-				const timeoutPromise = new Promise((_, reject) => {
-					synthTimeout = setTimeout(() => {
-						reject(/* @__PURE__ */ new Error(`Telephony TTS synthesis timed out after ${synthTimeoutMs}ms`));
-					}, synthTimeoutMs);
-				});
-				const abortPromise = new Promise((_, reject) => {
-					const onAbort = () => {
-						reject(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Telephony TTS synthesis aborted"));
-					};
-					signal.addEventListener("abort", onAbort, { once: true });
-					removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-					if (signal.aborted) onAbort();
+				muLawAudio = await raceWithTimeout(ttsProvider.synthesizeForTelephony(text), synthTimeoutMs, () => {
+					throw new Error(`Telephony TTS synthesis timed out after ${synthTimeoutMs}ms`);
+				}, {
+					signal,
+					onAbort: () => {
+						throw signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Telephony TTS synthesis aborted");
+					}
 				});
-				muLawAudio = await Promise.race([
-					synthPromise,
-					timeoutPromise,
-					abortPromise
-				]);
 			} finally {
-				if (synthTimeout) clearTimeout(synthTimeout);
 				clearInterval(keepAlive);
-				removeAbortListener();
 			}
 			if (muLawAudio.length === 0) throw new Error("Telephony TTS produced no audio");
 			let chunkAttempts = 0;
@@ -477,7 +480,6 @@ var TwilioProvider = class TwilioProvider {
 					break;
 				}
 				nextChunkDueAt += CHUNK_DELAY_MS;
-				if (signal.aborted) break;
 			}
 			if (signal.aborted) return;
 			const markName = `tts-${Date.now()}-${++this.playbackMarkSequence}`;
@@ -500,23 +502,6 @@ var TwilioProvider = class TwilioProvider {
 		return webhookUrl;
 	}
 	async stopListening(_input) {}
-	async getCallStatus(input) {
-		return readProviderCallStatus(() => guardedJsonApiRequest({
-			url: `${this.baseUrl}/Calls/${input.providerCallId}.json`,
-			method: "GET",
-			headers: { Authorization: `Basic ${Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64")}` },
-			allowNotFound: true,
-			allowedHostnames: [new URL(this.baseUrl).hostname],
-			auditContext: "twilio-get-call-status",
-			errorPrefix: "Twilio get call status error"
-		}), (data) => {
-			const status = normalizeProviderStatus(data.status);
-			return {
-				status,
-				isTerminal: isProviderStatusTerminal(status)
-			};
-		});
-	}
 };
 //#endregion
 export { TwilioProvider };

package/dist/.setup/{voice-mapping-B_iAUkER.mjs → voice-mapping-1lzFmzOF.mjs}

@@ -1,8 +1,5 @@
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/voice-call/src/voice-mapping.ts
-/**
-* Escape XML special characters for TwiML and other XML responses.
-*/
 function escapeXml(text) {
 	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -15,13 +12,6 @@ const OPENAI_TO_POLLY_MAP = /* @__PURE__ */ new Map([
 	["shimmer", "Polly.Kimberly"]
 ]);
 const DEFAULT_POLLY_VOICE = "Polly.Joanna";
-/**
-* Map OpenAI voice names to Twilio Polly equivalents.
-* Falls through if already a valid Polly/Google voice.
-*
-* @param voice - OpenAI voice name (alloy, echo, etc.) or Polly voice name
-* @returns Polly voice name suitable for Twilio TwiML
-*/
 function mapVoiceToPolly(voice) {
 	if (!voice) return DEFAULT_POLLY_VOICE;
 	if (voice.startsWith("Polly.") || voice.startsWith("Google.")) return voice;

package/dist/cli-output-mode.js

@@ -9,6 +9,7 @@ const MACHINE_OUTPUT_COMMANDS = /* @__PURE__ */ new Set([
 	"latency",
 	"speak",
 	"start",
+	"steer",
 	"status",
 	"tail"
 ]);

package/dist/doctor-contract-api.js

@@ -27,28 +27,24 @@ function resolveVoiceCallStateDatabaseEnv(params) {
 		OPENCLAW_STATE_DIR: resolveVoiceCallStorePath(params)
 	};
 }
-function describeVoiceCallSchemaMigration(migration) {
-	switch (migration.kind) {
-		case "agent-databases-composite-primary-key": return "agent database registry primary key -> agent_id,path";
-		case "agent-databases-relative-paths-v9": return "agent database registry paths -> state-relative paths";
-		case "audit-events-v2": return "audit event ledger -> versioned message lifecycle schema";
-		case "commitments-retirement-v7": return "retired commitments storage -> discarded rows, table, and indexes";
-		case "state-table-retirement-v10": return "retired shared-state tables -> removed tables and indexes";
-		case "state-table-retirement-v11": return "retired skill curator tables -> removed tables and indexes";
-		case "singleton-state-foldin-v12": return "singleton state tables -> shared configuration state";
-		case "state-consolidation-v13": return "cron jobs and subagent runs -> canonical JSON storage";
-		case "creator-namespace-v14": return "cron creators -> explicit principal namespaces";
-		case "conversation-binding-targets-v15": return "conversation bindings -> exact target keys without agent/session projections";
-		case "skill-workshop-directory-ownership-v16": return "Skill Workshop proposals -> per-agent Workshop directory ownership";
-		case "prepared-worker-ownership-v17": return "prepared workers -> one-use capacity and fixed workspace ownership";
-		case "github-publication-requester-authority-v18": return "GitHub publication receipts -> original requesting authority";
-		case "worker-placement-execution-mode-v8": return "cloud worker placements -> execution-mode claims";
-		case "operator-approvals-system-agent": return "operator approvals -> OpenClaw system changes";
-		case "session-watch-cursor-provenance-v4": return "session watch cursors -> provenance column";
-		case "strict-tables-v3": return "tables -> SQLite STRICT typing";
-	}
-	return migration.kind;
-}
+const schemaMigrationDescriptions = {
+	"agent-databases-composite-primary-key": "agent database registry primary key -> agent_id,path",
+	"agent-databases-relative-paths-v9": "agent database registry paths -> state-relative paths",
+	"audit-events-v2": "audit event ledger -> versioned message lifecycle schema",
+	"commitments-retirement-v7": "retired commitments storage -> discarded rows, table, and indexes",
+	"state-table-retirement-v10": "retired shared-state tables -> removed tables and indexes",
+	"state-table-retirement-v11": "retired skill curator tables -> removed tables and indexes",
+	"singleton-state-foldin-v12": "singleton state tables -> shared configuration state",
+	"state-consolidation-v13": "cron jobs and subagent runs -> canonical JSON storage",
+	"creator-namespace-v14": "cron creators -> explicit principal namespaces",
+	"conversation-binding-targets-v15": "conversation bindings -> exact target keys without agent/session projections",
+	"prepared-worker-ownership-v17": "prepared workers -> one-use capacity and fixed workspace ownership",
+	"github-publication-requester-authority-v18": "GitHub publication receipts -> original requesting authority",
+	"worker-placement-execution-mode-v8": "cloud worker placements -> execution-mode claims",
+	"operator-approvals-system-agent": "operator approvals -> OpenClaw system changes",
+	"session-watch-cursor-provenance-v4": "session watch cursors -> provenance column",
+	"strict-tables-v3": "tables -> SQLite STRICT typing"
+};
 /** Doctor migrations owned by the voice-call plugin. */
 const stateMigrations = [...stateMigrations$1, {
 	id: "voice-call-sqlite-schema",
@@ -59,7 +55,7 @@ const stateMigrations = [...stateMigrations$1, {
 		const { detectOpenClawStateDatabaseSchemaMigrations } = await import("openclaw/plugin-sdk/doctor-repair-runtime");
 		const schemaMigrations = detectOpenClawStateDatabaseSchemaMigrations({ env: resolveVoiceCallStateDatabaseEnv(params) });
 		if (schemaMigrations.length === 0) return null;
-		return { preview: schemaMigrations.map((migration) => `- Voice Call SQLite schema: ${describeVoiceCallSchemaMigration(migration)}`) };
+		return { preview: schemaMigrations.map((migration) => `- Voice Call SQLite schema: ${schemaMigrationDescriptions[migration.kind]}`) };
 	},
 	async migrateLegacyState(params) {
 		const changes = [];