loudmouth-ai 0.1.0 → 0.2.0

package/extensions/voice-call/src/response-generator.ts

@@ -1,171 +0,0 @@
-/**
- * Voice call response generator - uses the embedded Pi agent for tool support.
- * Routes voice responses through the same agent infrastructure as messaging.
- */
-
-import crypto from "node:crypto";
-
-import { loadCoreAgentDeps, type CoreConfig } from "./core-bridge.js";
-
-import type { VoiceCallConfig } from "./config.js";
-
-export type VoiceResponseParams = {
-  /** Voice call config */
-  voiceConfig: VoiceCallConfig;
-  /** Core Clawdbot config */
-  coreConfig: CoreConfig;
-  /** Call ID for session tracking */
-  callId: string;
-  /** Caller's phone number */
-  from: string;
-  /** Conversation transcript */
-  transcript: Array<{ speaker: "user" | "bot"; text: string }>;
-  /** Latest user message */
-  userMessage: string;
-};
-
-export type VoiceResponseResult = {
-  text: string | null;
-  error?: string;
-};
-
-type SessionEntry = {
-  sessionId: string;
-  updatedAt: number;
-};
-
-/**
- * Generate a voice response using the embedded Pi agent with full tool support.
- * Uses the same agent infrastructure as messaging for consistent behavior.
- */
-export async function generateVoiceResponse(
-  params: VoiceResponseParams,
-): Promise<VoiceResponseResult> {
-  const { voiceConfig, callId, from, transcript, userMessage, coreConfig } =
-    params;
-
-  if (!coreConfig) {
-    return { text: null, error: "Core config unavailable for voice response" };
-  }
-
-  let deps: Awaited<ReturnType<typeof loadCoreAgentDeps>>;
-  try {
-    deps = await loadCoreAgentDeps();
-  } catch (err) {
-    return {
-      text: null,
-      error:
-        err instanceof Error
-          ? err.message
-          : "Unable to load core agent dependencies",
-    };
-  }
-  const cfg = coreConfig;
-
-  // Build voice-specific session key based on phone number
-  const normalizedPhone = from.replace(/\D/g, "");
-  const sessionKey = `voice:${normalizedPhone}`;
-  const agentId = "main";
-
-  // Resolve paths
-  const storePath = deps.resolveStorePath(cfg.session?.store, { agentId });
-  const agentDir = deps.resolveAgentDir(cfg, agentId);
-  const workspaceDir = deps.resolveAgentWorkspaceDir(cfg, agentId);
-
-  // Ensure workspace exists
-  await deps.ensureAgentWorkspace({ dir: workspaceDir });
-
-  // Load or create session entry
-  const sessionStore = deps.loadSessionStore(storePath);
-  const now = Date.now();
-  let sessionEntry = sessionStore[sessionKey] as SessionEntry | undefined;
-
-  if (!sessionEntry) {
-    sessionEntry = {
-      sessionId: crypto.randomUUID(),
-      updatedAt: now,
-    };
-    sessionStore[sessionKey] = sessionEntry;
-    await deps.saveSessionStore(storePath, sessionStore);
-  }
-
-  const sessionId = sessionEntry.sessionId;
-  const sessionFile = deps.resolveSessionFilePath(sessionId, sessionEntry, {
-    agentId,
-  });
-
-  // Resolve model from config
-  const modelRef =
-    voiceConfig.responseModel ||
-    `${deps.DEFAULT_PROVIDER}/${deps.DEFAULT_MODEL}`;
-  const slashIndex = modelRef.indexOf("/");
-  const provider =
-    slashIndex === -1 ? deps.DEFAULT_PROVIDER : modelRef.slice(0, slashIndex);
-  const model = slashIndex === -1 ? modelRef : modelRef.slice(slashIndex + 1);
-
-  // Resolve thinking level
-  const thinkLevel = deps.resolveThinkingDefault({ cfg, provider, model });
-
-  // Resolve agent identity for personalized prompt
-  const identity = deps.resolveAgentIdentity(cfg, agentId);
-  const agentName = identity?.name?.trim() || "assistant";
-
-  // Build system prompt with conversation history
-  const basePrompt =
-    voiceConfig.responseSystemPrompt ??
-    `You are ${agentName}, a helpful voice assistant on a phone call. Keep responses brief and conversational (1-2 sentences max). Be natural and friendly. The caller's phone number is ${from}. You have access to tools - use them when helpful.`;
-
-  let extraSystemPrompt = basePrompt;
-  if (transcript.length > 0) {
-    const history = transcript
-      .map(
-        (entry) =>
-          `${entry.speaker === "bot" ? "You" : "Caller"}: ${entry.text}`,
-      )
-      .join("\n");
-    extraSystemPrompt = `${basePrompt}\n\nConversation so far:\n${history}`;
-  }
-
-  // Resolve timeout
-  const timeoutMs =
-    voiceConfig.responseTimeoutMs ?? deps.resolveAgentTimeoutMs({ cfg });
-  const runId = `voice:${callId}:${Date.now()}`;
-
-  try {
-    const result = await deps.runEmbeddedPiAgent({
-      sessionId,
-      sessionKey,
-      messageProvider: "voice",
-      sessionFile,
-      workspaceDir,
-      config: cfg,
-      prompt: userMessage,
-      provider,
-      model,
-      thinkLevel,
-      verboseLevel: "off",
-      timeoutMs,
-      runId,
-      lane: "voice",
-      extraSystemPrompt,
-      agentDir,
-    });
-
-    // Extract text from payloads
-    const texts = (result.payloads ?? [])
-      .filter((p) => p.text && !p.isError)
-      .map((p) => p.text?.trim())
-      .filter(Boolean);
-
-    const text = texts.join(" ") || null;
-
-    if (!text && result.meta.aborted) {
-      return { text: null, error: "Response generation was aborted" };
-    }
-
-    return { text };
-  } catch (err) {
-    console.error(`[voice-call] Response generation failed:`, err);
-    return { text: null, error: String(err) };
-  }
-}

