@alfe.ai/openclaw-voice 0.0.6 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,2 @@
+const require_plugin = require("./plugin.cjs");
+module.exports = require_plugin;

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+import plugin from "./plugin.cjs";
+export { plugin as default };

package/dist/plugin.cjs

@@ -0,0 +1,193 @@
+let _sinclair_typebox = require("@sinclair/typebox");
+let _alfe_ai_config = require("@alfe.ai/config");
+//#region src/plugin.ts
+/**
+* @alfe/voice-plugin — OpenClaw native plugin
+*
+* Thin client that registers voice tools with OpenClaw and forwards
+* TTS/STT operations to the voice service's public API.
+*
+* In the new architecture, voice service is a channel-agnostic pipeline
+* brain. Channel-specific operations (hangup, transfer, DTMF) are handled
+* by the respective channel services (Discord, Twilio, etc.), not voice.
+*
+* This plugin provides:
+*   - voice.speak RPC — converts text to audio via POST /voice/tts
+*   - voice_hangup tool — placeholder (requires channel service)
+*   - voice_transfer tool — placeholder (requires Twilio service)
+*   - voice_dtmf tool �� placeholder (requires Twilio service)
+*/
+const VOICE_CAPABILITIES = [
+	"voice.call",
+	"voice.answer",
+	"voice.dtmf",
+	"voice.hangup"
+];
+let voiceServiceUrl = "";
+let voiceServiceApiKey = "";
+async function voiceApi(method, path, body) {
+	const url = `${voiceServiceUrl}${path}`;
+	const headers = { "Content-Type": "application/json" };
+	if (voiceServiceApiKey) headers["x-api-key"] = voiceServiceApiKey;
+	const res = await fetch(url, {
+		method,
+		headers,
+		body: body ? JSON.stringify(body) : void 0
+	});
+	const json = await res.json();
+	if (!res.ok) {
+		const errorMsg = typeof json.error === "string" ? json.error : `Voice service returned ${String(res.status)}`;
+		throw new Error(errorMsg);
+	}
+	return json;
+}
+let daemonIpcClient = null;
+async function connectToDaemon(socketPath, log) {
+	try {
+		const IPCClientCtor = (await import("@alfe.ai/openclaw")).IPCClient;
+		const client = new IPCClientCtor(socketPath, log);
+		client.on("connected", async () => {
+			log.info("Connected to Alfe daemon — registering voice capabilities...");
+			const response = await client.request("capability.register", {
+				plugin: "@alfe.ai/openclaw-voice",
+				capabilities: [...VOICE_CAPABILITIES]
+			});
+			if (response.ok) log.info("Voice capabilities registered with daemon");
+			else log.warn(`Failed to register voice capabilities: ${response.error?.message ?? "unknown"}`);
+		});
+		client.on("disconnected", (reason) => {
+			log.warn(`Disconnected from Alfe daemon: ${String(reason)}`);
+		});
+		client.on("error", (err) => {
+			log.debug(`Daemon IPC error: ${err.message}`);
+		});
+		client.start();
+		return client;
+	} catch {
+		log.info("Alfe daemon not available — voice plugin running standalone");
+		return null;
+	}
+}
+function ok(data) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(data)
+		}],
+		details: data
+	};
+}
+function errResult(message) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({ error: message })
+		}],
+		details: { error: message }
+	};
+}
+function defineTool(def) {
+	return {
+		name: def.name,
+		description: def.description,
+		label: def.name,
+		parameters: def.parameters,
+		execute: async (_toolCallId, params) => {
+			try {
+				return ok(await def.handler(params));
+			} catch (e) {
+				return errResult(e.message);
+			}
+		}
+	};
+}
+const voiceTools = [
+	defineTool({
+		name: "voice_hangup",
+		description: "Hang up the current voice call or leave the voice channel. Use when the conversation is done or the user asks you to leave.",
+		parameters: _sinclair_typebox.Type.Object({ sessionId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Voice session ID." })) }),
+		handler: () => {
+			throw new Error("voice_hangup requires a channel service (Discord/Twilio). The voice service no longer manages channels directly.");
+		}
+	}),
+	defineTool({
+		name: "voice_transfer",
+		description: "Transfer the current phone call to another number. Only works for Twilio calls.",
+		parameters: _sinclair_typebox.Type.Object({
+			targetNumber: _sinclair_typebox.Type.String({ description: "Phone number to transfer to (E.164 format)" }),
+			sessionId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Voice session ID." }))
+		}),
+		handler: () => {
+			throw new Error("voice_transfer requires the Twilio service. The voice service no longer manages phone calls directly.");
+		}
+	}),
+	defineTool({
+		name: "voice_dtmf",
+		description: "Send DTMF tones (dial pad digits) on the current phone call. Only works for Twilio calls.",
+		parameters: _sinclair_typebox.Type.Object({
+			digits: _sinclair_typebox.Type.String({ description: "DTMF digits to send (0-9, *, #, w for pause)" }),
+			sessionId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Voice session ID." }))
+		}),
+		handler: () => {
+			throw new Error("voice_dtmf requires the Twilio service. The voice service no longer manages phone calls directly.");
+		}
+	})
+];
+const plugin = {
+	id: "@alfe.ai/openclaw-voice",
+	name: "Alfe Voice Plugin",
+	description: "Voice integration — TTS/STT via the voice service, channel-specific operations via channel services",
+	version: "0.2.0",
+	activate(api) {
+		const log = api.logger;
+		for (const tool of voiceTools) api.registerTool(tool);
+		log.info(`Registered ${String(voiceTools.length)} voice tools: ${voiceTools.map((t) => t.name).join(", ")}`);
+		if (!globalThis.__voiceGatewayActivated) {
+			globalThis.__voiceGatewayActivated = true;
+			log.info("Alfe Voice plugin activating...");
+			const fullConfig = api.config ?? {};
+			const pluginConfig = fullConfig.plugins?.entries?.["@alfe.ai/openclaw-voice"]?.config ?? fullConfig.plugins?.entries?.["voice-gateway"]?.config ?? {};
+			voiceServiceUrl = pluginConfig.voiceServiceUrl ?? `http://localhost:${String(pluginConfig.voiceServicePort ?? "3100")}`;
+			voiceServiceApiKey = pluginConfig.voiceServiceApiKey ?? "";
+			log.info(`Voice service: ${voiceServiceUrl}`);
+			let alfeConfig = null;
+			try {
+				alfeConfig = (0, _alfe_ai_config.resolveConfig)();
+			} catch {}
+			connectToDaemon(pluginConfig.daemonSocket ?? alfeConfig?.socketPath ?? _alfe_ai_config.DEFAULT_SOCKET_PATH, log).then((client) => {
+				daemonIpcClient = client;
+			}).catch((err) => {
+				log.debug(`Daemon connect failed: ${err.message}`);
+			});
+		}
+		api.registerGatewayMethod("voice.speak", async (...args) => {
+			const { text } = args[0];
+			log.info(`voice.speak RPC → text=${text?.slice(0, 50) ?? "(none)"}...`);
+			if (!text) throw new Error("voice.speak requires text");
+			return await voiceApi("POST", "/voice/tts", { text });
+		});
+		log.info("Registered gateway RPC method: voice.speak");
+		api.on("message_received", (...eventArgs) => {
+			const event = eventArgs[0];
+			if (eventArgs[1].channelId.includes("voice")) log.debug(`Voice-related message from ${event.from}: ${event.content.slice(0, 100)}`);
+		});
+		log.info("Alfe Voice plugin activated");
+	},
+	deactivate(api) {
+		globalThis.__voiceGatewayActivated = false;
+		const log = api.logger;
+		log.info("Alfe Voice plugin deactivating...");
+		if (daemonIpcClient) {
+			try {
+				daemonIpcClient.stop();
+				log.info("Disconnected from Alfe daemon");
+			} catch (err) {
+				log.debug(`Error disconnecting from daemon: ${err.message}`);
+			}
+			daemonIpcClient = null;
+		}
+		log.info("Alfe Voice plugin deactivated");
+	}
+};
+//#endregion
+module.exports = plugin;

package/dist/plugin.d.cts

@@ -0,0 +1,59 @@
+import { TSchema } from "@sinclair/typebox";
+
+//#region src/plugin.d.ts
+
+interface Logger {
+  info(msg: string, ...args: unknown[]): void;
+  warn(msg: string, ...args: unknown[]): void;
+  error(msg: string, ...args: unknown[]): void;
+  debug(msg: string, ...args: unknown[]): void;
+}
+interface VoicePluginConfig {
+  voiceServiceUrl?: string;
+  voiceServicePort?: string | number;
+  voiceServiceApiKey?: string;
+  daemonSocket?: string;
+  [key: string]: unknown;
+}
+interface OpenClawConfig {
+  plugins?: {
+    entries?: Record<string, {
+      config?: VoicePluginConfig;
+      [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+interface OpenClawPluginApi {
+  logger: Logger;
+  config?: OpenClawConfig;
+  registerTool(tool: ToolDef): void;
+  registerGatewayMethod(name: string, handler: (...args: unknown[]) => Promise<unknown>): void;
+  on(event: string, handler: (...args: unknown[]) => void | Promise<void>, options?: {
+    priority?: number;
+  }): void;
+}
+interface ToolDef {
+  name: string;
+  description: string;
+  label: string;
+  parameters: TSchema;
+  execute: (toolCallId: string, params: Record<string, unknown>) => Promise<{
+    content: {
+      type: 'text';
+      text: string;
+    }[];
+    details: unknown;
+  }>;
+}
+declare const plugin: {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  activate(api: OpenClawPluginApi): void;
+  deactivate(api: OpenClawPluginApi): void;
+};
+//#endregion
+export { plugin as default };

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@alfe.ai/openclaw-voice",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "OpenClaw voice plugin for Alfe — Discord audio, Twilio, Recall.ai",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
     },
     "./plugin": {
-      "import": "./dist/plugin.js",
-      "types": "./dist/plugin.d.ts"
+      "types": "./dist/plugin.d.ts",
+      "require": "./dist/plugin.cjs",
+      "import": "./dist/plugin.js"
     }
   },
   "openclaw": {
@@ -26,7 +28,7 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "@alfe.ai/config": "0.0.6"
+    "@alfe.ai/config": "0.0.7"
   },
   "scripts": {
     "build": "tsdown",