@clawvoice/voice-assistant 1.0.0

package/dist/telephony/twilio.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwilioTelephonyAdapter = void 0;
+const util_1 = require("./util");
+class TwilioTelephonyAdapter {
+    constructor(config, fetchFn) {
+        this.config = config;
+        this.fetchFn = fetchFn ?? globalThis.fetch;
+    }
+    providerName() {
+        return "twilio";
+    }
+    async startCall(input) {
+        const normalizedTo = (0, util_1.normalizeE164)(input.to);
+        if (!this.config.twilioAccountSid ||
+            !this.config.twilioAuthToken ||
+            !this.config.twilioPhoneNumber) {
+            throw new Error("Twilio credentials missing: twilioAccountSid, twilioAuthToken, and twilioPhoneNumber are required");
+        }
+        const url = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioAccountSid}/Calls.json`;
+        const from = input.from ?? this.config.twilioPhoneNumber;
+        const twiml = `<Response><Say>${input.greeting ?? "Hello"}</Say></Response>`;
+        const body = new URLSearchParams({
+            To: normalizedTo,
+            From: from ?? "",
+            Twiml: twiml,
+        });
+        const auth = Buffer.from(`${this.config.twilioAccountSid}:${this.config.twilioAuthToken}`).toString("base64");
+        const response = await this.fetchFn(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Basic ${auth}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: body.toString(),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`Twilio API error (${response.status}): ${errorText}`);
+        }
+        const data = (await response.json());
+        return {
+            providerCallId: data.sid,
+            normalizedTo,
+        };
+    }
+    async hangup(providerCallId) {
+        if (!this.config.twilioAccountSid || !this.config.twilioAuthToken) {
+            return;
+        }
+        const url = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioAccountSid}/Calls/${providerCallId}.json`;
+        const auth = Buffer.from(`${this.config.twilioAccountSid}:${this.config.twilioAuthToken}`).toString("base64");
+        await this.fetchFn(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Basic ${auth}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body: new URLSearchParams({ Status: "completed" }).toString(),
+        }).catch(() => undefined);
+    }
+}
+exports.TwilioTelephonyAdapter = TwilioTelephonyAdapter;

package/dist/telephony/types.d.ts

@@ -0,0 +1,15 @@
+export interface StartCallInput {
+    to: string;
+    from?: string;
+    greeting?: string;
+    purpose?: string;
+}
+export interface StartCallResult {
+    providerCallId: string;
+    normalizedTo: string;
+}
+export interface TelephonyProviderAdapter {
+    providerName(): string;
+    startCall(input: StartCallInput): Promise<StartCallResult>;
+    hangup(providerCallId: string): Promise<void>;
+}

package/dist/telephony/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/telephony/util.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeE164(phoneNumber: string): string;
+export declare function simulatedCallId(prefix: string): string;

package/dist/telephony/util.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeE164 = normalizeE164;
+exports.simulatedCallId = simulatedCallId;
+function normalizeE164(phoneNumber) {
+    if (phoneNumber.startsWith("+")) {
+        const digits = phoneNumber.replace(/\D/g, "");
+        if (digits.length < 10) {
+            throw new Error("Invalid international phone number. Must contain at least 10 digits.");
+        }
+        return `+${digits}`;
+    }
+    const digits = phoneNumber.replace(/\D/g, "");
+    if (digits.length !== 10) {
+        throw new Error("Invalid US phone number. Provide exactly 10 digits or valid E.164 number.");
+    }
+    return `+1${digits}`;
+}
+function simulatedCallId(prefix) {
+    const now = Date.now();
+    const random = Math.floor(Math.random() * 1000000)
+        .toString()
+        .padStart(6, "0");
+    return `${prefix}-${now}-${random}`;
+}

package/dist/tools.d.ts

@@ -0,0 +1,5 @@
+import { PluginAPI } from "@openclaw/plugin-sdk";
+import { ClawVoiceConfig } from "./config";
+import { VoiceCallService } from "./services/voice-call";
+import { MemoryExtractionService } from "./services/memory-extraction";
+export declare function registerTools(api: PluginAPI, config: ClawVoiceConfig, callService: VoiceCallService, memoryService?: MemoryExtractionService): void;

