niahere 0.3.0 → 0.3.2

package/src/mcp/tools.ts

@@ -1,5 +1,5 @@
-import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
-import type { ScheduleType } from "../types";
+import { readFileSync, appendFileSync, existsSync } from "fs";
+import type { Recipient, ScheduleType } from "../types";
 import { basename, join } from "path";
 import { randomUUID } from "crypto";
 import { Job, Message, Session } from "../db/models";
@@ -8,7 +8,6 @@ import { getConfig, readRawConfig, updateRawConfig, writeRawConfig } from "../ut
 import { getPaths } from "../utils/paths";
 import { getChannel } from "../channels/registry";
 import { log } from "../utils/log";
-import { classifyMime } from "../utils/attachment";
 import { scanAgents } from "../core/agents";
 import { listEmployeesForMcp } from "../core/employees";
 import { resolveJobPrompt } from "../core/job-prompt";
@@ -312,42 +311,27 @@ export async function sendMessage(
   }
 
   try {
-    // Handle media attachment if provided
+    let media: { data: Uint8Array; mimeType: string; filename: string } | undefined;
     if (mediaPath) {
       if (!existsSync(mediaPath)) {
         if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
         return `Failed to send: file not found: ${mediaPath}`;
       }
-      const data = readFileSync(mediaPath);
-      const mimeType = guessMime(mediaPath);
-      const filename = basename(mediaPath);
-
-      if (useThread && channel?.sendMediaToThread) {
-        await channel.sendMediaToThread(sourceCtx!.slackChannelId!, data, mimeType, filename, sourceCtx!.slackThreadTs);
-      } else if (channel?.sendMedia) {
-        await channel.sendMedia(data, mimeType, filename);
-      } else {
-        await sendMediaDirect(channelTarget, data, mimeType, filename);
-      }
+      const buf = readFileSync(mediaPath);
+      media = { data: new Uint8Array(buf), mimeType: guessMime(mediaPath), filename: basename(mediaPath) };
+    }
 
-      // Also send text if provided (as a separate message)
-      if (text) {
-        if (useThread && channel?.sendToThread) {
-          await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
-        } else if (channel?.sendMessage) {
-          await channel.sendMessage(text);
-        } else {
-          await sendDirect(channelTarget, text);
-        }
-      }
+    const recipient: Recipient = useThread
+      ? { kind: "thread", channelId: sourceCtx!.slackChannelId!, threadTs: sourceCtx!.slackThreadTs }
+      : { kind: "owner" };
+
+    if (channel) {
+      await channel.deliver({ text: text || undefined, media, to: recipient });
     } else {
-      if (useThread && channel?.sendToThread) {
-        await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
-      } else if (channel?.sendMessage) {
-        await channel.sendMessage(text);
-      } else {
-        await sendDirect(channelTarget, text);
-      }
+      // No started channel in this process (e.g. CLI `nia send` outside the daemon).
+      // Fall back to API-direct send — text-only, no thread fan-out.
+      if (media) await sendMediaDirect(channelTarget, Buffer.from(media.data), media.mimeType, media.filename);
+      if (text) await sendDirect(channelTarget, text);
     }
 
     // Mark as sent
@@ -480,7 +464,7 @@ export async function placeCall(args: {
   const { getPhoneChannel } = await import("../channels/phone");
   const phone = getPhoneChannel();
   if (!phone) {
-    return "Phone channel is not configured. Add a channels.phone block to ~/.niahere/config.yaml with twilio_sid, twilio_secret, from_number, public_base_url, openai_api_key (or set the matching env vars in .env), then restart the daemon.";
+    return "Phone channel is not configured. Add channels.twilio.{sid, secret, public_base_url} and channels.phone.{from_number, openai_api_key} to ~/.niahere/config.yaml (or set the matching env vars in .env), then restart the daemon.";
   }
   try {
     const result = await phone.placeCall({

package/src/types/channel.ts

@@ -1,13 +1,42 @@
+/**
+ * Where an outbound payload is delivered.
+ *
+ * - `owner` → the channel's configured default recipient (DM user, owner
+ *   phone number, etc.). Always supported.
+ * - `thread` → reply in a specific Slack thread. Channels that don't
+ *   support threads fall back to `owner`.
+ */
+export type Recipient = { kind: "owner" } | { kind: "thread"; channelId: string; threadTs?: string };
+
+export interface OutboundMedia {
+  data: Uint8Array;
+  mimeType: string;
+  filename?: string;
+}
+
+/**
+ * Structured payload for agent-initiated outbound messages (`send_message`
+ * MCP tool, cross-channel notifications). Replaces the old optional
+ * sendMessage / sendMedia / sendToThread / sendMediaToThread surface.
+ */
+export interface Outbound {
+  text?: string;
+  media?: OutboundMedia;
+  /** Defaults to `{ kind: "owner" }`. */
+  to?: Recipient;
+}
+
 export interface Channel {
+  /** Channel identifier. Built-in channels use the `ChannelName` literals; test fixtures may use other strings. */
   name: string;
   start(): Promise<void>;
   stop(): Promise<void>;
-  sendMessage?(text: string): Promise<void>;
-  sendMedia?(data: Buffer, mimeType: string, filename?: string): Promise<void>;
-  /** Send media to a specific channel/thread when the channel supports it. */
-  sendMediaToThread?(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void>;
-  /** Send a message to a specific channel/thread (e.g. reply back to a Slack thread). */
-  sendToThread?(channelId: string, text: string, threadTs?: string): Promise<void>;
+  /**
+   * Deliver an outbound payload. Channels are expected to handle either
+   * a text-only, media-only, or text+media payload; format details (chunking,
+   * markdown, attachment shape) are channel-specific.
+   */
+  deliver(out: Outbound): Promise<void>;
 }
 
 export type ChannelFactory = () => Channel | null;

package/src/types/config.ts

@@ -28,23 +28,36 @@ export interface SlackConfig {
   watch: Record<string, SlackWatchChannel> | null;
 }
 
-export interface PhoneConfig {
-  twilio_sid: string | null;
-  twilio_secret: string | null;
-  /** Account-level Auth Token used to verify X-Twilio-Signature on inbound webhooks.
-   *  Falls back to twilio_secret if not set (works when twilio_sid is the Account SID
-   *  and twilio_secret is the Auth Token). */
-  twilio_auth_token: string | null;
-  /** Twilio number Nia dials from (E.164, e.g. +13025480697) */
-  from_number: string | null;
-  /** Owner's phone number (E.164). Highest-trust caller. */
+/**
+ * Shared config for all Twilio-based channels (phone/sms/whatsapp).
+ * Credentials, owner identity, public URL, and the local webhook port
+ * live here so individual channels don't reach into each other's configs.
+ */
+export interface TwilioConfig {
+  /** SID used for both URL paths and Basic auth.
+   * Usually the Account SID (AC…). Can be an API Key SID (SK…) — Twilio resolves it. */
+  sid: string | null;
+  /** Basic auth password. Account Auth Token if sid is AC…, API Key Secret if SK…. */
+  secret: string | null;
+  /** Account-level Auth Token. Used to verify X-Twilio-Signature on inbound webhooks.
+   * If sid is an API Key SID (SK…), this MUST be set separately. Falls back to `secret`
+   * when sid is an Account SID and `secret` is the Auth Token. */
+  auth_token: string | null;
+  /** Owner's phone number (E.164). Highest-trust caller / messenger. */
   owner_number: string | null;
   /** Extra allowlisted E.164 numbers (family, close contacts). */
   allowlist: string[];
   /** Public base URL Twilio hits (e.g. https://nia.example.com). No trailing slash. */
   public_base_url: string | null;
-  /** Local HTTP port for the Twilio webhook server. */
+  /** Local HTTP port the shared Twilio webhook server binds to. */
   port: number;
+}
+
+/** Voice (Twilio Programmable Voice + OpenAI Realtime). */
+export interface PhoneConfig {
+  enabled: boolean;
+  /** Twilio number Nia dials from / inbound voice number (E.164). */
+  from_number: string | null;
   /** OpenAI API key for the Realtime voice loop. */
   openai_api_key: string | null;
   /** OpenAI Realtime model id. */
@@ -53,12 +66,29 @@ export interface PhoneConfig {
   voice: string;
 }
 
+/** SMS via Twilio (uses the shared TwilioConfig credentials). */
+export interface SmsConfig {
+  enabled: boolean;
+  /** E.164 number SMS is sent from. Defaults to phone.from_number. */
+  from_number: string | null;
+}
+
+/** WhatsApp via Twilio (sandbox by default; uses shared TwilioConfig). */
+export interface WhatsappConfig {
+  enabled: boolean;
+  /** WhatsApp sender E.164. Defaults to Twilio Sandbox shared number +14155238886. */
+  from_number: string | null;
+}
+
 export interface ChannelsConfig {
   enabled: boolean;
   default: string;
   telegram: TelegramConfig;
   slack: SlackConfig;
+  twilio: TwilioConfig;
   phone: PhoneConfig;
+  sms: SmsConfig;
+  whatsapp: WhatsappConfig;
 }
 
 export interface SessionFinalizationConfig {

package/src/types/enums.ts

@@ -17,4 +17,4 @@ export type Mode = "chat" | "job";
 export type AttachmentType = "image" | "document" | "file";
 
 /** Channel names. */
-export type ChannelName = "telegram" | "slack";
+export type ChannelName = "telegram" | "slack" | "phone" | "sms" | "whatsapp";

package/src/types/index.ts

@@ -3,9 +3,18 @@ export type { JobStatus, JobStateStatus, JobLifecycle, ScheduleType, Mode, Attac
 export type { JobInput, JobPromptSource, JobResult, ResolvedJobPrompt } from "./job";
 export type { SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "./engine";
 export type { AuditEntry, JobState, CronState } from "./audit";
-export type { Channel, ChannelFactory } from "./channel";
+export type { Channel, ChannelFactory, Outbound, OutboundMedia, Recipient } from "./channel";
 export type { ChatState } from "./chat-state";
-export type { Config, ChannelsConfig, TelegramConfig, SlackConfig, PhoneConfig } from "./config";
+export type {
+  Config,
+  ChannelsConfig,
+  TelegramConfig,
+  SlackConfig,
+  TwilioConfig,
+  PhoneConfig,
+  SmsConfig,
+  WhatsappConfig,
+} from "./config";
 export type { Paths } from "./paths";
 export type { SaveMessageParams, RoomStats, RecentMessage, SearchResult, SessionMessage } from "./message";
 export type { AgentInfo } from "./agent";

package/src/utils/attachment.ts

@@ -1,5 +1,11 @@
 import type { AttachmentType } from "../types";
-import { IMAGE_MIMES, DOCUMENT_MIMES, MAX_ATTACHMENT_SIZE, MAX_IMAGE_DIMENSION, JPEG_QUALITY } from "../constants/attachment";
+import {
+  IMAGE_MIMES,
+  DOCUMENT_MIMES,
+  MAX_ATTACHMENT_SIZE,
+  MAX_IMAGE_DIMENSION,
+  JPEG_QUALITY,
+} from "../constants/attachment";
 
 export function classifyMime(mimeType: string): AttachmentType | null {
   if (IMAGE_MIMES.has(mimeType)) return "image";
@@ -8,7 +14,7 @@ export function classifyMime(mimeType: string): AttachmentType | null {
   return "file";
 }
 
-export function validateAttachment(data: Buffer, mimeType: string): string | null {
+export function validateAttachment(data: Buffer): string | null {
   if (data.length > MAX_ATTACHMENT_SIZE) {
     return `File too large (${(data.length / 1024 / 1024).toFixed(1)}MB, max ${MAX_ATTACHMENT_SIZE / 1024 / 1024}MB)`;
   }

package/src/utils/config.ts

@@ -36,19 +36,30 @@ const DEFAULTS: Config = {
       workspace_url: null,
       watch: null,
     },
-    phone: {
-      twilio_sid: null,
-      twilio_secret: null,
-      twilio_auth_token: null,
-      from_number: null,
+    twilio: {
+      sid: null,
+      secret: null,
+      auth_token: null,
       owner_number: null,
       allowlist: [],
       public_base_url: null,
       port: 7079,
+    },
+    phone: {
+      enabled: true,
+      from_number: null,
       openai_api_key: null,
       realtime_model: "gpt-realtime",
       voice: "marin",
     },
+    sms: {
+      enabled: true,
+      from_number: null,
+    },
+    whatsapp: {
+      enabled: true,
+      from_number: "+14155238886",
+    },
   },
 };
 
@@ -131,6 +142,15 @@ export function loadConfig(): Config {
   const chTg = (ch.telegram || {}) as Record<string, unknown>;
   const chSl = (ch.slack || {}) as Record<string, unknown>;
   const chPh = (ch.phone || {}) as Record<string, unknown>;
+  const chTw = (ch.twilio || {}) as Record<string, unknown>;
+  const chSms = (ch.sms || {}) as Record<string, unknown>;
+  const chWa = (ch.whatsapp || {}) as Record<string, unknown>;
+
+  const twilioField = (key: string, envKey: string | null): string | null => {
+    const envVal = envKey ? process.env[envKey] : undefined;
+    if (envVal) return envVal;
+    return typeof chTw[key] === "string" ? (chTw[key] as string) : null;
+  };
 
   const channelsEnabled = ch.enabled !== false;
 
@@ -150,11 +170,7 @@ export function loadConfig(): Config {
 
   const slAppToken = process.env.SLACK_APP_TOKEN || (typeof chSl.app_token === "string" ? chSl.app_token : null);
 
-  // Legacy: channel_id was removed in favor of dm_user_id. Fall back to channel_id if dm_user_id is not set.
-  const legacyChannelId =
-    process.env.SLACK_CHANNEL_ID || (typeof chSl.channel_id === "string" ? chSl.channel_id : null);
-  const slDmUserId =
-    process.env.SLACK_DM_USER_ID || (typeof chSl.dm_user_id === "string" ? chSl.dm_user_id : null) || legacyChannelId;
+  const slDmUserId = process.env.SLACK_DM_USER_ID || (typeof chSl.dm_user_id === "string" ? chSl.dm_user_id : null);
 
   const slBotUserId = typeof chSl.bot_user_id === "string" ? chSl.bot_user_id : null;
   const slBotName = typeof chSl.bot_name === "string" ? chSl.bot_name : null;
@@ -162,29 +178,35 @@ export function loadConfig(): Config {
   const slWorkspaceId = typeof chSl.workspace_id === "string" ? chSl.workspace_id : null;
   const slWorkspaceUrl = typeof chSl.workspace_url === "string" ? chSl.workspace_url : null;
 
-  // Phone — env vars override config; secrets are env-only by convention
-  const phTwilioSid = process.env.TWILIO_SID || (typeof chPh.twilio_sid === "string" ? chPh.twilio_sid : null);
-  const phTwilioSecret =
-    process.env.TWILIO_SECRET || (typeof chPh.twilio_secret === "string" ? chPh.twilio_secret : null);
-  const phTwilioAuthToken =
-    process.env.TWILIO_AUTH_TOKEN || (typeof chPh.twilio_auth_token === "string" ? chPh.twilio_auth_token : null);
+  // --- Twilio shared config (used by phone, sms, whatsapp) ---
+  // Env vars take precedence over channels.twilio.* values.
+  const twSid = twilioField("sid", "TWILIO_SID");
+  const twSecret = twilioField("secret", "TWILIO_SECRET");
+  const twAuthToken = twilioField("auth_token", "TWILIO_AUTH_TOKEN");
+  const twOwnerNumber = twilioField("owner_number", "PRIMARY_PHONE_USER");
+  const twPublicBaseUrl = (twilioField("public_base_url", "PUBLIC_BASE_URL") || "").replace(/\/$/, "") || null;
+
+  const twPortRaw = process.env.PHONE_PORT ? Number(process.env.PHONE_PORT) : null;
+  const twPort =
+    twPortRaw && Number.isFinite(twPortRaw)
+      ? twPortRaw
+      : typeof chTw.port === "number"
+        ? chTw.port
+        : DEFAULTS.channels.twilio.port;
+
+  const twAllowlistRaw =
+    process.env.PHONE_ALLOWLIST ||
+    (Array.isArray(chTw.allowlist)
+      ? (chTw.allowlist as unknown[]).filter((x): x is string => typeof x === "string").join(",")
+      : "");
+  const twAllowlist = twAllowlistRaw
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+
+  // --- Phone (voice) — env vars override config ---
   const phFromNumber =
     process.env.PHONE_FROM_NUMBER || (typeof chPh.from_number === "string" ? chPh.from_number : null);
-  const phOwnerNumber =
-    process.env.PRIMARY_PHONE_USER || (typeof chPh.owner_number === "string" ? chPh.owner_number : null);
-  const phPublicBaseUrl =
-    (
-      process.env.PUBLIC_BASE_URL ||
-      (typeof chPh.public_base_url === "string" ? chPh.public_base_url : null) ||
-      ""
-    ).replace(/\/$/, "") || null;
-  const phPortRaw = process.env.PHONE_PORT ? Number(process.env.PHONE_PORT) : null;
-  const phPort =
-    phPortRaw && Number.isFinite(phPortRaw)
-      ? phPortRaw
-      : typeof chPh.port === "number"
-        ? chPh.port
-        : DEFAULTS.channels.phone.port;
   const phOpenAiKey =
     process.env.OPENAI_API_KEY || (typeof chPh.openai_api_key === "string" ? chPh.openai_api_key : null);
   const phRealtimeModel =
@@ -192,16 +214,18 @@ export function loadConfig(): Config {
     (typeof chPh.realtime_model === "string" ? chPh.realtime_model : DEFAULTS.channels.phone.realtime_model);
   const phVoice =
     process.env.PHONE_VOICE || (typeof chPh.voice === "string" ? chPh.voice : DEFAULTS.channels.phone.voice);
+  const phEnabled = chPh.enabled !== false;
 
-  const phAllowlistRaw =
-    process.env.PHONE_ALLOWLIST ||
-    (Array.isArray(chPh.allowlist)
-      ? (chPh.allowlist as unknown[]).filter((x): x is string => typeof x === "string").join(",")
-      : "");
-  const phAllowlist = phAllowlistRaw
-    .split(",")
-    .map((s) => s.trim())
-    .filter((s) => s.length > 0);
+  // --- SMS ---
+  const smsFromNumber =
+    process.env.SMS_FROM_NUMBER || (typeof chSms.from_number === "string" ? chSms.from_number : null);
+  const smsEnabled = chSms.enabled !== false;
+
+  // --- WhatsApp ---
+  const waFromNumber =
+    process.env.WHATSAPP_FROM_NUMBER ||
+    (typeof chWa.from_number === "string" ? chWa.from_number : DEFAULTS.channels.whatsapp.from_number);
+  const waEnabled = chWa.enabled !== false;
 
   // Slack watch channels — behavior is optional (defaults to key name lookup)
   const rawWatch = chSl.watch as Record<string, unknown> | undefined;
@@ -242,19 +266,30 @@ export function loadConfig(): Config {
         workspace_url: slWorkspaceUrl,
         watch: slWatch,
       },
+      twilio: {
+        sid: twSid,
+        secret: twSecret,
+        auth_token: twAuthToken,
+        owner_number: twOwnerNumber,
+        allowlist: twAllowlist,
+        public_base_url: twPublicBaseUrl,
+        port: twPort,
+      },
       phone: {
-        twilio_sid: phTwilioSid,
-        twilio_secret: phTwilioSecret,
-        twilio_auth_token: phTwilioAuthToken,
+        enabled: phEnabled,
         from_number: phFromNumber,
-        owner_number: phOwnerNumber,
-        allowlist: phAllowlist,
-        public_base_url: phPublicBaseUrl,
-        port: phPort,
         openai_api_key: phOpenAiKey,
         realtime_model: phRealtimeModel,
         voice: phVoice,
       },
+      sms: {
+        enabled: smsEnabled,
+        from_number: smsFromNumber,
+      },
+      whatsapp: {
+        enabled: waEnabled,
+        from_number: waFromNumber,
+      },
     },
   };
 }

package/src/channels/phone/twilio.ts

@@ -1,125 +0,0 @@
-/**
- * Minimal Twilio REST + webhook-signature helpers.
- * Skips the official SDK so the daemon's dependency surface stays small —
- * the surface we use (place call, hang up, swap URL, validate signature) is
- * a handful of well-documented endpoints.
- */
-import { createHmac, timingSafeEqual } from "crypto";
-
-const TWILIO_BASE = "https://api.twilio.com/2010-04-01";
-
-interface TwilioCreds {
-  accountSid: string;
-  authToken: string;
-}
-
-function basicAuth({ accountSid, authToken }: TwilioCreds): string {
-  return `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
-}
-
-function accountUrl({ accountSid }: TwilioCreds, suffix: string): string {
-  return `${TWILIO_BASE}/Accounts/${encodeURIComponent(accountSid)}${suffix}`;
-}
-
-/**
- * Validate a Twilio webhook signature.
- * Algorithm (per Twilio's webhook security docs):
- *   1. Take the full URL Twilio sent the request to (including query string).
- *   2. For application/x-www-form-urlencoded bodies, sort POST keys and
- *      append each "key" + "value" to the URL string.
- *   3. HMAC-SHA1 with the account AuthToken, base64-encode.
- *   4. Timing-safe compare with the X-Twilio-Signature header.
- */
-export function validateTwilioSignature(opts: {
-  authToken: string;
-  fullUrl: string;
-  params: Record<string, string>;
-  signature: string;
-}): boolean {
-  const { authToken, fullUrl, params, signature } = opts;
-  if (!signature) return false;
-
-  const sortedKeys = Object.keys(params).sort();
-  let data = fullUrl;
-  for (const key of sortedKeys) {
-    data += key + params[key];
-  }
-
-  const computed = createHmac("sha1", authToken).update(data, "utf8").digest("base64");
-  const a = Buffer.from(computed);
-  const b = Buffer.from(signature);
-  if (a.length !== b.length) return false;
-  return timingSafeEqual(a, b);
-}
-
-export interface PlaceCallOpts extends TwilioCreds {
-  to: string;
-  from: string;
-  twimlUrl: string;
-  statusCallbackUrl?: string;
-  /** Hard cap on call duration (seconds). Maps to Twilio's TimeLimit param. */
-  maxDurationSec?: number;
-}
-
-export interface PlaceCallResult {
-  callSid: string;
-  status: string;
-}
-
-export async function placeCall(opts: PlaceCallOpts): Promise<PlaceCallResult> {
-  const body = new URLSearchParams({
-    To: opts.to,
-    From: opts.from,
-    Url: opts.twimlUrl,
-    Method: "POST",
-  });
-  if (opts.statusCallbackUrl) {
-    body.set("StatusCallback", opts.statusCallbackUrl);
-    body.set("StatusCallbackMethod", "POST");
-    body.append("StatusCallbackEvent", "initiated");
-    body.append("StatusCallbackEvent", "answered");
-    body.append("StatusCallbackEvent", "completed");
-  }
-  if (opts.maxDurationSec && opts.maxDurationSec > 0) {
-    body.set("TimeLimit", String(opts.maxDurationSec));
-  }
-
-  const resp = await fetch(accountUrl(opts, "/Calls.json"), {
-    method: "POST",
-    headers: { Authorization: basicAuth(opts), "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`Twilio placeCall failed: ${resp.status} ${text}`);
-  }
-  const data = (await resp.json()) as { sid: string; status: string };
-  return { callSid: data.sid, status: data.status };
-}
-
-/** Swap the TwiML URL on an in-flight call (used to inject the real callSid into the path). */
-export async function updateCallUrl(opts: TwilioCreds & { callSid: string; url: string }): Promise<void> {
-  const body = new URLSearchParams({ Url: opts.url, Method: "POST" });
-  const resp = await fetch(accountUrl(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`), {
-    method: "POST",
-    headers: { Authorization: basicAuth(opts), "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`Twilio updateCallUrl failed: ${resp.status} ${text}`);
-  }
-}
-
-export async function hangupCall(opts: TwilioCreds & { callSid: string }): Promise<void> {
-  const body = new URLSearchParams({ Status: "completed" });
-  const resp = await fetch(accountUrl(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`), {
-    method: "POST",
-    headers: { Authorization: basicAuth(opts), "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString(),
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    throw new Error(`Twilio hangupCall failed: ${resp.status} ${text}`);
-  }
-}