package/extensions/voice-call/src/runtime.ts

@@ -1,205 +0,0 @@
-import type { CoreConfig } from "./core-bridge.js";
-import type { VoiceCallConfig } from "./config.js";
-import { resolveVoiceCallConfig, validateProviderConfig } from "./config.js";
-import { CallManager } from "./manager.js";
-import type { VoiceCallProvider } from "./providers/base.js";
-import { MockProvider } from "./providers/mock.js";
-import { PlivoProvider } from "./providers/plivo.js";
-import { TelnyxProvider } from "./providers/telnyx.js";
-import { TwilioProvider } from "./providers/twilio.js";
-import type { TelephonyTtsRuntime } from "./telephony-tts.js";
-import { createTelephonyTtsProvider } from "./telephony-tts.js";
-import { startTunnel, type TunnelResult } from "./tunnel.js";
-import {
-  cleanupTailscaleExposure,
-  setupTailscaleExposure,
-  VoiceCallWebhookServer,
-} from "./webhook.js";
-
-export type VoiceCallRuntime = {
-  config: VoiceCallConfig;
-  provider: VoiceCallProvider;
-  manager: CallManager;
-  webhookServer: VoiceCallWebhookServer;
-  webhookUrl: string;
-  publicUrl: string | null;
-  stop: () => Promise<void>;
-};
-
-type Logger = {
-  info: (message: string) => void;
-  warn: (message: string) => void;
-  error: (message: string) => void;
-  debug: (message: string) => void;
-};
-
-function resolveProvider(config: VoiceCallConfig): VoiceCallProvider {
-  switch (config.provider) {
-    case "telnyx":
-      return new TelnyxProvider({
-        apiKey: config.telnyx?.apiKey,
-        connectionId: config.telnyx?.connectionId,
-        publicKey: config.telnyx?.publicKey,
-      });
-    case "twilio":
-      return new TwilioProvider(
-        {
-          accountSid: config.twilio?.accountSid,
-          authToken: config.twilio?.authToken,
-        },
-        {
-          allowNgrokFreeTier: config.tunnel?.allowNgrokFreeTier ?? false,
-          publicUrl: config.publicUrl,
-          skipVerification: config.skipSignatureVerification,
-          streamPath: config.streaming?.enabled
-            ? config.streaming.streamPath
-            : undefined,
-        },
-      );
-    case "plivo":
-      return new PlivoProvider(
-        {
-          authId: config.plivo?.authId,
-          authToken: config.plivo?.authToken,
-        },
-        {
-          publicUrl: config.publicUrl,
-          skipVerification: config.skipSignatureVerification,
-          ringTimeoutSec: Math.max(1, Math.floor(config.ringTimeoutMs / 1000)),
-        },
-      );
-    case "mock":
-      return new MockProvider();
-    default:
-      throw new Error(
-        `Unsupported voice-call provider: ${String(config.provider)}`,
-      );
-  }
-}
-
-export async function createVoiceCallRuntime(params: {
-  config: VoiceCallConfig;
-  coreConfig: CoreConfig;
-  ttsRuntime?: TelephonyTtsRuntime;
-  logger?: Logger;
-}): Promise<VoiceCallRuntime> {
-  const { config: rawConfig, coreConfig, ttsRuntime, logger } = params;
-  const log = logger ?? {
-    info: console.log,
-    warn: console.warn,
-    error: console.error,
-    debug: console.debug,
-  };
-
-  const config = resolveVoiceCallConfig(rawConfig);
-
-  if (!config.enabled) {
-    throw new Error(
-      "Voice call disabled. Enable the plugin entry in config.",
-    );
-  }
-
-  const validation = validateProviderConfig(config);
-  if (!validation.valid) {
-    throw new Error(`Invalid voice-call config: ${validation.errors.join("; ")}`);
-  }
-
-  const provider = resolveProvider(config);
-  const manager = new CallManager(config);
-  const webhookServer = new VoiceCallWebhookServer(
-    config,
-    manager,
-    provider,
-    coreConfig,
-  );
-
-  const localUrl = await webhookServer.start();
-
-  // Determine public URL - priority: config.publicUrl > tunnel > legacy tailscale
-  let publicUrl: string | null = config.publicUrl ?? null;
-  let tunnelResult: TunnelResult | null = null;
-
-  if (!publicUrl && config.tunnel?.provider && config.tunnel.provider !== "none") {
-    try {
-      tunnelResult = await startTunnel({
-        provider: config.tunnel.provider,
-        port: config.serve.port,
-        path: config.serve.path,
-        ngrokAuthToken: config.tunnel.ngrokAuthToken,
-        ngrokDomain: config.tunnel.ngrokDomain,
-      });
-      publicUrl = tunnelResult?.publicUrl ?? null;
-    } catch (err) {
-      log.error(
-        `[voice-call] Tunnel setup failed: ${
-          err instanceof Error ? err.message : String(err)
-        }`,
-      );
-    }
-  }
-
-  if (!publicUrl && config.tailscale?.mode !== "off") {
-    publicUrl = await setupTailscaleExposure(config);
-  }
-
-  const webhookUrl = publicUrl ?? localUrl;
-
-  if (publicUrl && provider.name === "twilio") {
-    (provider as TwilioProvider).setPublicUrl(publicUrl);
-  }
-
-  if (provider.name === "twilio" && config.streaming?.enabled) {
-    const twilioProvider = provider as TwilioProvider;
-    if (ttsRuntime?.textToSpeechTelephony) {
-      try {
-        const ttsProvider = createTelephonyTtsProvider({
-          coreConfig,
-          ttsOverride: config.tts,
-          runtime: ttsRuntime,
-        });
-        twilioProvider.setTTSProvider(ttsProvider);
-        log.info("[voice-call] Telephony TTS provider configured");
-      } catch (err) {
-        log.warn(
-          `[voice-call] Failed to initialize telephony TTS: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-        );
-      }
-    } else {
-      log.warn("[voice-call] Telephony TTS unavailable; streaming TTS disabled");
-    }
-
-    const mediaHandler = webhookServer.getMediaStreamHandler();
-    if (mediaHandler) {
-      twilioProvider.setMediaStreamHandler(mediaHandler);
-      log.info("[voice-call] Media stream handler wired to provider");
-    }
-  }
-
-  manager.initialize(provider, webhookUrl);
-
-  const stop = async () => {
-    if (tunnelResult) {
-      await tunnelResult.stop();
-    }
-    await cleanupTailscaleExposure(config);
-    await webhookServer.stop();
-  };
-
-  log.info("[voice-call] Runtime initialized");
-  log.info(`[voice-call] Webhook URL: ${webhookUrl}`);
-  if (publicUrl) {
-    log.info(`[voice-call] Public URL: ${publicUrl}`);
-  }
-
-  return {
-    config,
-    provider,
-    manager,
-    webhookServer,
-    webhookUrl,
-    publicUrl,
-    stop,
-  };
-}

package/extensions/voice-call/src/telephony-audio.ts

@@ -1,88 +0,0 @@
-const TELEPHONY_SAMPLE_RATE = 8000;
-
-function clamp16(value: number): number {
-  return Math.max(-32768, Math.min(32767, value));
-}
-
-/**
- * Resample 16-bit PCM (little-endian mono) to 8kHz using linear interpolation.
- */
-export function resamplePcmTo8k(input: Buffer, inputSampleRate: number): Buffer {
-  if (inputSampleRate === TELEPHONY_SAMPLE_RATE) return input;
-  const inputSamples = Math.floor(input.length / 2);
-  if (inputSamples === 0) return Buffer.alloc(0);
-
-  const ratio = inputSampleRate / TELEPHONY_SAMPLE_RATE;
-  const outputSamples = Math.floor(inputSamples / ratio);
-  const output = Buffer.alloc(outputSamples * 2);
-
-  for (let i = 0; i < outputSamples; i++) {
-    const srcPos = i * ratio;
-    const srcIndex = Math.floor(srcPos);
-    const frac = srcPos - srcIndex;
-
-    const s0 = input.readInt16LE(srcIndex * 2);
-    const s1Index = Math.min(srcIndex + 1, inputSamples - 1);
-    const s1 = input.readInt16LE(s1Index * 2);
-
-    const sample = Math.round(s0 + frac * (s1 - s0));
-    output.writeInt16LE(clamp16(sample), i * 2);
-  }
-
-  return output;
-}
-
-/**
- * Convert 16-bit PCM to 8-bit mu-law (G.711).
- */
-export function pcmToMulaw(pcm: Buffer): Buffer {
-  const samples = Math.floor(pcm.length / 2);
-  const mulaw = Buffer.alloc(samples);
-
-  for (let i = 0; i < samples; i++) {
-    const sample = pcm.readInt16LE(i * 2);
-    mulaw[i] = linearToMulaw(sample);
-  }
-
-  return mulaw;
-}
-
-export function convertPcmToMulaw8k(
-  pcm: Buffer,
-  inputSampleRate: number,
-): Buffer {
-  const pcm8k = resamplePcmTo8k(pcm, inputSampleRate);
-  return pcmToMulaw(pcm8k);
-}
-
-/**
- * Chunk audio buffer into 20ms frames for streaming (8kHz mono mu-law).
- */
-export function chunkAudio(
-  audio: Buffer,
-  chunkSize = 160,
-): Generator<Buffer, void, unknown> {
-  return (function* () {
-    for (let i = 0; i < audio.length; i += chunkSize) {
-      yield audio.subarray(i, Math.min(i + chunkSize, audio.length));
-    }
-  })();
-}
-
-function linearToMulaw(sample: number): number {
-  const BIAS = 132;
-  const CLIP = 32635;
-
-  const sign = sample < 0 ? 0x80 : 0;
-  if (sample < 0) sample = -sample;
-  if (sample > CLIP) sample = CLIP;
-
-  sample += BIAS;
-  let exponent = 7;
-  for (let expMask = 0x4000; (sample & expMask) === 0 && exponent > 0; exponent--) {
-    expMask >>= 1;
-  }
-
-  const mantissa = (sample >> (exponent + 3)) & 0x0f;
-  return ~(sign | (exponent << 4) | mantissa) & 0xff;
-}

package/extensions/voice-call/src/telephony-tts.ts

@@ -1,95 +0,0 @@
-import type { CoreConfig } from "./core-bridge.js";
-import type { VoiceCallTtsConfig } from "./config.js";
-import { convertPcmToMulaw8k } from "./telephony-audio.js";
-
-export type TelephonyTtsRuntime = {
-  textToSpeechTelephony: (params: {
-    text: string;
-    cfg: CoreConfig;
-    prefsPath?: string;
-  }) => Promise<{
-    success: boolean;
-    audioBuffer?: Buffer;
-    sampleRate?: number;
-    provider?: string;
-    error?: string;
-  }>;
-};
-
-export type TelephonyTtsProvider = {
-  synthesizeForTelephony: (text: string) => Promise<Buffer>;
-};
-
-export function createTelephonyTtsProvider(params: {
-  coreConfig: CoreConfig;
-  ttsOverride?: VoiceCallTtsConfig;
-  runtime: TelephonyTtsRuntime;
-}): TelephonyTtsProvider {
-  const { coreConfig, ttsOverride, runtime } = params;
-  const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
-
-  return {
-    synthesizeForTelephony: async (text: string) => {
-      const result = await runtime.textToSpeechTelephony({
-        text,
-        cfg: mergedConfig,
-      });
-
-      if (!result.success || !result.audioBuffer || !result.sampleRate) {
-        throw new Error(result.error ?? "TTS conversion failed");
-      }
-
-      return convertPcmToMulaw8k(result.audioBuffer, result.sampleRate);
-    },
-  };
-}
-
-function applyTtsOverride(
-  coreConfig: CoreConfig,
-  override?: VoiceCallTtsConfig,
-): CoreConfig {
-  if (!override) return coreConfig;
-
-  const base = coreConfig.messages?.tts;
-  const merged = mergeTtsConfig(base, override);
-  if (!merged) return coreConfig;
-
-  return {
-    ...coreConfig,
-    messages: {
-      ...(coreConfig.messages ?? {}),
-      tts: merged,
-    },
-  };
-}
-
-function mergeTtsConfig(
-  base?: VoiceCallTtsConfig,
-  override?: VoiceCallTtsConfig,
-): VoiceCallTtsConfig | undefined {
-  if (!base && !override) return undefined;
-  if (!override) return base;
-  if (!base) return override;
-  return deepMerge(base, override);
-}
-
-function deepMerge<T>(base: T, override: T): T {
-  if (!isPlainObject(base) || !isPlainObject(override)) {
-    return override;
-  }
-  const result: Record<string, unknown> = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === undefined) continue;
-    const existing = (base as Record<string, unknown>)[key];
-    if (isPlainObject(existing) && isPlainObject(value)) {
-      result[key] = deepMerge(existing, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result as T;
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}