package/dist/tools.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTools = registerTools;
+function readString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function registerTools(api, config, callService, memoryService) {
+    api.tools.register({
+        name: "voice_assistant.call",
+        description: "Initiate an outbound voice call",
+        parameters: {
+            type: "object",
+            properties: {
+                phoneNumber: {
+                    type: "string",
+                    description: "Phone number in E.164 format",
+                },
+                purpose: {
+                    type: "string",
+                    description: "Brief description of call purpose",
+                },
+                greeting: {
+                    type: "string",
+                    description: "Custom greeting spoken at call start (overrides default)",
+                },
+            },
+            required: ["phoneNumber"],
+        },
+        handler: async (input) => {
+            const phoneNumber = readString(input.phoneNumber);
+            if (!phoneNumber) {
+                throw new Error("phoneNumber is required and must be a non-empty string.");
+            }
+            const purpose = readString(input.purpose);
+            const greeting = readString(input.greeting);
+            const result = await callService.startCall({
+                phoneNumber,
+                purpose,
+                greeting,
+            });
+            return {
+                content: `${result.message} Greeting: \"${result.openingGreeting}\"`,
+                data: {
+                    callId: result.callId,
+                    to: result.to,
+                    provider: config.telephonyProvider,
+                    purpose: purpose ?? null,
+                },
+            };
+        },
+    });
+    api.tools.register({
+        name: "voice_assistant.hangup",
+        description: "End an active voice call",
+        parameters: {
+            type: "object",
+            properties: {
+                callId: {
+                    type: "string",
+                    description: "Call ID to hang up. Omit for most recent.",
+                },
+            },
+        },
+        handler: async (input) => {
+            const result = await callService.hangup(readString(input.callId));
+            return {
+                content: result.message,
+                data: {
+                    callId: result.callId,
+                },
+            };
+        },
+    });
+    api.tools.register({
+        name: "voice_assistant.status",
+        description: "Get active call status or post-call summary with retry context",
+        parameters: {
+            type: "object",
+            properties: {
+                callId: {
+                    type: "string",
+                    description: "Specific call ID to get summary for (optional)",
+                },
+            },
+        },
+        handler: async (input) => {
+            const summaryCallId = readString(input.callId);
+            if (summaryCallId) {
+                const summary = callService.getCallSummary(summaryCallId);
+                if (summary) {
+                    const failureText = summary.failures.length > 0
+                        ? ` Failures: ${summary.failures.map((f) => f.description).join("; ")}.`
+                        : "";
+                    const retryText = summary.retryContext
+                        ? ` Retry suggestion: ${summary.retryContext.suggestedApproach}`
+                        : "";
+                    return {
+                        content: `Call ${summaryCallId}: ${summary.outcome}.${failureText}${retryText}`,
+                        data: { summary },
+                    };
+                }
+            }
+            const activeCalls = callService.getActiveCalls();
+            return {
+                content: activeCalls.length > 0
+                    ? `There are ${activeCalls.length} active call(s).`
+                    : "No active calls.",
+                data: {
+                    activeCalls,
+                },
+            };
+        },
+    });
+    api.tools.register({
+        name: "voice_assistant.promote_memory",
+        description: "Review and promote a voice memory to main MEMORY.md. Requires operator confirmation.",
+        parameters: {
+            type: "object",
+            properties: {
+                memoryId: {
+                    type: "string",
+                    description: "ID of the voice memory entry to promote",
+                },
+                confirm: {
+                    type: "boolean",
+                    description: "Set to true to confirm promotion. First call without confirm to preview.",
+                },
+            },
+            required: ["memoryId"],
+        },
+        handler: async (input) => {
+            const memoryId = readString(input.memoryId);
+            if (!memoryId) {
+                throw new Error("memoryId is required.");
+            }
+            if (!memoryService) {
+                return { content: "Memory extraction service not available." };
+            }
+            const candidate = memoryService.getCandidate(memoryId);
+            if (!candidate) {
+                return { content: `Memory candidate ${memoryId} not found.` };
+            }
+            const confirmed = input.confirm === true || input.confirm === "true";
+            if (!confirmed) {
+                return {
+                    content: `Preview: "${candidate.content}" (${candidate.category}, confidence: ${candidate.confidence}). Call again with confirm: true to promote.`,
+                    data: {
+                        memoryId,
+                        category: candidate.category,
+                        content: candidate.content,
+                        requiresConfirmation: true,
+                    },
+                };
+            }
+            const result = await memoryService.approveAndPromote(memoryId);
+            if (result.promoted) {
+                return {
+                    content: `Memory ${memoryId} promoted to main memory (${candidate.category}).`,
+                    data: { memoryId, category: candidate.category },
+                };
+            }
+            return { content: `Promotion failed: ${result.reason}` };
+        },
+    });
+}

