npm - @hasna/assistants - Versions diffs - 1.1.8 → 1.1.10 - Mend

@hasna/assistants 1.1.8 → 1.1.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/lib.js CHANGED Viewed

@@ -110939,7 +110939,7 @@ await init_runtime();
 // ../core/src/agent/loop.ts
 init_src2();
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 // ../core/src/agent/context.ts
 init_src2();
@@ -124618,7 +124618,9 @@ class BuiltinCommands {
     loader.register(this.messagesCommand());
     loader.register(this.webhooksCommand());
     loader.register(this.channelsCommand());
+    loader.register(this.phoneCommand());
     loader.register(this.tasksCommand());
+    loader.register(this.setupCommand());
     loader.register(this.exitCommand());
   }
   voiceCommand() {
@@ -127904,6 +127906,208 @@ Configure the external source with the URL and secret above.
         context.emit("text", `Unknown command: ${subcommand}
 `);
         context.emit("text", `Use /channels help for available commands.
+`);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  phoneCommand() {
+    return {
+      name: "phone",
+      description: "Manage telephony: SMS, calls, WhatsApp, routing",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const trimmed = args.trim();
+        const [subcommand, ...rest] = trimmed.split(/\s+/);
+        const subArgs = rest.join(" ");
+        if (!subcommand || subcommand === "ui") {
+          context.emit("done");
+          return { handled: true, showPanel: "telephony" };
+        }
+        const manager = context.getTelephonyManager?.();
+        if (!manager) {
+          context.emit("text", `Telephony is not enabled. Set telephony.enabled: true in config.
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "numbers") {
+          const numbers = manager.listPhoneNumbers();
+          if (numbers.length === 0) {
+            context.emit("text", `No phone numbers configured. Use /phone sync to import from Twilio.
+`);
+          } else {
+            context.emit("text", `Phone Numbers (${numbers.length}):
+`);
+            for (const num of numbers) {
+              const caps = [];
+              if (num.capabilities.voice)
+                caps.push("voice");
+              if (num.capabilities.sms)
+                caps.push("sms");
+              if (num.capabilities.whatsapp)
+                caps.push("whatsapp");
+              const name = num.friendlyName ? ` (${num.friendlyName})` : "";
+              context.emit("text", `  ${num.number}${name} [${caps.join(", ")}]
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "sync") {
+          context.emit("text", `Syncing phone numbers from Twilio...
+`);
+          const result = await manager.syncPhoneNumbers();
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "sms") {
+          const smsParts = subArgs.trim().split(/\s+/);
+          const smsAction = smsParts[0];
+          if (smsAction === "send") {
+            const to = smsParts[1];
+            const body = smsParts.slice(2).join(" ");
+            if (!to || !body) {
+              context.emit("text", `Usage: /phone sms send <to> <body>
+`);
+              context.emit("done");
+              return { handled: true };
+            }
+            const result = await manager.sendSms(to, body);
+            context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          } else if (smsAction === "list" || !smsAction) {
+            const messages = manager.getSmsHistory({ limit: 20 });
+            if (messages.length === 0) {
+              context.emit("text", `No SMS history.
+`);
+            } else {
+              context.emit("text", `Recent SMS (${messages.length}):
+`);
+              for (const msg of messages) {
+                const dir = msg.direction === "inbound" ? "IN" : "OUT";
+                context.emit("text", `  [${dir}] ${msg.fromNumber} \u2192 ${msg.toNumber}: ${msg.bodyPreview}
+`);
+              }
+            }
+          } else {
+            context.emit("text", `Usage: /phone sms [send <to> <body> | list]
+`);
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "call") {
+          const to = subArgs.trim();
+          if (!to) {
+            context.emit("text", `Usage: /phone call <to>
+`);
+            context.emit("done");
+            return { handled: true };
+          }
+          const result = await manager.makeCall(to);
+          context.emit("text", `${result.success ? result.message : `Error: ${result.message}`}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "calls") {
+          const calls = manager.getCallHistory({ limit: 20 });
+          if (calls.length === 0) {
+            context.emit("text", `No call history.
+`);
+          } else {
+            context.emit("text", `Recent Calls (${calls.length}):
+`);
+            for (const call of calls) {
+              const dir = call.direction === "inbound" ? "IN" : "OUT";
+              const dur = call.duration != null ? `${call.duration}s` : "-";
+              context.emit("text", `  [${dir}] ${call.fromNumber} \u2192 ${call.toNumber} | ${call.status} | ${dur}
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "routes") {
+          const rules = manager.listRoutingRules();
+          if (rules.length === 0) {
+            context.emit("text", `No routing rules configured.
+`);
+          } else {
+            context.emit("text", `Routing Rules (${rules.length}):
+`);
+            for (const rule of rules) {
+              const enabled = rule.enabled ? "" : " [DISABLED]";
+              context.emit("text", `  ${rule.name} (priority: ${rule.priority})${enabled}
+`);
+              context.emit("text", `    Target: ${rule.targetAssistantName} | Type: ${rule.messageType}
+`);
+            }
+          }
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "status") {
+          const status = manager.getStatus();
+          context.emit("text", `Telephony Status:
+`);
+          context.emit("text", `  Enabled:       ${status.enabled ? "Yes" : "No"}
+`);
+          context.emit("text", `  Twilio:        ${status.twilioConfigured ? "Configured" : "Not configured"}
+`);
+          context.emit("text", `  ElevenLabs:    ${status.elevenLabsConfigured ? "Configured" : "Not configured"}
+`);
+          context.emit("text", `  Numbers:       ${status.phoneNumbers}
+`);
+          context.emit("text", `  Active calls:  ${status.activeCalls}
+`);
+          context.emit("text", `  Routes:        ${status.routingRules}
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        if (subcommand === "help") {
+          context.emit("text", `Phone Commands:
+`);
+          context.emit("text", `/phone                         Open telephony panel
+`);
+          context.emit("text", `/phone numbers                 List phone numbers
+`);
+          context.emit("text", `/phone sync                    Sync numbers from Twilio
+`);
+          context.emit("text", `/phone sms send <to> <body>    Send SMS
+`);
+          context.emit("text", `/phone sms list                Recent SMS
+`);
+          context.emit("text", `/phone call <to>               Initiate call
+`);
+          context.emit("text", `/phone calls                   Recent calls
+`);
+          context.emit("text", `/phone routes                  Routing rules
+`);
+          context.emit("text", `/phone status                  Status summary
+`);
+          context.emit("text", `/phone help                    Show this help
+`);
+          context.emit("done");
+          return { handled: true };
+        }
+        context.emit("text", `Unknown command: ${subcommand}
+`);
+        context.emit("text", `Use /phone help for available commands.
 `);
         context.emit("done");
         return { handled: true };
@@ -128391,6 +128595,20 @@ Unknown workspace command. Use /workspace help for available commands.
       }
     };
   }
+  setupCommand() {
+    return {
+      name: "setup",
+      aliases: ["onboarding"],
+      description: "Run the interactive setup wizard",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (_args, context) => {
+        context.emit("done");
+        return { handled: true, showPanel: "setup" };
+      }
+    };
+  }
   exitCommand() {
     return {
       name: "exit",
@@ -150618,6 +150836,7 @@ class ChannelStore {
         role TEXT NOT NULL DEFAULT 'member',
         joined_at TEXT NOT NULL,
         last_read_at TEXT,
+        member_type TEXT NOT NULL DEFAULT 'assistant',
         PRIMARY KEY (channel_id, assistant_id)
       );
@@ -150635,6 +150854,16 @@ class ChannelStore {
       CREATE INDEX IF NOT EXISTS idx_channel_members_assistant
         ON channel_members(assistant_id);
     `);
+    this.migrateAddMemberType();
+  }
+  migrateAddMemberType() {
+    try {
+      const columns = this.db.prepare("PRAGMA table_info(channel_members)").all();
+      const hasMemberType = columns.some((col) => String(col.name) === "member_type");
+      if (!hasMemberType) {
+        this.db.exec("ALTER TABLE channel_members ADD COLUMN member_type TEXT NOT NULL DEFAULT 'assistant'");
+      }
+    } catch {}
   }
   createChannel(name2, description, createdBy, createdByName) {
     const normalizedName = name2.toLowerCase().replace(/^#/, "").replace(/[^a-z0-9_-]/g, "-");
@@ -150729,12 +150958,12 @@ class ChannelStore {
     const result = stmt.run("archived", now2, id, "active");
     return result.changes > 0;
   }
-  addMember(channelId, assistantId, assistantName, role = "member") {
+  addMember(channelId, assistantId, assistantName, role = "member", memberType = "assistant") {
     try {
       const now2 = new Date().toISOString();
-      const stmt = this.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, assistant_id, assistant_name, role, joined_at)
-         VALUES (?, ?, ?, ?, ?)`);
-      const result = stmt.run(channelId, assistantId, assistantName, role, now2);
+      const stmt = this.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, assistant_id, assistant_name, role, joined_at, member_type)
+         VALUES (?, ?, ?, ?, ?, ?)`);
+      const result = stmt.run(channelId, assistantId, assistantName, role, now2, memberType);
       return result.changes > 0;
     } catch {
       return false;
@@ -150874,7 +151103,8 @@ class ChannelStore {
       assistantName: String(row.assistant_name),
       role: String(row.role),
       joinedAt: String(row.joined_at),
-      lastReadAt: row.last_read_at ? String(row.last_read_at) : null
+      lastReadAt: row.last_read_at ? String(row.last_read_at) : null,
+      memberType: row.member_type ? String(row.member_type) : "assistant"
     };
   }
   rowToMessage(row) {
@@ -150952,7 +151182,7 @@ class ChannelsManager {
     this.store.removeMember(channel.id, this.assistantId);
     return { success: true, message: `Left #${channel.name}.`, channelId: channel.id };
   }
-  invite(nameOrId, targetId, targetName) {
+  invite(nameOrId, targetId, targetName, memberType = "assistant") {
     const channel = this.store.resolveChannel(nameOrId);
     if (!channel) {
       return { success: false, message: `Channel "${nameOrId}" not found.` };
@@ -150963,7 +151193,7 @@ class ChannelsManager {
     if (this.store.isMember(channel.id, targetId)) {
       return { success: false, message: `${targetName} is already a member of #${channel.name}.` };
     }
-    this.store.addMember(channel.id, targetId, targetName);
+    this.store.addMember(channel.id, targetId, targetName, "member", memberType);
     return {
       success: true,
       message: `Invited ${targetName} to #${channel.name}.`,
@@ -150994,6 +151224,24 @@ class ChannelsManager {
       channelId: channel.id
     };
   }
+  sendAs(nameOrId, content, senderId, senderName) {
+    const channel = this.store.resolveChannel(nameOrId);
+    if (!channel) {
+      return { success: false, message: `Channel "${nameOrId}" not found.` };
+    }
+    if (channel.status !== "active") {
+      return { success: false, message: `Channel #${channel.name} is archived.` };
+    }
+    if (!this.store.isMember(channel.id, senderId)) {
+      return { success: false, message: `${senderName} is not a member of #${channel.name}. Join first.` };
+    }
+    const messageId = this.store.sendMessage(channel.id, senderId, senderName, content);
+    return {
+      success: true,
+      message: `Message sent to #${channel.name} (${messageId}).`,
+      channelId: channel.id
+    };
+  }
   readMessages(nameOrId, limit2) {
     const channel = this.store.resolveChannel(nameOrId);
     if (!channel)
@@ -151361,25 +151609,1728 @@ function registerChannelTools(registry2, getChannelsManager) {
     registry2.register(tool, executors[tool.name]);
   }
 }
+// ../core/src/telephony/store.ts
+init_src2();
+await __promiseAll([
+  init_config(),
+  init_runtime()
+]);
+import { join as join44, dirname as dirname18 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync17 } from "fs";
+function generatePhoneId() {
+  return `ph_${generateId().slice(0, 12)}`;
+}
+function generateCallId() {
+  return `call_${generateId().slice(0, 12)}`;
+}
+function generateSmsId() {
+  return `sms_${generateId().slice(0, 12)}`;
+}
+function generateRuleId() {
+  return `rule_${generateId().slice(0, 12)}`;
+}
+class TelephonyStore {
+  db;
+  constructor(dbPath) {
+    const baseDir = getConfigDir();
+    const path2 = dbPath || join44(baseDir, "telephony.db");
+    const dir = dirname18(path2);
+    if (!existsSync27(dir)) {
+      mkdirSync17(dir, { recursive: true });
+    }
+    const runtime = getRuntime();
+    this.db = runtime.openDatabase(path2);
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS phone_numbers (
+        id TEXT PRIMARY KEY,
+        number TEXT NOT NULL UNIQUE,
+        friendly_name TEXT,
+        twilio_sid TEXT,
+        status TEXT NOT NULL DEFAULT 'active',
+        voice_capable INTEGER NOT NULL DEFAULT 1,
+        sms_capable INTEGER NOT NULL DEFAULT 1,
+        whatsapp_capable INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS call_logs (
+        id TEXT PRIMARY KEY,
+        call_sid TEXT,
+        from_number TEXT NOT NULL,
+        to_number TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        assistant_id TEXT,
+        duration INTEGER,
+        recording_url TEXT,
+        started_at TEXT,
+        ended_at TEXT,
+        created_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS sms_logs (
+        id TEXT PRIMARY KEY,
+        message_sid TEXT,
+        from_number TEXT NOT NULL,
+        to_number TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        message_type TEXT NOT NULL DEFAULT 'sms',
+        body TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'queued',
+        assistant_id TEXT,
+        created_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS routing_rules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        priority INTEGER NOT NULL DEFAULT 100,
+        from_pattern TEXT,
+        to_pattern TEXT,
+        message_type TEXT NOT NULL DEFAULT 'all',
+        time_of_day TEXT,
+        day_of_week TEXT,
+        keyword TEXT,
+        target_assistant_id TEXT NOT NULL,
+        target_assistant_name TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_call_logs_assistant ON call_logs(assistant_id);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_status ON call_logs(status);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_created ON call_logs(created_at);
+      CREATE INDEX IF NOT EXISTS idx_call_logs_sid ON call_logs(call_sid);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_assistant ON sms_logs(assistant_id);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_created ON sms_logs(created_at);
+      CREATE INDEX IF NOT EXISTS idx_sms_logs_sid ON sms_logs(message_sid);
+      CREATE INDEX IF NOT EXISTS idx_routing_rules_priority ON routing_rules(priority, enabled);
+    `);
+  }
+  addPhoneNumber(number, friendlyName, twilioSid, capabilities) {
+    const id = generatePhoneId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO phone_numbers (id, number, friendly_name, twilio_sid, voice_capable, sms_capable, whatsapp_capable, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, number, friendlyName, twilioSid, capabilities?.voice !== false ? 1 : 0, capabilities?.sms !== false ? 1 : 0, capabilities?.whatsapp ? 1 : 0, now2, now2);
+    return this.getPhoneNumber(id);
+  }
+  getPhoneNumber(id) {
+    const row = this.db.prepare("SELECT * FROM phone_numbers WHERE id = ?").get(id);
+    return row ? this.rowToPhoneNumber(row) : null;
+  }
+  getPhoneNumberByNumber(number) {
+    const row = this.db.prepare("SELECT * FROM phone_numbers WHERE number = ?").get(number);
+    return row ? this.rowToPhoneNumber(row) : null;
+  }
+  listPhoneNumbers(status) {
+    let query = "SELECT * FROM phone_numbers";
+    const params = [];
+    if (status) {
+      query += " WHERE status = ?";
+      params.push(status);
+    }
+    query += " ORDER BY created_at DESC";
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((r6) => this.rowToPhoneNumber(r6));
+  }
+  updatePhoneNumberStatus(id, status) {
+    const now2 = new Date().toISOString();
+    const result = this.db.prepare("UPDATE phone_numbers SET status = ?, updated_at = ? WHERE id = ?").run(status, now2, id);
+    return result.changes > 0;
+  }
+  deletePhoneNumber(id) {
+    const result = this.db.prepare("DELETE FROM phone_numbers WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  createCallLog(params) {
+    const id = generateCallId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO call_logs (id, call_sid, from_number, to_number, direction, status, assistant_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.callSid || null, params.fromNumber, params.toNumber, params.direction, params.status || "pending", params.assistantId || null, now2);
+    return this.getCallLog(id);
+  }
+  getCallLog(id) {
+    const row = this.db.prepare("SELECT * FROM call_logs WHERE id = ?").get(id);
+    return row ? this.rowToCallLog(row) : null;
+  }
+  getCallLogBySid(callSid) {
+    const row = this.db.prepare("SELECT * FROM call_logs WHERE call_sid = ?").get(callSid);
+    return row ? this.rowToCallLog(row) : null;
+  }
+  updateCallLog(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.status !== undefined) {
+      sets.push("status = ?");
+      params.push(updates.status);
+    }
+    if (updates.callSid !== undefined) {
+      sets.push("call_sid = ?");
+      params.push(updates.callSid);
+    }
+    if (updates.duration !== undefined) {
+      sets.push("duration = ?");
+      params.push(updates.duration);
+    }
+    if (updates.recordingUrl !== undefined) {
+      sets.push("recording_url = ?");
+      params.push(updates.recordingUrl);
+    }
+    if (updates.startedAt !== undefined) {
+      sets.push("started_at = ?");
+      params.push(updates.startedAt);
+    }
+    if (updates.endedAt !== undefined) {
+      sets.push("ended_at = ?");
+      params.push(updates.endedAt);
+    }
+    if (sets.length === 0)
+      return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE call_logs SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  listCallLogs(options) {
+    const conditions = [];
+    const params = [];
+    const limit2 = options?.limit || 50;
+    if (options?.assistantId) {
+      conditions.push("assistant_id = ?");
+      params.push(options.assistantId);
+    }
+    if (options?.direction) {
+      conditions.push("direction = ?");
+      params.push(options.direction);
+    }
+    if (options?.status) {
+      conditions.push("status = ?");
+      params.push(options.status);
+    }
+    let query = "SELECT * FROM call_logs";
+    if (conditions.length > 0) {
+      query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit2);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => ({
+      id: String(row.id),
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      status: String(row.status),
+      duration: row.duration != null ? Number(row.duration) : null,
+      startedAt: row.started_at ? String(row.started_at) : null,
+      createdAt: String(row.created_at)
+    }));
+  }
+  createSmsLog(params) {
+    const id = generateSmsId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO sms_logs (id, message_sid, from_number, to_number, direction, message_type, body, status, assistant_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.messageSid || null, params.fromNumber, params.toNumber, params.direction, params.messageType || "sms", params.body, params.status || "queued", params.assistantId || null, now2);
+    return this.getSmsLog(id);
+  }
+  getSmsLog(id) {
+    const row = this.db.prepare("SELECT * FROM sms_logs WHERE id = ?").get(id);
+    return row ? this.rowToSmsLog(row) : null;
+  }
+  updateSmsStatus(id, status) {
+    const result = this.db.prepare("UPDATE sms_logs SET status = ? WHERE id = ?").run(status, id);
+    return result.changes > 0;
+  }
+  listSmsLogs(options) {
+    const conditions = [];
+    const params = [];
+    const limit2 = options?.limit || 50;
+    if (options?.assistantId) {
+      conditions.push("assistant_id = ?");
+      params.push(options.assistantId);
+    }
+    if (options?.direction) {
+      conditions.push("direction = ?");
+      params.push(options.direction);
+    }
+    if (options?.messageType) {
+      conditions.push("message_type = ?");
+      params.push(options.messageType);
+    }
+    let query = "SELECT * FROM sms_logs";
+    if (conditions.length > 0) {
+      query += " WHERE " + conditions.join(" AND ");
+    }
+    query += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit2);
+    const rows = this.db.prepare(query).all(...params);
+    return rows.map((row) => ({
+      id: String(row.id),
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      messageType: String(row.message_type),
+      bodyPreview: String(row.body).slice(0, 100),
+      status: String(row.status),
+      createdAt: String(row.created_at)
+    }));
+  }
+  getUnreadInboundSms(assistantId, limit2) {
+    const maxLimit = limit2 || 50;
+    const rows = this.db.prepare(`SELECT * FROM sms_logs
+       WHERE direction = 'inbound' AND assistant_id = ? AND status = 'received'
+       ORDER BY created_at ASC LIMIT ?`).all(assistantId, maxLimit);
+    return rows.map((r6) => this.rowToSmsLog(r6));
+  }
+  createRoutingRule(params) {
+    const id = generateRuleId();
+    const now2 = new Date().toISOString();
+    this.db.prepare(`INSERT INTO routing_rules (id, name, priority, from_pattern, to_pattern, message_type, time_of_day, day_of_week, keyword, target_assistant_id, target_assistant_name, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.name, params.priority ?? 100, params.fromPattern || null, params.toPattern || null, params.messageType || "all", params.timeOfDay || null, params.dayOfWeek || null, params.keyword || null, params.targetAssistantId, params.targetAssistantName, now2, now2);
+    return this.getRoutingRule(id);
+  }
+  getRoutingRule(id) {
+    const row = this.db.prepare("SELECT * FROM routing_rules WHERE id = ?").get(id);
+    return row ? this.rowToRoutingRule(row) : null;
+  }
+  listRoutingRules() {
+    const rows = this.db.prepare("SELECT * FROM routing_rules ORDER BY priority ASC, created_at ASC").all();
+    return rows.map((r6) => this.rowToRoutingRule(r6));
+  }
+  updateRoutingRule(id, updates) {
+    const sets = [];
+    const params = [];
+    const now2 = new Date().toISOString();
+    if (updates.name !== undefined) {
+      sets.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.priority !== undefined) {
+      sets.push("priority = ?");
+      params.push(updates.priority);
+    }
+    if (updates.enabled !== undefined) {
+      sets.push("enabled = ?");
+      params.push(updates.enabled ? 1 : 0);
+    }
+    sets.push("updated_at = ?");
+    params.push(now2);
+    if (sets.length === 1)
+      return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE routing_rules SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  deleteRoutingRule(id) {
+    const result = this.db.prepare("DELETE FROM routing_rules WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  resolveRouting(params) {
+    const rules = this.db.prepare(`SELECT * FROM routing_rules WHERE enabled = 1 ORDER BY priority ASC`).all();
+    for (const row of rules) {
+      const rule = this.rowToRoutingRule(row);
+      if (rule.messageType !== "all" && rule.messageType !== params.messageType)
+        continue;
+      if (rule.fromPattern && !matchPattern2(rule.fromPattern, params.fromNumber))
+        continue;
+      if (rule.toPattern && !matchPattern2(rule.toPattern, params.toNumber))
+        continue;
+      if (rule.keyword && params.body) {
+        if (!params.body.toLowerCase().includes(rule.keyword.toLowerCase()))
+          continue;
+      } else if (rule.keyword && !params.body) {
+        continue;
+      }
+      if (rule.timeOfDay && !matchTimeOfDay(rule.timeOfDay))
+        continue;
+      if (rule.dayOfWeek && !matchDayOfWeek(rule.dayOfWeek))
+        continue;
+      return {
+        assistantId: rule.targetAssistantId,
+        assistantName: rule.targetAssistantName,
+        ruleId: rule.id
+      };
+    }
+    return null;
+  }
+  cleanup(maxAgeDays, maxCallLogs, maxSmsLogs) {
+    let deleted = 0;
+    const cutoff = new Date;
+    cutoff.setDate(cutoff.getDate() - maxAgeDays);
+    const cutoffStr = cutoff.toISOString();
+    const callResult = this.db.prepare("DELETE FROM call_logs WHERE created_at < ?").run(cutoffStr);
+    deleted += callResult.changes;
+    const smsResult = this.db.prepare("DELETE FROM sms_logs WHERE created_at < ?").run(cutoffStr);
+    deleted += smsResult.changes;
+    const callCount = this.db.prepare("SELECT COUNT(*) as cnt FROM call_logs").get();
+    if (Number(callCount.cnt) > maxCallLogs) {
+      const excess = Number(callCount.cnt) - maxCallLogs;
+      const trimResult = this.db.prepare(`DELETE FROM call_logs WHERE id IN (
+          SELECT id FROM call_logs ORDER BY created_at ASC LIMIT ?
+        )`).run(excess);
+      deleted += trimResult.changes;
+    }
+    const smsCount = this.db.prepare("SELECT COUNT(*) as cnt FROM sms_logs").get();
+    if (Number(smsCount.cnt) > maxSmsLogs) {
+      const excess = Number(smsCount.cnt) - maxSmsLogs;
+      const trimResult = this.db.prepare(`DELETE FROM sms_logs WHERE id IN (
+          SELECT id FROM sms_logs ORDER BY created_at ASC LIMIT ?
+        )`).run(excess);
+      deleted += trimResult.changes;
+    }
+    return deleted;
+  }
+  close() {
+    try {
+      this.db.close();
+    } catch {}
+  }
+  rowToPhoneNumber(row) {
+    return {
+      id: String(row.id),
+      number: String(row.number),
+      friendlyName: row.friendly_name ? String(row.friendly_name) : null,
+      twilioSid: row.twilio_sid ? String(row.twilio_sid) : null,
+      status: String(row.status),
+      capabilities: {
+        voice: Boolean(row.voice_capable),
+        sms: Boolean(row.sms_capable),
+        whatsapp: Boolean(row.whatsapp_capable)
+      },
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+  rowToCallLog(row) {
+    return {
+      id: String(row.id),
+      callSid: row.call_sid ? String(row.call_sid) : null,
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      status: String(row.status),
+      assistantId: row.assistant_id ? String(row.assistant_id) : null,
+      duration: row.duration != null ? Number(row.duration) : null,
+      recordingUrl: row.recording_url ? String(row.recording_url) : null,
+      startedAt: row.started_at ? String(row.started_at) : null,
+      endedAt: row.ended_at ? String(row.ended_at) : null,
+      createdAt: String(row.created_at)
+    };
+  }
+  rowToSmsLog(row) {
+    return {
+      id: String(row.id),
+      messageSid: row.message_sid ? String(row.message_sid) : null,
+      fromNumber: String(row.from_number),
+      toNumber: String(row.to_number),
+      direction: String(row.direction),
+      messageType: String(row.message_type),
+      body: String(row.body),
+      status: String(row.status),
+      assistantId: row.assistant_id ? String(row.assistant_id) : null,
+      createdAt: String(row.created_at)
+    };
+  }
+  rowToRoutingRule(row) {
+    return {
+      id: String(row.id),
+      name: String(row.name),
+      priority: Number(row.priority),
+      fromPattern: row.from_pattern ? String(row.from_pattern) : null,
+      toPattern: row.to_pattern ? String(row.to_pattern) : null,
+      messageType: String(row.message_type),
+      timeOfDay: row.time_of_day ? String(row.time_of_day) : null,
+      dayOfWeek: row.day_of_week ? String(row.day_of_week) : null,
+      keyword: row.keyword ? String(row.keyword) : null,
+      targetAssistantId: String(row.target_assistant_id),
+      targetAssistantName: String(row.target_assistant_name),
+      enabled: Boolean(row.enabled),
+      createdAt: String(row.created_at),
+      updatedAt: String(row.updated_at)
+    };
+  }
+}
+function matchPattern2(pattern, value) {
+  if (pattern === "*")
+    return true;
+  if (pattern.endsWith("*")) {
+    return value.startsWith(pattern.slice(0, -1));
+  }
+  if (pattern.startsWith("*")) {
+    return value.endsWith(pattern.slice(1));
+  }
+  return pattern === value;
+}
+function matchTimeOfDay(timeRange) {
+  const [start, end] = timeRange.split("-");
+  if (!start || !end)
+    return true;
+  const now2 = new Date;
+  const currentMinutes = now2.getHours() * 60 + now2.getMinutes();
+  const [startH, startM] = start.split(":").map(Number);
+  const [endH, endM] = end.split(":").map(Number);
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+  if (startMinutes <= endMinutes) {
+    return currentMinutes >= startMinutes && currentMinutes <= endMinutes;
+  }
+  return currentMinutes >= startMinutes || currentMinutes <= endMinutes;
+}
+function matchDayOfWeek(dayList) {
+  const days = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+  const today = days[new Date().getDay()];
+  const allowedDays = dayList.toLowerCase().split(",").map((d5) => d5.trim());
+  return allowedDays.includes(today);
+}
+// ../core/src/telephony/twilio-client.ts
+var TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
+class TwilioClient {
+  accountSid;
+  authToken;
+  authHeader;
+  constructor(config) {
+    this.accountSid = config.accountSid;
+    this.authToken = config.authToken;
+    this.authHeader = "Basic " + Buffer.from(`${this.accountSid}:${this.authToken}`).toString("base64");
+  }
+  isConfigured() {
+    return Boolean(this.accountSid && this.authToken);
+  }
+  async makeCall(params) {
+    const body = new URLSearchParams;
+    body.append("To", params.to);
+    body.append("From", params.from);
+    if (params.url) {
+      body.append("Url", params.url);
+    } else if (params.twiml) {
+      body.append("Twiml", params.twiml);
+    }
+    if (params.statusCallback) {
+      body.append("StatusCallback", params.statusCallback);
+      body.append("StatusCallbackEvent", "initiated ringing answered completed");
+      body.append("StatusCallbackMethod", "POST");
+    }
+    if (params.record) {
+      body.append("Record", "true");
+    }
+    return this.post(`/Accounts/${this.accountSid}/Calls.json`, body);
+  }
+  async updateCall(callSid, updates) {
+    const body = new URLSearchParams;
+    if (updates.status) {
+      body.append("Status", updates.status);
+    }
+    if (updates.url) {
+      body.append("Url", updates.url);
+    }
+    if (updates.twiml) {
+      body.append("Twiml", updates.twiml);
+    }
+    return this.post(`/Accounts/${this.accountSid}/Calls/${callSid}.json`, body);
+  }
+  async getCall(callSid) {
+    return this.get(`/Accounts/${this.accountSid}/Calls/${callSid}.json`);
+  }
+  async sendSms(params) {
+    const body = new URLSearchParams;
+    body.append("To", params.to);
+    body.append("From", params.from);
+    body.append("Body", params.body);
+    if (params.statusCallback) {
+      body.append("StatusCallback", params.statusCallback);
+    }
+    return this.post(`/Accounts/${this.accountSid}/Messages.json`, body);
+  }
+  async sendWhatsApp(params) {
+    const to3 = params.to.startsWith("whatsapp:") ? params.to : `whatsapp:${params.to}`;
+    const from = params.from.startsWith("whatsapp:") ? params.from : `whatsapp:${params.from}`;
+    return this.sendSms({
+      ...params,
+      to: to3,
+      from
+    });
+  }
+  async listPhoneNumbers() {
+    return this.get(`/Accounts/${this.accountSid}/IncomingPhoneNumbers.json`);
+  }
+  async getPhoneNumber(phoneSid) {
+    return this.get(`/Accounts/${this.accountSid}/IncomingPhoneNumbers/${phoneSid}.json`);
+  }
+  async updatePhoneNumber(phoneSid, updates) {
+    const body = new URLSearchParams;
+    if (updates.voiceUrl) {
+      body.append("VoiceUrl", updates.voiceUrl);
+      body.append("VoiceMethod", updates.voiceMethod || "POST");
+    }
+    if (updates.smsUrl) {
+      body.append("SmsUrl", updates.smsUrl);
+      body.append("SmsMethod", updates.smsMethod || "POST");
+    }
+    if (updates.statusCallback) {
+      body.append("StatusCallback", updates.statusCallback);
+    }
+    return this.post(`/Accounts/${this.accountSid}/IncomingPhoneNumbers/${phoneSid}.json`, body);
+  }
+  async verifyCredentials() {
+    return this.get(`/Accounts/${this.accountSid}.json`);
+  }
+  async get(path2) {
+    try {
+      const response = await fetch(`${TWILIO_API_BASE}${path2}`, {
+        method: "GET",
+        headers: {
+          Authorization: this.authHeader,
+          Accept: "application/json"
+        }
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          statusCode: response.status
+        };
+      }
+      return { success: true, data, statusCode: response.status };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2),
+        statusCode: 0
+      };
+    }
+  }
+  async post(path2, body) {
+    try {
+      const response = await fetch(`${TWILIO_API_BASE}${path2}`, {
+        method: "POST",
+        headers: {
+          Authorization: this.authHeader,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: body.toString()
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.message || `HTTP ${response.status}`,
+          statusCode: response.status
+        };
+      }
+      return { success: true, data, statusCode: response.status };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : String(error2),
+        statusCode: 0
+      };
+    }
+  }
+}
+// ../core/src/telephony/call-manager.ts
+class CallManager {
+  activeCalls = new Map;
+  maxCallDurationMs;
+  staleTimeoutMs;
+  constructor(config) {
+    this.maxCallDurationMs = (config?.maxCallDurationSeconds || 3600) * 1000;
+    this.staleTimeoutMs = (config?.staleTimeoutSeconds || 300) * 1000;
+  }
+  addCall(params) {
+    const call = {
+      callSid: params.callSid,
+      streamSid: null,
+      fromNumber: params.fromNumber,
+      toNumber: params.toNumber,
+      direction: params.direction,
+      state: "connecting",
+      assistantId: params.assistantId || null,
+      bridgeId: null,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now()
+    };
+    this.activeCalls.set(params.callSid, call);
+    return call;
+  }
+  getCall(callSid) {
+    return this.activeCalls.get(callSid) || null;
+  }
+  updateState(callSid, state) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    const validTransitions = {
+      connecting: ["ringing", "active", "ending"],
+      ringing: ["bridging", "active", "ending"],
+      bridging: ["active", "ending"],
+      active: ["ending"],
+      ending: []
+    };
+    if (!validTransitions[call.state].includes(state)) {
+      return false;
+    }
+    call.state = state;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  setStreamSid(callSid, streamSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    call.streamSid = streamSid;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  setBridgeId(callSid, bridgeId) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return false;
+    call.bridgeId = bridgeId;
+    call.lastActivityAt = Date.now();
+    return true;
+  }
+  touchCall(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (call) {
+      call.lastActivityAt = Date.now();
+    }
+  }
+  endCall(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return null;
+    call.state = "ending";
+    this.activeCalls.delete(callSid);
+    return call;
+  }
+  getActiveCalls() {
+    return Array.from(this.activeCalls.values());
+  }
+  getActiveCallCount() {
+    return this.activeCalls.size;
+  }
+  getCallByStreamSid(streamSid) {
+    for (const call of this.activeCalls.values()) {
+      if (call.streamSid === streamSid)
+        return call;
+    }
+    return null;
+  }
+  cleanupStaleCalls() {
+    const now2 = Date.now();
+    const removed = [];
+    for (const [callSid, call] of this.activeCalls) {
+      if (now2 - call.startedAt > this.maxCallDurationMs) {
+        this.activeCalls.delete(callSid);
+        removed.push(callSid);
+        continue;
+      }
+      if (now2 - call.lastActivityAt > this.staleTimeoutMs) {
+        this.activeCalls.delete(callSid);
+        removed.push(callSid);
+      }
+    }
+    return removed;
+  }
+  getCallDuration(callSid) {
+    const call = this.activeCalls.get(callSid);
+    if (!call)
+      return null;
+    return Math.floor((Date.now() - call.startedAt) / 1000);
+  }
+  endAllCalls() {
+    const calls = Array.from(this.activeCalls.values());
+    this.activeCalls.clear();
+    return calls;
+  }
+}
+// ../core/src/telephony/voice-bridge.ts
+init_src2();
+// ../core/src/telephony/audio-codec.ts
+var MULAW_MAX = 8191;
+var MULAW_BIAS = 33;
+function pcmSampleToMulaw(sample) {
+  const sign2 = sample >> 8 & 128;
+  if (sign2 !== 0)
+    sample = -sample;
+  if (sample > MULAW_MAX)
+    sample = MULAW_MAX;
+  sample += MULAW_BIAS;
+  let exponent = 7;
+  let mask = 16384;
+  while (exponent > 0 && (sample & mask) === 0) {
+    exponent--;
+    mask >>= 1;
+  }
+  const mantissa = sample >> exponent + 3 & 15;
+  const mulawByte = ~(sign2 | exponent << 4 | mantissa) & 255;
+  return mulawByte;
+}
+function mulawSampleToPcm(mulawByte) {
+  mulawByte = ~mulawByte & 255;
+  const sign2 = mulawByte & 128;
+  const exponent = mulawByte >> 4 & 7;
+  const mantissa = mulawByte & 15;
+  let sample = (mantissa << 3) + MULAW_BIAS << exponent;
+  sample -= MULAW_BIAS;
+  return sign2 !== 0 ? -sample : sample;
+}
+function pcmToMulaw(pcmBuffer) {
+  const numSamples = Math.floor(pcmBuffer.length / 2);
+  const mulawBuffer = Buffer.alloc(numSamples);
+  for (let i5 = 0;i5 < numSamples; i5++) {
+    const sample = pcmBuffer.readInt16LE(i5 * 2);
+    mulawBuffer[i5] = pcmSampleToMulaw(sample);
+  }
+  return mulawBuffer;
+}
+function mulawToPcm(mulawBuffer) {
+  const pcmBuffer = Buffer.alloc(mulawBuffer.length * 2);
+  for (let i5 = 0;i5 < mulawBuffer.length; i5++) {
+    const sample = mulawSampleToPcm(mulawBuffer[i5]);
+    pcmBuffer.writeInt16LE(sample, i5 * 2);
+  }
+  return pcmBuffer;
+}
+function downsample16kTo8k(pcm16k) {
+  const numSamples = Math.floor(pcm16k.length / 2);
+  const outputSamples = Math.floor(numSamples / 2);
+  const pcm8k = Buffer.alloc(outputSamples * 2);
+  for (let i5 = 0;i5 < outputSamples; i5++) {
+    const sample = pcm16k.readInt16LE(i5 * 2 * 2);
+    pcm8k.writeInt16LE(sample, i5 * 2);
+  }
+  return pcm8k;
+}
+function upsample8kTo16k(pcm8k) {
+  const numSamples = Math.floor(pcm8k.length / 2);
+  const pcm16k = Buffer.alloc(numSamples * 2 * 2);
+  for (let i5 = 0;i5 < numSamples; i5++) {
+    const current = pcm8k.readInt16LE(i5 * 2);
+    const next = i5 + 1 < numSamples ? pcm8k.readInt16LE((i5 + 1) * 2) : current;
+    const interpolated = Math.round((current + next) / 2);
+    pcm16k.writeInt16LE(current, i5 * 4);
+    pcm16k.writeInt16LE(interpolated, i5 * 4 + 2);
+  }
+  return pcm16k;
+}
+function twilioToElevenLabs(mulawBuffer) {
+  const pcm8k = mulawToPcm(mulawBuffer);
+  return upsample8kTo16k(pcm8k);
+}
+function elevenLabsToTwilio(pcm16k) {
+  const pcm8k = downsample16kTo8k(pcm16k);
+  return pcmToMulaw(pcm8k);
+}
+function decodeTwilioPayload(base64Payload) {
+  const mulawBuffer = Buffer.from(base64Payload, "base64");
+  return twilioToElevenLabs(mulawBuffer);
+}
+function encodeTwilioPayload(pcm16k) {
+  const mulawBuffer = elevenLabsToTwilio(pcm16k);
+  return mulawBuffer.toString("base64");
+}
+// ../core/src/telephony/voice-bridge.ts
+var ELEVENLABS_WS_BASE = "wss://api.elevenlabs.io/v1/convai/conversation";
+class VoiceBridge {
+  config;
+  connections = new Map;
+  constructor(config) {
+    this.config = config;
+  }
+  isConfigured() {
+    return Boolean(this.config.elevenLabsApiKey && this.config.elevenLabsAgentId);
+  }
+  async createBridge(callSid, streamSid, sendToTwilio) {
+    const id = `bridge_${generateId().slice(0, 12)}`;
+    const connection = new BridgeConnection({
+      id,
+      callSid,
+      streamSid,
+      config: this.config,
+      sendToTwilio
+    });
+    this.connections.set(id, connection);
+    try {
+      await connection.connect();
+    } catch (error2) {
+      this.connections.delete(id);
+      throw error2;
+    }
+    return id;
+  }
+  handleTwilioMedia(bridgeId, message) {
+    const connection = this.connections.get(bridgeId);
+    if (!connection)
+      return;
+    if (message.event === "media" && message.media?.payload) {
+      connection.forwardToElevenLabs(message.media.payload);
+    } else if (message.event === "stop") {
+      connection.close();
+      this.connections.delete(bridgeId);
+    }
+  }
+  closeBridge(bridgeId) {
+    const connection = this.connections.get(bridgeId);
+    if (connection) {
+      connection.close();
+      this.connections.delete(bridgeId);
+    }
+  }
+  getConnection(bridgeId) {
+    const conn = this.connections.get(bridgeId);
+    if (!conn)
+      return null;
+    return conn.getInfo();
+  }
+  getActiveConnections() {
+    return Array.from(this.connections.values()).map((c6) => c6.getInfo());
+  }
+  closeAll() {
+    for (const connection of this.connections.values()) {
+      connection.close();
+    }
+    this.connections.clear();
+  }
+}
+class BridgeConnection {
+  id;
+  callSid;
+  streamSid;
+  config;
+  sendToTwilio;
+  elevenLabsWs = null;
+  state = "connecting";
+  startedAt;
+  constructor(options) {
+    this.id = options.id;
+    this.callSid = options.callSid;
+    this.streamSid = options.streamSid;
+    this.config = options.config;
+    this.sendToTwilio = options.sendToTwilio;
+    this.startedAt = Date.now();
+  }
+  async connect() {
+    const url = `${ELEVENLABS_WS_BASE}?agent_id=${this.config.elevenLabsAgentId}`;
+    return new Promise((resolve5, reject) => {
+      try {
+        this.elevenLabsWs = new WebSocket(url, {
+          headers: {
+            "xi-api-key": this.config.elevenLabsApiKey
+          }
+        });
+        this.elevenLabsWs.onopen = () => {
+          this.state = "active";
+          resolve5();
+        };
+        this.elevenLabsWs.onmessage = (event) => {
+          this.handleElevenLabsMessage(event.data);
+        };
+        this.elevenLabsWs.onerror = (event) => {
+          console.error(`[VoiceBridge ${this.id}] ElevenLabs WS error:`, event);
+          if (this.state === "connecting") {
+            reject(new Error("Failed to connect to ElevenLabs"));
+          }
+        };
+        this.elevenLabsWs.onclose = () => {
+          this.state = "closed";
+        };
+        setTimeout(() => {
+          if (this.state === "connecting") {
+            this.close();
+            reject(new Error("ElevenLabs connection timeout"));
+          }
+        }, 1e4);
+      } catch (error2) {
+        reject(error2);
+      }
+    });
+  }
+  forwardToElevenLabs(base64Payload) {
+    if (this.state !== "active" || !this.elevenLabsWs)
+      return;
+    try {
+      const pcm16k = decodeTwilioPayload(base64Payload);
+      const message = JSON.stringify({
+        user_audio_chunk: pcm16k.toString("base64")
+      });
+      if (this.elevenLabsWs.readyState === WebSocket.OPEN) {
+        this.elevenLabsWs.send(message);
+      }
+    } catch (error2) {
+      console.error(`[VoiceBridge ${this.id}] Error forwarding to ElevenLabs:`, error2);
+    }
+  }
+  handleElevenLabsMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      if (message.audio?.chunk) {
+        const pcm16k = Buffer.from(message.audio.chunk, "base64");
+        const twilioPayload = encodeTwilioPayload(pcm16k);
+        const twilioMessage = JSON.stringify({
+          event: "media",
+          streamSid: this.streamSid,
+          media: {
+            payload: twilioPayload
+          }
+        });
+        this.sendToTwilio(twilioMessage);
+      }
+      if (message.type === "conversation_initiation_metadata") {} else if (message.type === "agent_response") {} else if (message.type === "user_transcript") {}
+    } catch (error2) {
+      console.error(`[VoiceBridge ${this.id}] Error handling ElevenLabs message:`, error2);
+    }
+  }
+  close() {
+    if (this.state === "closed" || this.state === "closing")
+      return;
+    this.state = "closing";
+    if (this.elevenLabsWs) {
+      try {
+        this.elevenLabsWs.close();
+      } catch {}
+      this.elevenLabsWs = null;
+    }
+    this.state = "closed";
+  }
+  getInfo() {
+    return {
+      id: this.id,
+      callSid: this.callSid,
+      streamSid: this.streamSid,
+      state: this.state,
+      startedAt: this.startedAt
+    };
+  }
+}
+// ../core/src/telephony/manager.ts
+class TelephonyManager {
+  assistantId;
+  assistantName;
+  config;
+  store;
+  twilioClient = null;
+  callManager;
+  voiceBridge = null;
+  constructor(options) {
+    this.assistantId = options.assistantId;
+    this.assistantName = options.assistantName;
+    this.config = options.config;
+    this.store = new TelephonyStore;
+    this.callManager = new CallManager({
+      maxCallDurationSeconds: options.config.voice?.maxCallDurationSeconds
+    });
+    const accountSid = process.env.TWILIO_ACCOUNT_SID;
+    const authToken = process.env.TWILIO_AUTH_TOKEN;
+    if (accountSid && authToken) {
+      this.twilioClient = new TwilioClient({ accountSid, authToken });
+    }
+    const elevenLabsApiKey = process.env.ELEVENLABS_API_KEY;
+    const elevenLabsAgentId = this.config.elevenLabsAgentId || process.env.ELEVENLABS_AGENT_ID;
+    if (elevenLabsApiKey && elevenLabsAgentId) {
+      this.voiceBridge = new VoiceBridge({
+        elevenLabsApiKey,
+        elevenLabsAgentId
+      });
+    }
+  }
+  async sendSms(to3, body, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured. Set telephony.defaultPhoneNumber or TWILIO_PHONE_NUMBER."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    const statusCallback = webhookUrl ? `${webhookUrl}/api/v1/telephony/webhooks/sms-status` : undefined;
+    const result = await this.twilioClient.sendSms({
+      to: to3,
+      from: fromNumber,
+      body,
+      statusCallback
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to send SMS: ${result.error}` };
+    }
+    const log2 = this.store.createSmsLog({
+      messageSid: result.data?.sid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      messageType: "sms",
+      body,
+      status: "queued",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `SMS sent to ${to3}.`,
+      messageSid: result.data?.sid,
+      id: log2.id
+    };
+  }
+  async sendWhatsApp(to3, body, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    const statusCallback = webhookUrl ? `${webhookUrl}/api/v1/telephony/webhooks/sms-status` : undefined;
+    const result = await this.twilioClient.sendWhatsApp({
+      to: to3,
+      from: fromNumber,
+      body,
+      statusCallback
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to send WhatsApp: ${result.error}` };
+    }
+    const log2 = this.store.createSmsLog({
+      messageSid: result.data?.sid,
+      fromNumber: `whatsapp:${fromNumber}`,
+      toNumber: `whatsapp:${to3}`,
+      direction: "outbound",
+      messageType: "whatsapp",
+      body,
+      status: "queued",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `WhatsApp message sent to ${to3}.`,
+      messageSid: result.data?.sid,
+      id: log2.id
+    };
+  }
+  async makeCall(to3, from) {
+    if (!this.twilioClient) {
+      return {
+        success: false,
+        message: "Twilio is not configured. Set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN."
+      };
+    }
+    const fromNumber = from || this.config.defaultPhoneNumber || process.env.TWILIO_PHONE_NUMBER;
+    if (!fromNumber) {
+      return {
+        success: false,
+        message: "No phone number configured."
+      };
+    }
+    const webhookUrl = this.config.webhookUrl || process.env.TELEPHONY_WEBHOOK_URL;
+    if (!webhookUrl) {
+      return {
+        success: false,
+        message: "No webhook URL configured. Set telephony.webhookUrl or TELEPHONY_WEBHOOK_URL."
+      };
+    }
+    const result = await this.twilioClient.makeCall({
+      to: to3,
+      from: fromNumber,
+      url: `${webhookUrl}/api/v1/telephony/webhooks/voice`,
+      statusCallback: `${webhookUrl}/api/v1/telephony/webhooks/voice-status`,
+      record: this.config.voice?.recordCalls
+    });
+    if (!result.success) {
+      return { success: false, message: `Failed to make call: ${result.error}` };
+    }
+    const callSid = result.data?.sid;
+    const log2 = this.store.createCallLog({
+      callSid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      status: "pending",
+      assistantId: this.assistantId
+    });
+    this.callManager.addCall({
+      callSid,
+      fromNumber,
+      toNumber: to3,
+      direction: "outbound",
+      assistantId: this.assistantId
+    });
+    return {
+      success: true,
+      message: `Calling ${to3}...`,
+      callSid,
+      id: log2.id
+    };
+  }
+  getCallHistory(options) {
+    return this.store.listCallLogs({
+      assistantId: this.assistantId,
+      limit: options?.limit || 20
+    });
+  }
+  getSmsHistory(options) {
+    return this.store.listSmsLogs({
+      assistantId: this.assistantId,
+      messageType: options?.messageType,
+      limit: options?.limit || 20
+    });
+  }
+  listPhoneNumbers() {
+    return this.store.listPhoneNumbers("active");
+  }
+  async syncPhoneNumbers() {
+    if (!this.twilioClient) {
+      return { success: false, message: "Twilio is not configured." };
+    }
+    const result = await this.twilioClient.listPhoneNumbers();
+    if (!result.success) {
+      return { success: false, message: `Failed to list numbers: ${result.error}` };
+    }
+    const numbers = result.data?.incoming_phone_numbers || [];
+    let synced = 0;
+    for (const num of numbers) {
+      const phoneNumber = String(num.phone_number || "");
+      const existing = this.store.getPhoneNumberByNumber(phoneNumber);
+      if (!existing && phoneNumber) {
+        this.store.addPhoneNumber(phoneNumber, num.friendly_name ? String(num.friendly_name) : null, num.sid ? String(num.sid) : null, {
+          voice: Boolean(num.capabilities?.voice),
+          sms: Boolean(num.capabilities?.sms)
+        });
+        synced++;
+      }
+    }
+    return {
+      success: true,
+      message: `Synced ${synced} phone number${synced !== 1 ? "s" : ""} from Twilio.`
+    };
+  }
+  listRoutingRules() {
+    return this.store.listRoutingRules();
+  }
+  createRoutingRule(params) {
+    const rule = this.store.createRoutingRule(params);
+    return {
+      success: true,
+      message: `Routing rule "${rule.name}" created (priority ${rule.priority}).`,
+      id: rule.id
+    };
+  }
+  deleteRoutingRule(id) {
+    const success = this.store.deleteRoutingRule(id);
+    return {
+      success,
+      message: success ? "Routing rule deleted." : "Routing rule not found."
+    };
+  }
+  getStatus() {
+    const phoneNumbers = this.store.listPhoneNumbers("active");
+    const recentCalls = this.store.listCallLogs({ limit: 100 });
+    const recentMessages = this.store.listSmsLogs({ limit: 100 });
+    const routingRules = this.store.listRoutingRules();
+    return {
+      enabled: this.config.enabled !== false,
+      twilioConfigured: this.twilioClient?.isConfigured() ?? false,
+      elevenLabsConfigured: this.voiceBridge?.isConfigured() ?? false,
+      phoneNumbers: phoneNumbers.length,
+      activeCalls: this.callManager.getActiveCallCount(),
+      routingRules: routingRules.length,
+      recentCalls: recentCalls.length,
+      recentMessages: recentMessages.length
+    };
+  }
+  getUnreadForInjection() {
+    const injectionConfig = this.config.injection || {};
+    if (injectionConfig.enabled === false) {
+      return [];
+    }
+    const maxPerTurn = injectionConfig.maxPerTurn || 5;
+    return this.store.getUnreadInboundSms(this.assistantId, maxPerTurn);
+  }
+  buildInjectionContext(messages) {
+    if (messages.length === 0)
+      return "";
+    const lines = [];
+    lines.push("## Incoming Telephony Messages");
+    lines.push("");
+    for (const msg of messages) {
+      const type = msg.messageType === "whatsapp" ? "WhatsApp" : "SMS";
+      const ago = formatTimeAgo2(msg.createdAt);
+      lines.push(`**${type} from ${msg.fromNumber}** (${ago}):`);
+      lines.push(msg.body);
+      lines.push("");
+    }
+    lines.push("Use telephony_send_sms or telephony_send_whatsapp to reply.");
+    return lines.join(`
+`);
+  }
+  markInjected(messages) {
+    for (const msg of messages) {
+      this.store.updateSmsStatus(msg.id, "delivered");
+    }
+  }
+  getStore() {
+    return this.store;
+  }
+  getTwilioClient() {
+    return this.twilioClient;
+  }
+  getCallManager() {
+    return this.callManager;
+  }
+  getVoiceBridge() {
+    return this.voiceBridge;
+  }
+  getAssistantId() {
+    return this.assistantId;
+  }
+  getAssistantName() {
+    return this.assistantName;
+  }
+  getConfig() {
+    return this.config;
+  }
+  cleanup() {
+    const maxAgeDays = this.config.storage?.maxAgeDays || 90;
+    const maxCallLogs = this.config.storage?.maxCallLogs || 1000;
+    const maxSmsLogs = this.config.storage?.maxSmsLogs || 5000;
+    this.callManager.cleanupStaleCalls();
+    return this.store.cleanup(maxAgeDays, maxCallLogs, maxSmsLogs);
+  }
+  close() {
+    this.callManager.endAllCalls();
+    this.voiceBridge?.closeAll();
+    this.store.close();
+  }
+}
+function formatTimeAgo2(isoDate) {
+  const now2 = Date.now();
+  const then = new Date(isoDate).getTime();
+  const diffMs = now2 - then;
+  if (diffMs < 60000) {
+    const secs = Math.floor(diffMs / 1000);
+    return `${secs}s ago`;
+  }
+  if (diffMs < 3600000) {
+    const mins = Math.floor(diffMs / 60000);
+    return `${mins}m ago`;
+  }
+  if (diffMs < 86400000) {
+    const hours = Math.floor(diffMs / 3600000);
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(diffMs / 86400000);
+  return `${days}d ago`;
+}
+function createTelephonyManager(assistantId, assistantName, config) {
+  return new TelephonyManager({
+    assistantId,
+    assistantName,
+    config
+  });
+}
+// ../core/src/telephony/tools.ts
+var telephonySendSmsTool = {
+  name: "telephony_send_sms",
+  description: "Send an SMS text message to a phone number.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Recipient phone number in E.164 format (e.g., "+15551234567")'
+      },
+      body: {
+        type: "string",
+        description: "Message content to send"
+      },
+      from: {
+        type: "string",
+        description: "Sender phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to", "body"]
+  }
+};
+var telephonySendWhatsappTool = {
+  name: "telephony_send_whatsapp",
+  description: "Send a WhatsApp message to a phone number.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Recipient phone number in E.164 format (e.g., "+15551234567")'
+      },
+      body: {
+        type: "string",
+        description: "Message content to send"
+      },
+      from: {
+        type: "string",
+        description: "Sender phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to", "body"]
+  }
+};
+var telephonyCallTool = {
+  name: "telephony_call",
+  description: "Initiate an outbound voice call. The call will be connected to the AI voice agent.",
+  parameters: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: 'Phone number to call in E.164 format (e.g., "+15551234567")'
+      },
+      from: {
+        type: "string",
+        description: "Caller phone number (optional, uses default if not set)"
+      }
+    },
+    required: ["to"]
+  }
+};
+var telephonyCallHistoryTool = {
+  name: "telephony_call_history",
+  description: "Get recent call history. Returns call logs with status, duration, and timestamps.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum number of calls to return (default: 20)"
+      }
+    },
+    required: []
+  }
+};
+var telephonySmsHistoryTool = {
+  name: "telephony_sms_history",
+  description: "Get recent SMS and WhatsApp message history.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum messages to return (default: 20)"
+      },
+      type: {
+        type: "string",
+        enum: ["sms", "whatsapp"],
+        description: "Filter by message type (default: all)"
+      }
+    },
+    required: []
+  }
+};
+var telephonyPhoneNumbersTool = {
+  name: "telephony_phone_numbers",
+  description: "List available phone numbers with their capabilities (voice, SMS, WhatsApp).",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+var telephonyRoutingRulesTool = {
+  name: "telephony_routing_rules",
+  description: "View and manage routing rules that direct incoming calls/messages to specific assistants.",
+  parameters: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "create", "delete"],
+        description: "Action to perform (default: list)"
+      },
+      name: {
+        type: "string",
+        description: "Rule name (for create)"
+      },
+      priority: {
+        type: "number",
+        description: "Priority (lower = higher priority, for create)"
+      },
+      from_pattern: {
+        type: "string",
+        description: 'From number pattern (e.g., "+1555*", for create)'
+      },
+      message_type: {
+        type: "string",
+        enum: ["sms", "whatsapp", "voice", "all"],
+        description: "Message type filter (for create)"
+      },
+      rule_id: {
+        type: "string",
+        description: "Rule ID (for delete)"
+      }
+    },
+    required: []
+  }
+};
+var telephonyStatusTool = {
+  name: "telephony_status",
+  description: "Get telephony system status including configured numbers, active calls, and connection health.",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: []
+  }
+};
+function createTelephonyToolExecutors(getTelephonyManager) {
+  return {
+    telephony_send_sms: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      const body = String(input.body || "").trim();
+      if (!to3)
+        return "Error: Recipient phone number (to) is required.";
+      if (!body)
+        return "Error: Message body is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.sendSms(to3, body, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_send_whatsapp: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      const body = String(input.body || "").trim();
+      if (!to3)
+        return "Error: Recipient phone number (to) is required.";
+      if (!body)
+        return "Error: Message body is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.sendWhatsApp(to3, body, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_call: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const to3 = String(input.to || "").trim();
+      if (!to3)
+        return "Error: Phone number (to) is required.";
+      const from = input.from ? String(input.from).trim() : undefined;
+      const result = await manager.makeCall(to3, from);
+      return result.success ? result.message : `Error: ${result.message}`;
+    },
+    telephony_call_history: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      const calls = manager.getCallHistory({ limit: limit2 });
+      if (calls.length === 0) {
+        return "No call history found.";
+      }
+      const lines = [];
+      lines.push(`## Call History (${calls.length})`);
+      lines.push("");
+      for (const call of calls) {
+        const dir = call.direction === "inbound" ? "IN" : "OUT";
+        const duration = call.duration != null ? `${call.duration}s` : "-";
+        const date = new Date(call.createdAt).toLocaleString();
+        lines.push(`[${dir}] ${call.fromNumber} \u2192 ${call.toNumber} | ${call.status} | ${duration} | ${date}`);
+      }
+      return lines.join(`
+`);
+    },
+    telephony_sms_history: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const limit2 = typeof input.limit === "number" ? input.limit : 20;
+      const messageType = input.type;
+      const messages = manager.getSmsHistory({ limit: limit2, messageType });
+      if (messages.length === 0) {
+        return "No message history found.";
+      }
+      const lines = [];
+      lines.push(`## Message History (${messages.length})`);
+      lines.push("");
+      for (const msg of messages) {
+        const dir = msg.direction === "inbound" ? "IN" : "OUT";
+        const type = msg.messageType === "whatsapp" ? "WA" : "SMS";
+        const date = new Date(msg.createdAt).toLocaleString();
+        lines.push(`[${dir}/${type}] ${msg.fromNumber} \u2192 ${msg.toNumber} | ${msg.status}`);
+        lines.push(`  ${msg.bodyPreview}`);
+        lines.push(`  ${date}`);
+        lines.push("");
+      }
+      return lines.join(`
+`);
+    },
+    telephony_phone_numbers: async () => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const numbers = manager.listPhoneNumbers();
+      if (numbers.length === 0) {
+        return "No phone numbers configured. Use /phone sync to import from Twilio.";
+      }
+      const lines = [];
+      lines.push(`## Phone Numbers (${numbers.length})`);
+      lines.push("");
+      for (const num of numbers) {
+        const caps = [];
+        if (num.capabilities.voice)
+          caps.push("voice");
+        if (num.capabilities.sms)
+          caps.push("sms");
+        if (num.capabilities.whatsapp)
+          caps.push("whatsapp");
+        const name2 = num.friendlyName ? ` (${num.friendlyName})` : "";
+        lines.push(`  ${num.number}${name2} [${caps.join(", ")}]`);
+      }
+      return lines.join(`
+`);
+    },
+    telephony_routing_rules: async (input) => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Error: Telephony is not enabled.";
+      }
+      const action = String(input.action || "list");
+      if (action === "list") {
+        const rules = manager.listRoutingRules();
+        if (rules.length === 0) {
+          return "No routing rules configured.";
+        }
+        const lines = [];
+        lines.push(`## Routing Rules (${rules.length})`);
+        lines.push("");
+        for (const rule of rules) {
+          const enabled = rule.enabled ? "" : " [DISABLED]";
+          lines.push(`**${rule.name}** (priority: ${rule.priority})${enabled}`);
+          lines.push(`  ID: ${rule.id}`);
+          lines.push(`  Type: ${rule.messageType} | Target: ${rule.targetAssistantName}`);
+          if (rule.fromPattern)
+            lines.push(`  From: ${rule.fromPattern}`);
+          if (rule.toPattern)
+            lines.push(`  To: ${rule.toPattern}`);
+          if (rule.keyword)
+            lines.push(`  Keyword: ${rule.keyword}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      }
+      if (action === "create") {
+        const name2 = String(input.name || "").trim();
+        if (!name2)
+          return "Error: Rule name is required.";
+        const result = manager.createRoutingRule({
+          name: name2,
+          priority: typeof input.priority === "number" ? input.priority : undefined,
+          fromPattern: input.from_pattern ? String(input.from_pattern) : undefined,
+          messageType: input.message_type,
+          targetAssistantId: manager.getAssistantId(),
+          targetAssistantName: manager.getAssistantName()
+        });
+        return result.success ? result.message : `Error: ${result.message}`;
+      }
+      if (action === "delete") {
+        const ruleId = String(input.rule_id || "").trim();
+        if (!ruleId)
+          return "Error: Rule ID is required.";
+        const result = manager.deleteRoutingRule(ruleId);
+        return result.success ? result.message : `Error: ${result.message}`;
+      }
+      return `Unknown action: ${action}. Use 'list', 'create', or 'delete'.`;
+    },
+    telephony_status: async () => {
+      const manager = getTelephonyManager();
+      if (!manager) {
+        return "Telephony is not enabled. Set telephony.enabled: true in config.";
+      }
+      const status = manager.getStatus();
+      const lines = [];
+      lines.push("## Telephony Status");
+      lines.push("");
+      lines.push(`Enabled:           ${status.enabled ? "Yes" : "No"}`);
+      lines.push(`Twilio configured: ${status.twilioConfigured ? "Yes" : "No (set TWILIO_ACCOUNT_SID + TWILIO_AUTH_TOKEN)"}`);
+      lines.push(`ElevenLabs AI:     ${status.elevenLabsConfigured ? "Yes" : "No (set ELEVENLABS_API_KEY + ELEVENLABS_AGENT_ID)"}`);
+      lines.push(`Phone numbers:     ${status.phoneNumbers}`);
+      lines.push(`Active calls:      ${status.activeCalls}`);
+      lines.push(`Routing rules:     ${status.routingRules}`);
+      lines.push(`Recent calls:      ${status.recentCalls}`);
+      lines.push(`Recent messages:   ${status.recentMessages}`);
+      return lines.join(`
+`);
+    }
+  };
+}
+var telephonyTools = [
+  telephonySendSmsTool,
+  telephonySendWhatsappTool,
+  telephonyCallTool,
+  telephonyCallHistoryTool,
+  telephonySmsHistoryTool,
+  telephonyPhoneNumbersTool,
+  telephonyRoutingRulesTool,
+  telephonyStatusTool
+];
+function registerTelephonyTools(registry2, getTelephonyManager) {
+  const executors = createTelephonyToolExecutors(getTelephonyManager);
+  for (const tool of telephonyTools) {
+    registry2.register(tool, executors[tool.name]);
+  }
+}
 // ../core/src/sessions/store.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 import { homedir as homedir21 } from "os";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, writeFileSync as writeFileSync14, readFileSync as readFileSync17, readdirSync as readdirSync9, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, writeFileSync as writeFileSync14, readFileSync as readFileSync17, readdirSync as readdirSync9, unlinkSync as unlinkSync6 } from "fs";
 class SessionStore {
   basePath;
   constructor(basePath) {
     const envHome = process.env.HOME || process.env.USERPROFILE || homedir21();
-    this.basePath = basePath || join44(envHome, ".assistants", "sessions");
+    this.basePath = basePath || join45(envHome, ".assistants", "sessions");
     this.ensureDir();
   }
   ensureDir() {
-    if (!existsSync27(this.basePath)) {
-      mkdirSync17(this.basePath, { recursive: true });
+    if (!existsSync28(this.basePath)) {
+      mkdirSync18(this.basePath, { recursive: true });
     }
   }
   getSessionPath(id) {
-    return join44(this.basePath, `${id}.json`);
+    return join45(this.basePath, `${id}.json`);
   }
   save(data) {
     try {
@@ -151390,7 +153341,7 @@ class SessionStore {
   load(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (!existsSync27(filePath))
+      if (!existsSync28(filePath))
         return null;
       return JSON.parse(readFileSync17(filePath, "utf-8"));
     } catch {
@@ -151404,7 +153355,7 @@ class SessionStore {
       const sessions = [];
       for (const file of files) {
         try {
-          const data = JSON.parse(readFileSync17(join44(this.basePath, file), "utf-8"));
+          const data = JSON.parse(readFileSync17(join45(this.basePath, file), "utf-8"));
           sessions.push(data);
         } catch {}
       }
@@ -151416,7 +153367,7 @@ class SessionStore {
   delete(id) {
     try {
       const filePath = this.getSessionPath(id);
-      if (existsSync27(filePath)) {
+      if (existsSync28(filePath)) {
         unlinkSync6(filePath);
       }
     } catch {}
@@ -151733,6 +153684,12 @@ class EmbeddedClient {
     }
     return null;
   }
+  getTelephonyManager() {
+    if (typeof this.assistantLoop.getTelephonyManager === "function") {
+      return this.assistantLoop.getTelephonyManager();
+    }
+    return null;
+  }
   getWalletManager() {
     if (typeof this.assistantLoop.getWalletManager === "function") {
       return this.assistantLoop.getWalletManager();
@@ -153603,7 +155560,7 @@ function createSelfAwarenessToolExecutors(context) {
     workspace_map: async (input) => {
       const { readdir: readdir7, stat: stat5, access } = await import("fs/promises");
       const { execSync } = await import("child_process");
-      const { join: join45, basename: basename6 } = await import("path");
+      const { join: join46, basename: basename6 } = await import("path");
       const depth = input.depth ?? 3;
       const includeGitStatus = input.include_git_status !== false;
       const includeRecentFiles = input.include_recent_files !== false;
@@ -153649,7 +155606,7 @@ function createSelfAwarenessToolExecutors(context) {
               break;
             }
             if (entry.isDirectory()) {
-              const children = await buildTree(join45(dir, entry.name), currentDepth + 1);
+              const children = await buildTree(join46(dir, entry.name), currentDepth + 1);
               nodes.push({
                 name: entry.name,
                 type: "directory",
@@ -153675,7 +155632,7 @@ function createSelfAwarenessToolExecutors(context) {
       };
       if (includeGitStatus) {
         try {
-          await access(join45(cwd, ".git"));
+          await access(join46(cwd, ".git"));
           gitStatus.isRepo = true;
           try {
             const branch = execSync("git branch --show-current", { cwd, encoding: "utf-8" }).trim();
@@ -153706,7 +155663,7 @@ function createSelfAwarenessToolExecutors(context) {
             for (const entry of entries) {
               if (shouldIgnore(entry.name))
                 continue;
-              const fullPath = join45(dir, entry.name);
+              const fullPath = join46(dir, entry.name);
               const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
               if (entry.isFile()) {
                 try {
@@ -153740,12 +155697,12 @@ function createSelfAwarenessToolExecutors(context) {
       let projectName = basename6(cwd);
       for (const indicator of projectIndicators) {
         try {
-          await access(join45(cwd, indicator.file));
+          await access(join46(cwd, indicator.file));
           projectType = indicator.type;
           if (indicator.file === "package.json") {
             try {
               const { readFile: readFile16 } = await import("fs/promises");
-              const pkg = JSON.parse(await readFile16(join45(cwd, indicator.file), "utf-8"));
+              const pkg = JSON.parse(await readFile16(join46(cwd, indicator.file), "utf-8"));
               projectName = pkg.name || projectName;
             } catch {}
           }
@@ -156334,8 +158291,8 @@ await __promiseAll([
   init_config(),
   init_runtime()
 ]);
-import { join as join45, dirname as dirname19 } from "path";
-import { existsSync as existsSync28, mkdirSync as mkdirSync18 } from "fs";
+import { join as join46, dirname as dirname20 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync19 } from "fs";
 var MAX_KEY_LENGTH2 = 256;
 var MAX_VALUE_SIZE = 65536;
 var MAX_SUMMARY_LENGTH2 = 500;
@@ -156348,10 +158305,10 @@ class GlobalMemoryManager {
   config;
   constructor(options = {}) {
     const baseDir = getConfigDir();
-    const path2 = options.dbPath || join45(baseDir, "memory.db");
-    const dir = dirname19(path2);
-    if (!existsSync28(dir)) {
-      mkdirSync18(dir, { recursive: true });
+    const path2 = options.dbPath || join46(baseDir, "memory.db");
+    const dir = dirname20(path2);
+    if (!existsSync29(dir)) {
+      mkdirSync19(dir, { recursive: true });
     }
     const runtime = getRuntime();
     this.db = runtime.openDatabase(path2);
@@ -157755,8 +159712,8 @@ function createCapabilityChain(scope, capabilities) {
   };
 }
 // ../core/src/capabilities/storage.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
-import { join as join46, dirname as dirname20 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync15 } from "fs";
+import { join as join47, dirname as dirname21 } from "path";
 import { homedir as homedir22 } from "os";
 var DEFAULT_STORAGE_CONFIG = {
   enabled: true,
@@ -157777,14 +159734,14 @@ class CapabilityStorage {
       return this.config.storagePath;
     }
     const home = process.env.HOME || process.env.USERPROFILE || homedir22();
-    return join46(home, ".assistants", "capabilities", "store.json");
+    return join47(home, ".assistants", "capabilities", "store.json");
   }
   load() {
     if (!this.config.enabled)
       return;
     try {
       const path2 = this.getStoragePath();
-      if (!existsSync29(path2))
+      if (!existsSync30(path2))
         return;
       const data = JSON.parse(readFileSync18(path2, "utf-8"));
       if (data.chains) {
@@ -157804,9 +159761,9 @@ class CapabilityStorage {
       return;
     try {
       const path2 = this.getStoragePath();
-      const dir = dirname20(path2);
-      if (!existsSync29(dir)) {
-        mkdirSync19(dir, { recursive: true });
+      const dir = dirname21(path2);
+      if (!existsSync30(dir)) {
+        mkdirSync20(dir, { recursive: true });
       }
       const data = {
         version: 1,
@@ -158192,6 +160149,7 @@ class AssistantLoop {
   messagesManager = null;
   webhooksManager = null;
   channelsManager = null;
+  telephonyManager = null;
   memoryManager = null;
   memoryInjector = null;
   contextInjector = null;
@@ -158201,6 +160159,7 @@ class AssistantLoop {
   pendingMessagesContext = null;
   pendingWebhooksContext = null;
   pendingChannelsContext = null;
+  pendingTelephonyContext = null;
   pendingMemoryContext = null;
   identityContext = null;
   projectContext = null;
@@ -158430,6 +160389,13 @@ class AssistantLoop {
       this.channelsManager = createChannelsManager(assistantId, assistantName, this.config.channels);
       registerChannelTools(this.toolRegistry, () => this.channelsManager);
     }
+    if (this.config?.telephony?.enabled) {
+      const assistant = this.assistantManager?.getActive();
+      const assistantId = assistant?.id || this.sessionId;
+      const assistantName = assistant?.name || "assistant";
+      this.telephonyManager = createTelephonyManager(assistantId, assistantName, this.config.telephony);
+      registerTelephonyTools(this.toolRegistry, () => this.telephonyManager);
+    }
     const memoryConfig = this.config?.memory;
     if (memoryConfig?.enabled !== false) {
       const assistant = this.assistantManager?.getActive();
@@ -158761,6 +160727,7 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
       await this.injectPendingMessages();
       await this.injectPendingWebhookEvents();
       await this.injectPendingChannelMessages();
+      await this.injectPendingTelephonyMessages();
       await this.injectMemoryContext(userMessage);
       await this.injectContextInfo();
     } catch (error2) {
@@ -159479,6 +161446,7 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
       getMessagesManager: () => this.messagesManager,
       getWebhooksManager: () => this.webhooksManager,
       getChannelsManager: () => this.channelsManager,
+      getTelephonyManager: () => this.telephonyManager,
       getMemoryManager: () => this.memoryManager,
       refreshIdentityContext: async () => {
         if (this.identityManager) {
@@ -159720,6 +161688,8 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
     this.webhooksManager?.stopWatching();
     this.channelsManager?.close();
     this.channelsManager = null;
+    this.telephonyManager?.close();
+    this.telephonyManager = null;
     this.memoryManager?.close();
     this.memoryManager = null;
     this.memoryInjector = null;
@@ -159797,6 +161767,9 @@ You are running in **autonomous mode**. You manage your own wakeup schedule.
   getChannelsManager() {
     return this.channelsManager;
   }
+  getTelephonyManager() {
+    return this.telephonyManager;
+  }
   getWalletManager() {
     return this.walletManager;
   }
@@ -160029,7 +162002,7 @@ ${content.trim()}`);
     if (!heartbeatConfig)
       return;
     this.heartbeatRuntimeConfig = heartbeatConfig;
-    const statePath = join47(getConfigDir(), "state", `${this.sessionId}.json`);
+    const statePath = join48(getConfigDir(), "state", `${this.sessionId}.json`);
     this.heartbeatManager = new HeartbeatManager(heartbeatConfig);
     this.heartbeatPersistence = new StatePersistence(statePath);
     this.heartbeatRecovery = new RecoveryManager(this.heartbeatPersistence, heartbeatConfig.persistPath, heartbeatConfig.staleThresholdMs, {
@@ -160150,7 +162123,7 @@ ${content.trim()}`);
   async startEnergySystem() {
     if (!this.config || this.config.energy?.enabled === false)
       return;
-    const statePath = join47(getConfigDir(), "energy", "state.json");
+    const statePath = join48(getConfigDir(), "energy", "state.json");
     this.energyManager = new EnergyManager(this.config.energy, new EnergyStorage(statePath));
     await this.energyManager.initialize();
     this.refreshEnergyEffects();
@@ -160257,6 +162230,29 @@ ${effects.message}
       this.pendingChannelsContext = null;
     }
   }
+  async injectPendingTelephonyMessages() {
+    if (!this.telephonyManager)
+      return;
+    try {
+      if (this.pendingTelephonyContext) {
+        const previous = this.pendingTelephonyContext.trim();
+        this.context.removeSystemMessages((content) => content.trim() === previous);
+        this.pendingTelephonyContext = null;
+      }
+      const pending = this.telephonyManager.getUnreadForInjection();
+      if (pending.length === 0) {
+        return;
+      }
+      this.pendingTelephonyContext = this.telephonyManager.buildInjectionContext(pending);
+      if (this.pendingTelephonyContext) {
+        this.context.addSystemMessage(this.pendingTelephonyContext);
+      }
+      this.telephonyManager.markInjected(pending);
+    } catch (error2) {
+      console.error("Failed to inject pending telephony messages:", error2);
+      this.pendingTelephonyContext = null;
+    }
+  }
   async injectMemoryContext(userMessage) {
     if (!this.memoryInjector || !this.memoryInjector.isEnabled())
       return;
@@ -160526,8 +162522,8 @@ ${this.identityContext}`);
       return null;
     const intervalMs = Math.max(1000, config.heartbeat?.intervalMs ?? 15000);
     const staleThresholdMs = Math.max(intervalMs * 2, config.heartbeat?.staleThresholdMs ?? 120000);
-    const persistPath = config.heartbeat?.persistPath ?? join47(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
-    const historyPath = config.heartbeat?.historyPath ?? join47(getConfigDir(), "heartbeats", "runs", `${this.sessionId}.jsonl`);
+    const persistPath = config.heartbeat?.persistPath ?? join48(getConfigDir(), "heartbeats", `${this.sessionId}.json`);
+    const historyPath = config.heartbeat?.historyPath ?? join48(getConfigDir(), "heartbeats", "runs", `${this.sessionId}.jsonl`);
     return {
       intervalMs,
       staleThresholdMs,
@@ -160916,9 +162912,9 @@ class StatsTracker {
   }
 }
 // ../core/src/tools/connector-index.ts
-import { join as join48, dirname as dirname21 } from "path";
+import { join as join49, dirname as dirname22 } from "path";
 import { homedir as homedir23 } from "os";
-import { existsSync as existsSync30, mkdirSync as mkdirSync20, writeFileSync as writeFileSync16, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync21, writeFileSync as writeFileSync16, readFileSync as readFileSync19 } from "fs";
 var TAG_KEYWORDS = {
   email: ["email", "mail", "inbox", "send", "receive", "message", "compose"],
   calendar: ["calendar", "event", "meeting", "schedule", "appointment"],
@@ -160955,13 +162951,13 @@ class ConnectorIndex {
     return envHome && envHome.trim().length > 0 ? envHome : homedir23();
   }
   getCachePath() {
-    return join48(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
+    return join49(this.getHomeDir(), ".assistants", "cache", "connector-index.json");
   }
   loadDiskCache() {
     ConnectorIndex.indexLoaded = true;
     try {
       const cachePath = this.getCachePath();
-      if (!existsSync30(cachePath))
+      if (!existsSync31(cachePath))
         return;
       const data = JSON.parse(readFileSync19(cachePath, "utf-8"));
       if (data.version !== INDEX_VERSION)
@@ -160977,9 +162973,9 @@ class ConnectorIndex {
   saveDiskCache() {
     try {
       const cachePath = this.getCachePath();
-      const cacheDir = dirname21(cachePath);
-      if (!existsSync30(cacheDir)) {
-        mkdirSync20(cacheDir, { recursive: true });
+      const cacheDir = dirname22(cachePath);
+      if (!existsSync31(cacheDir)) {
+        mkdirSync21(cacheDir, { recursive: true });
       }
       const data = {
         version: INDEX_VERSION,