package/dist/voice/bridge.d.ts

@@ -0,0 +1,47 @@
+import { AudioCodec, BridgeEvent, BridgeSessionConfig, CallFailure, CallSummary, CodecNegotiationResult, DisconnectionReason, DisconnectionRecord, FunctionCallRequest, FunctionCallResponse, TranscriptEntry, TurnState, VoiceAgentMessageResult } from "./types";
+import { ClawVoiceConfig } from "../config";
+export interface VoiceWebSocket {
+    send(data: string | Buffer): void;
+    close(): void;
+    readyState: number;
+}
+export type DisconnectionHandler = (record: DisconnectionRecord) => void;
+export declare class VoiceBridgeService {
+    private readonly config;
+    private readonly bridges;
+    private disconnectionHandler;
+    constructor(config: ClawVoiceConfig);
+    onDisconnection(handler: DisconnectionHandler): void;
+    negotiateAndValidate(telephonyCodec?: AudioCodec, voiceProviderCodec?: AudioCodec, sampleRate?: number): CodecNegotiationResult;
+    createSession(sessionConfig: BridgeSessionConfig): BridgeEvent;
+    buildSettingsMessage(sessionConfig: BridgeSessionConfig): Record<string, unknown>;
+    setVoiceSocket(callId: string, socket: VoiceWebSocket): void;
+    getVoiceSocket(callId: string): VoiceWebSocket | null;
+    startKeepAlive(callId: string, intervalMs: number): void;
+    recordActivity(callId: string): void;
+    startHeartbeatMonitor(callId: string, timeoutMs?: number): void;
+    stopHeartbeatMonitor(callId: string): void;
+    reportDisconnection(callId: string, reason: DisconnectionReason, detail: string): DisconnectionRecord | null;
+    getDisconnectionRecord(callId: string): DisconnectionRecord | null;
+    endGreetingGrace(callId: string): void;
+    isGreetingGraceActive(callId: string): boolean;
+    bufferTelephonyAudio(callId: string, chunk: Buffer): Buffer | null;
+    flushAudioBuffer(callId: string): Buffer | null;
+    addTranscriptEntry(callId: string, entry: TranscriptEntry): void;
+    getTranscript(callId: string): TranscriptEntry[];
+    destroySession(callId: string): BridgeEvent;
+    handleVoiceAgentMessage(callId: string, message: Record<string, unknown>): VoiceAgentMessageResult;
+    handleBargeIn(callId: string): VoiceAgentMessageResult;
+    completeFunctionCall(callId: string, response: FunctionCallResponse): boolean;
+    getTurnState(callId: string): TurnState;
+    setTurnState(callId: string, state: TurnState): void;
+    getPendingFunctionCalls(callId: string): FunctionCallRequest[];
+    recordFailure(callId: string, failure: CallFailure): void;
+    getFailures(callId: string): CallFailure[];
+    generateCallSummary(callId: string): CallSummary | null;
+    private determineOutcome;
+    private buildRetryContext;
+    getActiveBridgeCount(): number;
+    hasActiveBridge(callId: string): boolean;
+    stopAll(): Promise<void>;
+}