@diegoaltoworks/talker 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1771 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/routes/call/pending.ts
+var pending_exports = {};
+__export(pending_exports, {
+  deletePending: () => deletePending,
+  getPending: () => getPending,
+  setPending: () => setPending
+});
+function setPending(phoneNumber, query) {
+  pendingQueries.set(phoneNumber, query);
+}
+function getPending(phoneNumber) {
+  return pendingQueries.get(phoneNumber);
+}
+function deletePending(phoneNumber) {
+  pendingQueries.delete(phoneNumber);
+}
+var pendingQueries;
+var init_pending = __esm({
+  "src/routes/call/pending.ts"() {
+    "use strict";
+    pendingQueries = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/logger.ts
+var isTestEnv = process.env.NODE_ENV === "test" || typeof Bun !== "undefined" && process.argv.some((arg) => arg.includes("test"));
+var isDebug = process.env.DEBUG === "true";
+var isSilent = isTestEnv && !isDebug;
+var timestamp = () => (/* @__PURE__ */ new Date()).toISOString();
+var log = (level, message, data) => {
+  if (isSilent) return;
+  const entry = {
+    timestamp: timestamp(),
+    level,
+    message,
+    ...data
+  };
+  console.log(JSON.stringify(entry));
+};
+var logger = {
+  info: (message, data) => log("info", message, data),
+  warn: (message, data) => log("warn", message, data),
+  error: (message, data) => log("error", message, data)
+};
+
+// src/core/context.ts
+var contexts = /* @__PURE__ */ new Map();
+var cleanupTimer = null;
+function startCleanup(ttlMs, intervalMs) {
+  if (cleanupTimer) return;
+  cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [phoneNumber, context] of contexts) {
+      if (now - context.lastActivity > ttlMs) {
+        contexts.delete(phoneNumber);
+        logger.info(`context expired for ${phoneNumber}`);
+      }
+    }
+  }, intervalMs);
+}
+function stopCleanup() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}
+function getOrCreateContext(phoneNumber, channel = "call") {
+  let context = contexts.get(phoneNumber);
+  if (!context) {
+    context = {
+      phoneNumber,
+      channel,
+      detectedLanguage: null,
+      messageHistory: [],
+      activeFlow: null,
+      noSpeechRetries: 0,
+      lastPrompt: null,
+      createdAt: Date.now(),
+      lastActivity: Date.now()
+    };
+    contexts.set(phoneNumber, context);
+    logger.info(`context created for ${phoneNumber} (${channel})`);
+  }
+  context.lastActivity = Date.now();
+  return context;
+}
+function getContext(phoneNumber) {
+  return contexts.get(phoneNumber);
+}
+function setDetectedLanguage(phoneNumber, language) {
+  const context = getOrCreateContext(phoneNumber);
+  if (!context.detectedLanguage) {
+    context.detectedLanguage = language;
+    logger.info(`detected language for ${phoneNumber}: ${language}`);
+  }
+}
+function getDetectedLanguage(phoneNumber) {
+  return contexts.get(phoneNumber)?.detectedLanguage || null;
+}
+function addMessage(phoneNumber, role, content, channel = "call") {
+  const context = getOrCreateContext(phoneNumber, channel);
+  context.messageHistory.push({ role, content, timestamp: Date.now() });
+  if (context.messageHistory.length > 10) {
+    context.messageHistory = context.messageHistory.slice(-10);
+  }
+}
+function getMessageHistory(phoneNumber) {
+  return contexts.get(phoneNumber)?.messageHistory || [];
+}
+function clearContext(phoneNumber) {
+  contexts.delete(phoneNumber);
+  logger.info("context cleared", { phoneNumber });
+}
+function setActiveFlow(phoneNumber, flowName, params = {}) {
+  const context = contexts.get(phoneNumber);
+  if (!context) return;
+  context.activeFlow = {
+    flowName,
+    params,
+    attempts: 0,
+    startedAt: Date.now()
+  };
+  logger.info(`flow activated for ${phoneNumber}: ${flowName}`);
+}
+function getActiveFlow(phoneNumber) {
+  return contexts.get(phoneNumber)?.activeFlow || null;
+}
+function updateFlowParams(phoneNumber, params) {
+  const context = contexts.get(phoneNumber);
+  if (!context || !context.activeFlow) return;
+  context.activeFlow.params = { ...context.activeFlow.params, ...params };
+  context.activeFlow.attempts += 1;
+}
+function clearActiveFlow(phoneNumber) {
+  const context = contexts.get(phoneNumber);
+  if (!context) return;
+  logger.info(`flow cleared for ${phoneNumber}: ${context.activeFlow?.flowName}`);
+  context.activeFlow = null;
+}
+function incrementNoSpeechRetries(phoneNumber) {
+  const context = contexts.get(phoneNumber);
+  if (!context) return 0;
+  context.noSpeechRetries += 1;
+  return context.noSpeechRetries;
+}
+function resetNoSpeechRetries(phoneNumber) {
+  const context = contexts.get(phoneNumber);
+  if (context && context.noSpeechRetries > 0) {
+    context.noSpeechRetries = 0;
+  }
+}
+function setLastPrompt(phoneNumber, prompt) {
+  const context = getOrCreateContext(phoneNumber);
+  context.lastPrompt = prompt;
+}
+function getLastPrompt(phoneNumber) {
+  return contexts.get(phoneNumber)?.lastPrompt || null;
+}
+function clearAllContexts() {
+  contexts.clear();
+}
+
+// src/db/client.ts
+import { createClient } from "@libsql/client";
+var client = null;
+function initDbClient(url, authToken) {
+  if (client) return;
+  try {
+    client = createClient({ url, authToken });
+    logger.info("database client initialized", {
+      url: url.replace(/:[^:]*@/, ":***@")
+    });
+  } catch (error) {
+    logger.error("failed to initialize database client", {
+      error: error instanceof Error ? error.message : "Unknown"
+    });
+  }
+}
+function getDbClient() {
+  return client;
+}
+async function closeDbClient() {
+  if (client) {
+    try {
+      client.close();
+      client = null;
+      logger.info("database client closed");
+    } catch (error) {
+      logger.error("error closing database client", {
+        error: error instanceof Error ? error.message : "Unknown"
+      });
+    }
+  }
+}
+
+// src/db/migrate.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+async function runMigrations() {
+  const client2 = getDbClient();
+  if (!client2) {
+    logger.warn("cannot run migrations - database not configured");
+    return;
+  }
+  try {
+    const schemaPath = join(__dirname, "schema.sql");
+    const schema = readFileSync(schemaPath, "utf-8");
+    const statements = schema.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n").split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    logger.info("running database migrations", { statementCount: statements.length });
+    for (const statement of statements) {
+      await client2.execute(statement);
+    }
+    logger.info("database migrations completed");
+  } catch (error) {
+    logger.error("database migration failed", {
+      error: error instanceof Error ? error.message : "Unknown"
+    });
+    throw error;
+  }
+}
+
+// src/flows/registry.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+
+// src/flows/intent.ts
+var OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
+async function detectIntent(deps, phoneNumber, userMessage, flows, conversationContext) {
+  const contextStr = conversationContext && conversationContext.length > 0 ? `
+
+Recent conversation:
+${conversationContext.join("\n")}` : "";
+  const flowDescriptions = Array.from(flows.entries()).map(([id, flow], index) => {
+    const keywords = flow.definition.triggerKeywords.join(", ");
+    return `${index + 1}. ${id} -- ${flow.definition.description}
+   - Keywords: ${keywords}`;
+  }).join("\n\n");
+  const systemPrompt = `You are an intent detector for a voice assistant.
+
+Detect ONE category. Use these EXACT ids (they must match flow ids):
+
+${flowDescriptions}
+
+${flows.size + 1}. chatbot -- All other questions (general fallback)
+${contextStr}
+
+Return JSON with:
+- "intent": one of the ids above (exact string)
+- "confidence": 0.0-1.0 (how certain you are)
+- "reasoning": brief explanation
+
+Rules:
+- If uncertain, always return "chatbot" with low confidence`;
+  const requestBody = {
+    model: deps.openaiModel,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ],
+    temperature: 0.1,
+    response_format: { type: "json_object" }
+  };
+  logger.info("detecting intent", {
+    phoneNumber,
+    msg: userMessage.substring(0, 160),
+    hasContext: !!conversationContext && conversationContext.length > 0
+  });
+  try {
+    const response = await fetch(OPENAI_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${deps.openaiApiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      logger.error("intent detection error", { phoneNumber, status: response.status, error });
+      return { intent: "chatbot", confidence: 0, reasoning: "API error, defaulting to chatbot" };
+    }
+    const data = await response.json();
+    const content = data.choices[0]?.message?.content || "{}";
+    const raw = JSON.parse(content);
+    const validFlowIds = new Set(flows.keys());
+    const normalizedIntent = validFlowIds.has(raw.intent) ? raw.intent : "chatbot";
+    const result = {
+      intent: normalizedIntent,
+      confidence: raw.confidence,
+      reasoning: raw.reasoning
+    };
+    logger.info("intent detected", {
+      phoneNumber,
+      intent: result.intent,
+      confidence: result.confidence,
+      reasoning: result.reasoning
+    });
+    return result;
+  } catch (error) {
+    logger.error("intent detection exception", {
+      phoneNumber,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return {
+      intent: "chatbot",
+      confidence: 0,
+      reasoning: "Exception occurred, defaulting to chatbot"
+    };
+  }
+}
+
+// src/flows/loader.ts
+import { existsSync, readFileSync as readFileSync2, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+async function loadFlowsFromDirectory(flowsDir) {
+  const flows = /* @__PURE__ */ new Map();
+  if (!existsSync(flowsDir)) {
+    logger.warn("flows directory does not exist", { flowsDir });
+    return flows;
+  }
+  const flowDirs = readdirSync(flowsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).filter((dirent) => ["lib", "tests", "registry"].indexOf(dirent.name) === -1).map((dirent) => dirent.name);
+  logger.info("loading flows", { count: flowDirs.length, flowDirs });
+  for (const flowName of flowDirs) {
+    try {
+      const flow = await loadFlow(flowsDir, flowName);
+      flows.set(flowName, flow);
+      logger.info("flow loaded", { flowName });
+    } catch (error) {
+      logger.error("failed to load flow", {
+        flowName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  logger.info("flows loaded", { count: flows.size, flows: Array.from(flows.keys()) });
+  return flows;
+}
+async function loadFlow(flowsDir, flowName) {
+  const flowPath = join2(flowsDir, flowName);
+  const definitionPath = join2(flowPath, "flow.json");
+  const instructionsPath = join2(flowPath, "instructions.md");
+  const handlerPath = join2(flowPath, "handler.ts");
+  if (!existsSync(definitionPath)) {
+    throw new Error(`flow.json not found for ${flowName}`);
+  }
+  if (!existsSync(instructionsPath)) {
+    throw new Error(`instructions.md not found for ${flowName}`);
+  }
+  if (!existsSync(handlerPath)) {
+    throw new Error(`handler.ts not found for ${flowName}`);
+  }
+  const definitionContent = readFileSync2(definitionPath, "utf-8");
+  const definition = JSON.parse(definitionContent);
+  if (definition.id !== flowName) {
+    throw new Error(`Flow id mismatch: ${definition.id} !== ${flowName}`);
+  }
+  if (!definition.triggerKeywords || definition.triggerKeywords.length === 0) {
+    throw new Error(`Flow ${flowName} has no trigger keywords`);
+  }
+  if (!definition.schema || Object.keys(definition.schema).length === 0) {
+    throw new Error(`Flow ${flowName} has no schema`);
+  }
+  const handlerModule = await import(handlerPath);
+  const handler = handlerModule.execute;
+  if (typeof handler !== "function") {
+    throw new Error(`Flow ${flowName} handler.ts must export an 'execute' function`);
+  }
+  const prefillPath = join2(flowPath, "prefill.ts");
+  let prefill;
+  if (existsSync(prefillPath)) {
+    const prefillModule = await import(prefillPath);
+    prefill = prefillModule.prefillFromContext;
+    if (typeof prefill !== "function") {
+      logger.warn("flow prefill.ts does not export prefillFromContext function", { flowName });
+      prefill = void 0;
+    }
+  }
+  return {
+    definition,
+    handler,
+    instructionsPath,
+    prefill
+  };
+}
+
+// src/flows/registry.ts
+var CRITICAL_KEYWORDS = ["human", "person", "agent", "representative", "operator"];
+var FlowRegistry = class {
+  flows = /* @__PURE__ */ new Map();
+  flowsDir;
+  constructor(flowsDir) {
+    this.flowsDir = flowsDir;
+  }
+  /**
+   * Load all flows from the flows directory
+   */
+  async loadFlows() {
+    this.flows = await loadFlowsFromDirectory(this.flowsDir);
+  }
+  /**
+   * Get a flow by name
+   */
+  getFlow(name) {
+    return this.flows.get(name);
+  }
+  /**
+   * Match user message to a flow using hybrid approach:
+   * 1. Critical keyword detection (immediate)
+   * 2. LLM intent classification
+   */
+  async matchFlow(deps, phoneNumber, message, conversationContext) {
+    const lowerMessage = message.toLowerCase();
+    for (const keyword of CRITICAL_KEYWORDS) {
+      if (lowerMessage.includes(keyword)) {
+        const transferFlow = this.flows.get("transfer");
+        if (transferFlow) {
+          logger.info("flow triggered (critical keyword)", {
+            flowId: transferFlow.definition.id,
+            keyword
+          });
+          return transferFlow;
+        }
+      }
+    }
+    if (this.flows.size === 0) return void 0;
+    const detection = process.env.NODE_ENV === "test" ? testModeDetectIntent(message) : await detectIntent(deps, phoneNumber, message, this.flows, conversationContext);
+    if (detection.confidence >= 0.7) {
+      const flow = this.flows.get(detection.intent);
+      if (flow) {
+        logger.info("flow triggered (LLM detection)", {
+          flowId: flow.definition.id,
+          intent: detection.intent,
+          confidence: detection.confidence
+        });
+        return flow;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get all loaded flows
+   */
+  getAllFlows() {
+    return Array.from(this.flows.values());
+  }
+  /**
+   * Get flow instructions content
+   */
+  getInstructions(flowName) {
+    const flow = this.flows.get(flowName);
+    if (!flow) {
+      throw new Error(`Flow ${flowName} not found`);
+    }
+    return readFileSync3(flow.instructionsPath, "utf-8");
+  }
+};
+function testModeDetectIntent(message) {
+  const m = message.toLowerCase();
+  if (m.match(/\b(add|sum|plus)\b/)) {
+    return { intent: "addNumbers", confidence: 0.99, reasoning: "test-mode mapping" };
+  }
+  return { intent: "chatbot", confidence: 0.4, reasoning: "test-mode default" };
+}
+
+// src/routes/call/index.ts
+import { Hono } from "hono";
+
+// src/core/errors.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+
+// src/core/phrases.ts
+import { existsSync as existsSync2, readFileSync as readFileSync4 } from "node:fs";
+import { join as join3 } from "node:path";
+var phrasesCache = {};
+function loadPhrases(language, languageDir) {
+  const cacheKey = `${languageDir || "default"}:${language}`;
+  if (phrasesCache[cacheKey]) {
+    return phrasesCache[cacheKey];
+  }
+  const dirs = [languageDir, join3(__dirname, "../../language")].filter(Boolean);
+  for (const dir of dirs) {
+    const filePath = join3(dir, `${language}.json`);
+    if (existsSync2(filePath)) {
+      try {
+        const content = readFileSync4(filePath, "utf-8");
+        phrasesCache[cacheKey] = JSON.parse(content);
+        return phrasesCache[cacheKey];
+      } catch {
+      }
+    }
+  }
+  if (language !== "en") {
+    return loadPhrases("en", languageDir);
+  }
+  throw new Error("English phrase file not found in any search path");
+}
+function getPhrase(language, key, languageDir) {
+  const phrases = loadPhrases(language, languageDir);
+  return phrases[key];
+}
+function getFarewellPhrase(language, languageDir) {
+  const phrases = loadPhrases(language, languageDir);
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour < 12) {
+    return phrases.farewell.morning;
+  }
+  if (hour < 18) {
+    return phrases.farewell.afternoon;
+  }
+  return phrases.farewell.evening;
+}
+function getFlowPhrase(language, key, languageDir) {
+  const phrases = loadPhrases(language, languageDir);
+  return phrases.flow[key];
+}
+function getSmsPhrase(language, key, languageDir) {
+  const phrases = loadPhrases(language, languageDir);
+  return phrases.sms[key];
+}
+
+// src/core/voice.ts
+var DEFAULT_VOICES = {
+  en: { voice: "Polly.Brian", language: "en-GB" },
+  fr: { voice: "Polly.Mathieu", language: "fr-FR" },
+  nl: { voice: "Polly.Ruben", language: "nl-NL" },
+  de: { voice: "Polly.Hans", language: "de-DE" },
+  es: { voice: "Polly.Enrique", language: "es-ES" },
+  pt: { voice: "Polly.Ricardo", language: "pt-BR" }
+};
+var DEFAULT_VOICE = DEFAULT_VOICES.en;
+function getVoiceConfig(language, customVoices) {
+  if (customVoices?.[language]) {
+    return customVoices[language];
+  }
+  return DEFAULT_VOICES[language] || DEFAULT_VOICE;
+}
+function getDefaultVoices() {
+  return { ...DEFAULT_VOICES };
+}
+
+// src/core/xml.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/core/twiml.ts
+function gatherTwiml(prompt, language, config, phoneNumber) {
+  const { voice, language: lang } = getVoiceConfig(language, config.voices);
+  const prefix = config.routePrefix || "";
+  if (phoneNumber) {
+    setLastPrompt(phoneNumber, prompt);
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${prompt}</Say>
+    <Gather input="speech" action="${prefix}/call/respond" method="POST" speechTimeout="auto" language="${lang}">
+    </Gather>
+    <Redirect method="POST">${prefix}/call/no-speech</Redirect>
+</Response>`;
+}
+function sayTwiml(message, language, config) {
+  const { voice, language: lang } = getVoiceConfig(language, config.voices);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${message}</Say>
+</Response>`;
+}
+function transferTwiml(language, config) {
+  const { voice, language: lang } = getVoiceConfig(language, config.voices);
+  const message = getPhrase(language, "transfer", config.languageDir);
+  const transferNumber = config.transferNumber || "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${message}</Say>
+    <Dial>${transferNumber}</Dial>
+</Response>`;
+}
+function acknowledgmentTwiml(language, config) {
+  const { voice, language: lang } = getVoiceConfig(language, config.voices);
+  const message = getPhrase(language, "acknowledgment", config.languageDir);
+  const prefix = config.routePrefix || "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${message}</Say>
+    <Redirect method="POST">${prefix}/call/answer</Redirect>
+</Response>`;
+}
+function farewellTwiml(language, config) {
+  const { voice, language: lang } = getVoiceConfig(language, config.voices);
+  const message = getFarewellPhrase(language, config.languageDir);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${message}</Say>
+    <Hangup/>
+</Response>`;
+}
+function messageTwiml(message) {
+  const escapedMessage = escapeXml(message);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Message>${escapedMessage}</Message>
+</Response>`;
+}
+
+// src/routes/call/handle-answer.ts
+init_pending();
+async function handleAnswer(c, config) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  const pending = getPending(phoneNumber);
+  if (!pending) {
+    logger.warn("no pending query found", { phoneNumber });
+    const twiml = gatherTwiml(
+      getPhrase("en", "lostQuestion", config.languageDir),
+      "en",
+      config,
+      phoneNumber
+    );
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  }
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Processing timeout")), 3e4);
+    });
+    const result = await Promise.race([pending.promise, timeoutPromise]);
+    deletePending(phoneNumber);
+    return c.text(result.twiml, 200, { "Content-Type": "text/xml" });
+  } catch (error) {
+    logger.error("answer error", { phoneNumber, error: getErrorMessage(error) });
+    deletePending(phoneNumber);
+    const twiml = sayTwiml(getPhrase("en", "timeout", config.languageDir), "en", config);
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  }
+}
+
+// src/routes/call/handle-initial.ts
+async function handleInitialCall(c, config) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  logger.info("call started", { phoneNumber });
+  clearContext(phoneNumber);
+  const { voice, language: lang } = getVoiceConfig("en", config.voices);
+  const greeting = getPhrase("en", "greeting", config.languageDir);
+  const didNotHear = getPhrase("en", "didNotHear", config.languageDir);
+  const prefix = config.routePrefix || "";
+  const twiml = `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${greeting}</Say>
+    <Gather input="speech" action="${prefix}/call/respond" method="POST" speechTimeout="auto" language="${lang}">
+    </Gather>
+    <Say voice="${voice}" language="${lang}">${didNotHear}</Say>
+</Response>`;
+  return c.text(twiml, 200, { "Content-Type": "text/xml" });
+}
+
+// src/routes/call/handle-nospeech.ts
+async function handleNoSpeech(c, config) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  const maxRetries = config.maxNoSpeechRetries ?? 3;
+  const retryCount = incrementNoSpeechRetries(phoneNumber);
+  const language = getDetectedLanguage(phoneNumber) || "en";
+  if (retryCount > maxRetries) {
+    logger.info("max retries reached, ending call", { phoneNumber, retryCount });
+    const finalMessage = getPhrase(language, "didNotHearFinal", config.languageDir);
+    return c.text(sayTwiml(finalMessage, language, config), 200, { "Content-Type": "text/xml" });
+  }
+  logger.info("retrying speech gather", { phoneNumber, retryCount, maxRetries });
+  const retryMessage = getPhrase(language, "didNotHearRetry", config.languageDir);
+  const lastPrompt = getLastPrompt(phoneNumber);
+  let prompt;
+  if (retryCount === 1) {
+    prompt = lastPrompt ? `${retryMessage} ${lastPrompt}` : retryMessage;
+  } else {
+    prompt = lastPrompt || retryMessage;
+  }
+  return c.text(gatherTwiml(prompt, language, config, phoneNumber), 200, {
+    "Content-Type": "text/xml"
+  });
+}
+
+// src/db/sessions.ts
+function generateSessionId(phoneNumber, startTime) {
+  const sanitized = phoneNumber.replace(/[^0-9]/g, "");
+  return `${sanitized}-${startTime}`;
+}
+async function upsertSession(session) {
+  const client2 = getDbClient();
+  if (!client2) return false;
+  try {
+    await client2.execute({
+      sql: `
+        INSERT INTO talker_sessions (
+          id, phone_number, channel, reason, language,
+          started_at, ended_at, duration_ms, transfer_reason, conversation_id, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          channel = excluded.channel,
+          reason = excluded.reason,
+          language = excluded.language,
+          ended_at = excluded.ended_at,
+          duration_ms = excluded.duration_ms,
+          transfer_reason = excluded.transfer_reason,
+          conversation_id = excluded.conversation_id,
+          updated_at = excluded.updated_at
+      `,
+      args: [
+        session.id,
+        session.phoneNumber,
+        session.channel,
+        session.reason,
+        session.language,
+        session.startedAt,
+        session.endedAt,
+        session.durationMs,
+        session.transferReason || null,
+        session.conversationId || null,
+        Date.now()
+      ]
+    });
+    logger.info("session upserted", {
+      sessionId: session.id,
+      phoneNumber: session.phoneNumber,
+      channel: session.channel
+    });
+    return true;
+  } catch (error) {
+    logger.error("failed to upsert session", {
+      sessionId: session.id,
+      error: error instanceof Error ? error.message : "Unknown"
+    });
+    return false;
+  }
+}
+async function insertMessage(message) {
+  const client2 = getDbClient();
+  if (!client2) return false;
+  try {
+    await client2.execute({
+      sql: `INSERT OR IGNORE INTO talker_messages (id, session_id, role, content, timestamp)
+            VALUES (?, ?, ?, ?, ?)`,
+      args: [message.id, message.sessionId, message.role, message.content, message.timestamp]
+    });
+    return true;
+  } catch (error) {
+    logger.error("failed to insert message", {
+      messageId: message.id,
+      error: error instanceof Error ? error.message : "Unknown"
+    });
+    return false;
+  }
+}
+
+// src/db/persist.ts
+function persistSession(phoneNumber, channel, conversationId) {
+  const context = getContext(phoneNumber);
+  const language = getDetectedLanguage(phoneNumber) || "en";
+  const messages = getMessageHistory(phoneNumber);
+  if (!context || messages.length === 0) return;
+  if (!getDbClient()) return;
+  const sanitizedPhone = phoneNumber.replace(/[^0-9]/g, "");
+  const sessionId = generateSessionId(phoneNumber, context.createdAt);
+  const now = Date.now();
+  upsertSession({
+    id: sessionId,
+    phoneNumber: sanitizedPhone,
+    channel,
+    reason: "ended",
+    language,
+    startedAt: context.createdAt,
+    endedAt: now,
+    durationMs: now - context.createdAt,
+    conversationId
+  }).catch((err) => {
+    logger.error("session persistence failed", { phoneNumber, error: getErrorMessage(err) });
+  });
+  for (const msg of messages) {
+    const messageId = `${sessionId}-${msg.timestamp}-${msg.role}`;
+    insertMessage({
+      id: messageId,
+      sessionId,
+      role: msg.role,
+      content: msg.content,
+      timestamp: msg.timestamp
+    }).catch((err) => {
+      logger.error("message persistence failed", { phoneNumber, error: getErrorMessage(err) });
+    });
+  }
+}
+function persistFinalSession(phoneNumber, channel, reason, transferReason) {
+  const context = getContext(phoneNumber);
+  const language = getDetectedLanguage(phoneNumber) || "en";
+  if (!context) return;
+  if (!getDbClient()) return;
+  const sanitizedPhone = phoneNumber.replace(/[^0-9]/g, "");
+  const sessionId = generateSessionId(phoneNumber, context.createdAt);
+  const now = Date.now();
+  upsertSession({
+    id: sessionId,
+    phoneNumber: sanitizedPhone,
+    channel,
+    reason,
+    language,
+    startedAt: context.createdAt,
+    endedAt: now,
+    durationMs: now - context.createdAt,
+    transferReason
+  }).catch((err) => {
+    logger.error("final session persistence failed", {
+      phoneNumber,
+      error: getErrorMessage(err)
+    });
+  });
+}
+
+// src/routes/call/handle-respond.ts
+init_pending();
+
+// src/core/chatbot/conversations.ts
+var conversations = /* @__PURE__ */ new Map();
+function getOrCreateConversation(phoneNumber, systemMessage) {
+  const existing = conversations.get(phoneNumber);
+  if (existing) {
+    existing.lastActivityAt = Date.now();
+    return existing;
+  }
+  const conversation = {
+    conversationId: crypto.randomUUID(),
+    chatHistory: systemMessage ? [{ role: "system", content: systemMessage }] : [],
+    createdAt: Date.now(),
+    lastActivityAt: Date.now()
+  };
+  conversations.set(phoneNumber, conversation);
+  logger.info("chatbot conversation created", {
+    phoneNumber,
+    conversationId: conversation.conversationId
+  });
+  return conversation;
+}
+function addUserMessage(phoneNumber, content, systemMessage) {
+  const conversation = getOrCreateConversation(phoneNumber, systemMessage);
+  conversation.chatHistory.push({ role: "user", content });
+  conversation.lastActivityAt = Date.now();
+}
+function addBotMessage(phoneNumber, content, systemMessage) {
+  const conversation = getOrCreateConversation(phoneNumber, systemMessage);
+  conversation.chatHistory.push({ role: "assistant", content });
+  conversation.lastActivityAt = Date.now();
+}
+
+// src/core/chatbot/client.ts
+var DEFAULT_SYSTEM_MESSAGE = "You are a voice assistant. Always refer to the subject in third person.";
+async function chatViaHTTP(config, phoneNumber, message) {
+  const systemMessage = config.systemMessage || DEFAULT_SYSTEM_MESSAGE;
+  addUserMessage(phoneNumber, message, systemMessage);
+  const conversation = getOrCreateConversation(phoneNumber, systemMessage);
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.apiKey) {
+    headers["x-api-key"] = config.apiKey;
+  }
+  const body = JSON.stringify({
+    messages: conversation.chatHistory
+  });
+  logger.info("chatbot request", {
+    phoneNumber,
+    conversationId: conversation.conversationId,
+    message: message.substring(0, 100),
+    historyLength: conversation.chatHistory.length
+  });
+  try {
+    const response = await fetch(config.url, {
+      method: "POST",
+      headers,
+      body
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      logger.error("chatbot error", {
+        status: response.status,
+        statusText: response.statusText,
+        error: errorText
+      });
+      throw new Error(`Chatbot API error: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    logger.info("chatbot response", {
+      phoneNumber,
+      conversationId: conversation.conversationId,
+      reply: data.reply.substring(0, 200)
+    });
+    const answer = data.reply || "Sorry, I could not process your request.";
+    addBotMessage(phoneNumber, answer, systemMessage);
+    return answer;
+  } catch (error) {
+    logger.error("chatbot request failed", {
+      phoneNumber,
+      error: getErrorMessage(error)
+    });
+    return "Sorry, I encountered an error processing your question.";
+  }
+}
+
+// src/core/chat.ts
+async function chat(deps, phoneNumber, message) {
+  if (deps.config.chatFn) {
+    return deps.config.chatFn(phoneNumber, message);
+  }
+  if (deps.config.chatbot?.url) {
+    return chatViaHTTP(deps.config.chatbot, phoneNumber, message);
+  }
+  try {
+    const { completeOnce } = await import("@diegoaltoworks/chatter");
+    const { client: client2, store, prompts } = deps.chatter;
+    const ragContext = await store.query(message, 6, ["base", "public"]);
+    const system = [
+      prompts.baseSystemRules,
+      prompts.publicPersona,
+      `Context:
+${ragContext.join("\n\n")}`
+    ].join("\n\n");
+    const result = await completeOnce({
+      client: client2,
+      system,
+      messages: [{ role: "user", content: message }]
+    });
+    return result.content;
+  } catch (error) {
+    logger.error("chat error", { phoneNumber, error: getErrorMessage(error) });
+    return "Sorry, I encountered an error processing your question.";
+  }
+}
+
+// src/core/processing/openai.ts
+var OPENAI_API_URL2 = "https://api.openai.com/v1/chat/completions";
+async function callOpenAI(deps, systemPrompt, userMessage, context) {
+  const headers = {
+    Authorization: `Bearer ${deps.openaiApiKey}`,
+    "Content-Type": "application/json"
+  };
+  const requestBody = {
+    model: deps.openaiModel,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ],
+    temperature: 0.3
+  };
+  logger.info(`${context.stage} request`, {
+    phoneNumber: context.phoneNumber,
+    stage: context.stage,
+    input: userMessage.substring(0, 160) + (userMessage.length > 160 ? "..." : "")
+  });
+  const response = await fetch(OPENAI_API_URL2, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    logger.error(`${context.stage} openai error`, {
+      phoneNumber: context.phoneNumber,
+      status: response.status,
+      error
+    });
+    throw new Error(`OpenAI API error: ${response.status}`);
+  }
+  const data = await response.json();
+  const content = data.choices[0]?.message?.content || "";
+  logger.info(`${context.stage} response`, {
+    phoneNumber: context.phoneNumber,
+    stage: context.stage,
+    output: content.substring(0, 160) + (content.length > 160 ? "..." : ""),
+    tokens: data.usage?.total_tokens
+  });
+  return content;
+}
+
+// src/core/processing/prompts.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
+var incomingPrompt = null;
+var outgoingPrompt = null;
+function loadPromptFile(filename, customPath) {
+  if (customPath && existsSync3(customPath)) {
+    return readFileSync5(customPath, "utf-8");
+  }
+  const builtinPath = join4(__dirname, "../../../prompts", filename);
+  if (existsSync3(builtinPath)) {
+    return readFileSync5(builtinPath, "utf-8");
+  }
+  throw new Error(`Prompt file not found: ${filename}`);
+}
+function getIncomingPrompt(deps) {
+  if (!incomingPrompt) {
+    try {
+      incomingPrompt = loadPromptFile("incoming.md", deps.config.processing?.incomingPromptPath);
+      logger.info("incoming prompt loaded");
+    } catch (error) {
+      logger.error("failed to load incoming prompt", { error: getErrorMessage(error) });
+      incomingPrompt = "Return JSON with shouldTransfer (boolean), shouldEndCall (boolean), detectedLanguage (string), processedMessage (string)";
+    }
+  }
+  return incomingPrompt;
+}
+function getOutgoingPrompt(deps) {
+  if (!outgoingPrompt) {
+    try {
+      outgoingPrompt = loadPromptFile("outgoing.md", deps.config.processing?.outgoingPromptPath);
+      logger.info("outgoing prompt loaded");
+    } catch (error) {
+      logger.error("failed to load outgoing prompt", { error: getErrorMessage(error) });
+      outgoingPrompt = "Make this response phone-friendly and brief.";
+    }
+  }
+  return outgoingPrompt;
+}
+
+// src/core/processing/incoming.ts
+async function processIncoming(deps, phoneNumber, userMessage, channel = "call") {
+  try {
+    getOrCreateContext(phoneNumber, channel);
+    const history = getMessageHistory(phoneNumber);
+    addMessage(phoneNumber, "user", userMessage, channel);
+    let contextualMessage = userMessage;
+    if (history.length > 0) {
+      const recentHistory = history.slice(-4);
+      const historyText = recentHistory.map((m) => `${m.role === "user" ? "Customer" : "Bot"}: ${m.content}`).join("\n");
+      contextualMessage = `CONVERSATION HISTORY:
+${historyText}
+
+CURRENT MESSAGE:
+${userMessage}`;
+    }
+    const result = await callOpenAI(deps, getIncomingPrompt(deps), contextualMessage, {
+      phoneNumber,
+      stage: "incoming"
+    });
+    const cleanedResult = result.replace(/^```json\s*/i, "").replace(/^```\s*/i, "").replace(/\s*```$/i, "").trim();
+    const parsed = JSON.parse(cleanedResult);
+    const detectedLang = parsed.detectedLanguage || "en";
+    setDetectedLanguage(phoneNumber, detectedLang);
+    const storedLanguage = getDetectedLanguage(phoneNumber) || "en";
+    logger.info("INCOMING", {
+      phoneNumber,
+      channel,
+      in: userMessage,
+      out: parsed.processedMessage,
+      lang: storedLanguage,
+      ...parsed.shouldTransfer && { transfer: true },
+      ...parsed.shouldEndCall && { endCall: true }
+    });
+    return {
+      shouldTransfer: parsed.shouldTransfer ?? false,
+      shouldEndCall: parsed.shouldEndCall ?? false,
+      detectedLanguage: storedLanguage,
+      processedMessage: parsed.processedMessage || userMessage
+    };
+  } catch (error) {
+    logger.error("incoming processing error", {
+      phoneNumber,
+      error: getErrorMessage(error)
+    });
+    return {
+      shouldTransfer: false,
+      shouldEndCall: false,
+      detectedLanguage: getDetectedLanguage(phoneNumber) || "en",
+      processedMessage: userMessage
+    };
+  }
+}
+
+// src/core/processing/outgoing.ts
+async function processOutgoing(deps, phoneNumber, botResponse, channel = "call") {
+  try {
+    const language = getDetectedLanguage(phoneNumber) || "en";
+    const prompt = getOutgoingPrompt(deps);
+    const promptWithContext = `${prompt}
+
+---
+Channel: ${channel}
+Respond in: ${language}`;
+    const result = await callOpenAI(deps, promptWithContext, botResponse, {
+      phoneNumber,
+      stage: "outgoing"
+    });
+    addMessage(phoneNumber, "assistant", result || botResponse, channel);
+    logger.info("OUTGOING", {
+      phoneNumber,
+      channel,
+      in: botResponse,
+      out: result,
+      lang: language
+    });
+    return result || botResponse;
+  } catch (error) {
+    logger.error("outgoing processing error", {
+      phoneNumber,
+      channel,
+      error: getErrorMessage(error)
+    });
+    return botResponse;
+  }
+}
+
+// src/flows/params.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+var OPENAI_API_URL3 = "https://api.openai.com/v1/chat/completions";
+async function extractParameters(deps, flow, phoneNumber, userMessage, existingParams) {
+  const instructions = readFileSync6(flow.instructionsPath, "utf-8");
+  const schema = flow.definition.schema;
+  const properties = schema.properties || {};
+  const required = schema.required || [];
+  const schemaDescription = Object.entries(properties).map(
+    ([key, field]) => `- ${key} (${field.type}${required.includes(key) ? ", required" : ""}): ${field.description || ""}`
+  ).join("\n");
+  const existingParamsStr = Object.keys(existingParams).length > 0 ? `
+
+Already collected:
+${JSON.stringify(existingParams, null, 2)}` : "";
+  const missingFields = required.filter((key) => !existingParams[key]);
+  const currentlyAsking = missingFields.length > 0 ? missingFields[0] : null;
+  const now = /* @__PURE__ */ new Date();
+  const todayStr = now.toISOString().split("T")[0];
+  const currentYear = now.getFullYear();
+  const currentMonth = now.getMonth() + 1;
+  const nextYear = currentYear + 1;
+  const tomorrow = new Date(now);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  const tomorrowStr = tomorrow.toISOString().split("T")[0];
+  const dateContext = `
+
+## CRITICAL DATE CONTEXT
+TODAY IS: ${todayStr} (year ${currentYear}, month ${currentMonth})
+
+**DATE EXTRACTION RULES:**
+- "tomorrow" = ${tomorrowStr}
+- Months 1-${currentMonth} = year ${nextYear}
+- Months ${currentMonth + 1}-12 = year ${currentYear}
+- NEVER output a date before ${todayStr}`;
+  const currentFieldHint = currentlyAsking ? `
+
+## IMPORTANT CONTEXT
+We just asked the user for: "${currentlyAsking}"
+If the user's response is a simple value, interpret it as the value for the "${currentlyAsking}" parameter.` : "";
+  const systemPrompt = `${instructions}
+${dateContext}
+
+## Schema
+${schemaDescription}
+${existingParamsStr}
+${currentFieldHint}
+
+## Task
+Extract any parameters from the user's message that match the schema above.
+Return JSON with:
+- "extractedParams": object with any NEW parameters found
+- "allParamsFilled": boolean indicating if ALL required params are now complete
+
+If not all params are filled, do NOT include "nextPrompt" - we'll generate that separately.`;
+  const requestBody = {
+    model: deps.openaiModel,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ],
+    temperature: 0.2,
+    response_format: { type: "json_object" }
+  };
+  logger.info("flow extracting params", {
+    phoneNumber,
+    flow: flow.definition.id,
+    msg: userMessage.substring(0, 160),
+    existing: Object.keys(existingParams).length > 0 ? existingParams : void 0,
+    askingFor: currentlyAsking || "none"
+  });
+  const response = await fetch(OPENAI_API_URL3, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${deps.openaiApiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    logger.error("flow parameter extraction error", {
+      phoneNumber,
+      flowName: flow.definition.id,
+      status: response.status,
+      error
+    });
+    throw new Error(`OpenAI API error: ${response.status}`);
+  }
+  const data = await response.json();
+  const content = data.choices[0]?.message?.content || "{}";
+  const result = JSON.parse(content);
+  const mergedParams = { ...existingParams, ...result.extractedParams || {} };
+  const requiredFields = schema.required || [];
+  const allRequiredFilled = requiredFields.every(
+    (key) => mergedParams[key] !== void 0 && mergedParams[key] !== null
+  );
+  logger.info("flow params extracted", {
+    phoneNumber,
+    flow: flow.definition.id,
+    extracted: result.extractedParams,
+    complete: allRequiredFilled
+  });
+  let nextPrompt;
+  if (!allRequiredFilled) {
+    const missingKey = requiredFields.find(
+      (key) => mergedParams[key] === void 0 || mergedParams[key] === null
+    );
+    if (missingKey) {
+      nextPrompt = `What is the ${missingKey.replace(/([A-Z])/g, " $1").toLowerCase()}?`;
+    }
+  }
+  return {
+    extractedParams: result.extractedParams || {},
+    allParamsFilled: allRequiredFilled,
+    nextPrompt
+  };
+}
+
+// src/flows/utils.ts
+var CANCELLATION_KEYWORDS = ["cancel", "nevermind", "stop", "forget it", "quit"];
+function shouldExitFlow(message) {
+  const lowerMessage = message.toLowerCase();
+  return CANCELLATION_KEYWORDS.some((keyword) => lowerMessage.includes(keyword));
+}
+function getExitMessage(language, languageDir) {
+  return getFlowPhrase(language, "cancelled", languageDir);
+}
+
+// src/flows/manager.ts
+async function processFlow(deps, registry, phoneNumber, userMessage, channel) {
+  const activeFlow = getActiveFlow(phoneNumber);
+  if (activeFlow && shouldExitFlow(userMessage)) {
+    logger.info("flow cancelled", { phoneNumber, flow: activeFlow.flowName });
+    clearActiveFlow(phoneNumber);
+    const language = getDetectedLanguage(phoneNumber) || "en";
+    return {
+      isFlowActive: false,
+      response: getExitMessage(language, deps.config.languageDir),
+      flowCompleted: false
+    };
+  }
+  if (activeFlow) {
+    const flow = registry.getFlow(activeFlow.flowName);
+    if (!flow) {
+      logger.error("active flow not found in registry", {
+        phoneNumber,
+        flowName: activeFlow.flowName
+      });
+      clearActiveFlow(phoneNumber);
+      return { isFlowActive: false, response: "", flowCompleted: false };
+    }
+    try {
+      const extraction = await extractParameters(
+        deps,
+        flow,
+        phoneNumber,
+        userMessage,
+        activeFlow.params
+      );
+      updateFlowParams(phoneNumber, extraction.extractedParams);
+      if (extraction.allParamsFilled) {
+        logger.info("flow executing", {
+          phoneNumber,
+          flow: activeFlow.flowName,
+          params: { ...activeFlow.params, ...extraction.extractedParams }
+        });
+        const result = await flow.handler(
+          { ...activeFlow.params, ...extraction.extractedParams },
+          { phoneNumber, channel }
+        );
+        clearActiveFlow(phoneNumber);
+        return {
+          isFlowActive: false,
+          response: result.say,
+          flowCompleted: true,
+          smsContent: result.sms,
+          flowSuccess: result.success
+        };
+      }
+      return {
+        isFlowActive: true,
+        response: extraction.nextPrompt || "Could you provide more details?",
+        flowCompleted: false
+      };
+    } catch (error) {
+      logger.error("flow error", {
+        phoneNumber,
+        flow: activeFlow.flowName,
+        error: getErrorMessage(error)
+      });
+      clearActiveFlow(phoneNumber);
+      return {
+        isFlowActive: false,
+        response: "Sorry, I encountered an error. Let's start over.",
+        flowCompleted: false
+      };
+    }
+  }
+  const conversationHistory = getMessageHistory(phoneNumber);
+  const conversationContext = conversationHistory.slice(-5).map((msg) => `${msg.role === "assistant" ? "Bot" : "User"}: ${msg.content}`);
+  const matchedFlow = await registry.matchFlow(deps, phoneNumber, userMessage, conversationContext);
+  if (matchedFlow) {
+    const globalParams = matchedFlow.prefill ? matchedFlow.prefill(phoneNumber, {}) : {};
+    logger.info("flow started", {
+      phoneNumber,
+      flow: matchedFlow.definition.id,
+      msg: userMessage.substring(0, 160)
+    });
+    try {
+      const extraction = await extractParameters(
+        deps,
+        matchedFlow,
+        phoneNumber,
+        userMessage,
+        globalParams
+      );
+      const mergedParams = { ...globalParams, ...extraction.extractedParams };
+      setActiveFlow(phoneNumber, matchedFlow.definition.id, mergedParams);
+      if (extraction.allParamsFilled) {
+        logger.info("flow instant complete", {
+          phoneNumber,
+          flow: matchedFlow.definition.id,
+          params: mergedParams
+        });
+        const result = await matchedFlow.handler(mergedParams, { phoneNumber, channel });
+        clearActiveFlow(phoneNumber);
+        return {
+          isFlowActive: false,
+          response: result.say,
+          flowCompleted: true,
+          smsContent: result.sms,
+          flowSuccess: result.success
+        };
+      }
+      return {
+        isFlowActive: true,
+        response: extraction.nextPrompt || "Could you provide more details?",
+        flowCompleted: false
+      };
+    } catch (error) {
+      logger.error("flow init error", {
+        phoneNumber,
+        flow: matchedFlow.definition.id,
+        error: getErrorMessage(error)
+      });
+      return { isFlowActive: false, response: "", flowCompleted: false };
+    }
+  }
+  return { isFlowActive: false, response: "", flowCompleted: false };
+}
+
+// src/routes/call/processor.ts
+async function processCall(deps, registry, phoneNumber, speechResult) {
+  const incoming = await processIncoming(deps, phoneNumber, speechResult, "call");
+  if (incoming.shouldTransfer) {
+    logger.info("transferring to human", { phoneNumber, language: incoming.detectedLanguage });
+    persistSession(phoneNumber, "call");
+    persistFinalSession(phoneNumber, "call", "redirected", incoming.processedMessage);
+    return transferTwiml(incoming.detectedLanguage, deps.config);
+  }
+  if (incoming.shouldEndCall) {
+    logger.info("ending call - user done", { phoneNumber, language: incoming.detectedLanguage });
+    persistSession(phoneNumber, "call");
+    persistFinalSession(phoneNumber, "call", "ended");
+    clearContext(phoneNumber);
+    return farewellTwiml(incoming.detectedLanguage, deps.config);
+  }
+  const flowResult = await processFlow(
+    deps,
+    registry,
+    phoneNumber,
+    incoming.processedMessage,
+    "call"
+  );
+  if (flowResult.isFlowActive || flowResult.flowCompleted) {
+    logger.info("FLOW RESULT", {
+      phoneNumber,
+      active: flowResult.isFlowActive,
+      done: flowResult.flowCompleted,
+      success: flowResult.flowSuccess
+    });
+    if (flowResult.flowCompleted && flowResult.flowSuccess === false) {
+      const { voice, language: lang } = getVoiceConfig(
+        incoming.detectedLanguage,
+        deps.config.voices
+      );
+      const transferNumber = deps.config.transferNumber || "";
+      return `<?xml version="1.0" encoding="UTF-8"?>
+<Response>
+    <Say voice="${voice}" language="${lang}">${flowResult.response}</Say>
+    <Dial>${transferNumber}</Dial>
+</Response>`;
+    }
+    const escapedResponse2 = escapeXml(flowResult.response);
+    return gatherTwiml(escapedResponse2, incoming.detectedLanguage, deps.config, phoneNumber);
+  }
+  const botResponse = await chat(deps, phoneNumber, incoming.processedMessage);
+  const phoneResponse = await processOutgoing(deps, phoneNumber, botResponse, "call");
+  const escapedResponse = escapeXml(phoneResponse);
+  return gatherTwiml(escapedResponse, incoming.detectedLanguage, deps.config, phoneNumber);
+}
+
+// src/routes/call/handle-respond.ts
+async function handleRespond(c, deps, registry) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  const speechResult = body.SpeechResult;
+  const config = deps.config;
+  logger.info("speech received", { phoneNumber, speechResult });
+  if (!speechResult) {
+    const twiml = gatherTwiml(
+      getPhrase("en", "didNotCatch", config.languageDir),
+      "en",
+      config,
+      phoneNumber
+    );
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  }
+  resetNoSpeechRetries(phoneNumber);
+  const messageHistory = getMessageHistory(phoneNumber);
+  const isFirstMessage = messageHistory.filter((m) => m.role === "user").length === 0;
+  const ackEnabled = config.features?.thinkingAcknowledgmentEnabled ?? false;
+  if (ackEnabled && isFirstMessage) {
+    let resolveQuery;
+    const promise = new Promise((resolve) => {
+      resolveQuery = resolve;
+    });
+    setPending(phoneNumber, {
+      speechResult,
+      promise,
+      resolve: resolveQuery
+    });
+    processCall(deps, registry, phoneNumber, speechResult).then((twiml) => {
+      const pending = getPendingForResolve(phoneNumber);
+      if (pending) pending.resolve({ twiml });
+      persistSession(phoneNumber, "call");
+    }).catch((error) => {
+      logger.error("background processing error", {
+        phoneNumber,
+        error: getErrorMessage(error)
+      });
+      const pending = getPendingForResolve(phoneNumber);
+      if (pending) {
+        pending.resolve({
+          twiml: sayTwiml(getPhrase("en", "error", config.languageDir), "en", config)
+        });
+      }
+    });
+    return c.text(acknowledgmentTwiml("en", config), 200, { "Content-Type": "text/xml" });
+  }
+  try {
+    const twiml = await processCall(deps, registry, phoneNumber, speechResult);
+    persistSession(phoneNumber, "call");
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  } catch (error) {
+    logger.error("call processing error", { error: getErrorMessage(error) });
+    const twiml = sayTwiml(getPhrase("en", "error", config.languageDir), "en", config);
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  }
+}
+function getPendingForResolve(phoneNumber) {
+  const { getPending: getPending2 } = (init_pending(), __toCommonJS(pending_exports));
+  return getPending2(phoneNumber);
+}
+
+// src/routes/call/handle-status.ts
+async function handleStatus(c) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  const callStatus = body.CallStatus;
+  logger.info("call status update", { phoneNumber, callStatus });
+  if (callStatus === "completed") {
+    persistSession(phoneNumber, "call");
+    persistFinalSession(phoneNumber, "call", "ended");
+    clearContext(phoneNumber);
+  }
+  return c.text("", 200);
+}
+
+// src/routes/call/index.ts
+function callRoutes(deps, registry) {
+  const app = new Hono();
+  app.post("/call", (c) => handleInitialCall(c, deps.config));
+  app.post("/call/respond", (c) => handleRespond(c, deps, registry));
+  app.post("/call/answer", (c) => handleAnswer(c, deps.config));
+  app.post("/call/no-speech", (c) => handleNoSpeech(c, deps.config));
+  app.post("/call/status", (c) => handleStatus(c));
+  return app;
+}
+
+// src/routes/sms/index.ts
+import { Hono as Hono2 } from "hono";
+
+// src/routes/sms/processor.ts
+async function processSms(deps, registry, phoneNumber, messageBody) {
+  const incoming = await processIncoming(deps, phoneNumber, messageBody, "sms");
+  if (incoming.shouldTransfer) {
+    const message = getSmsPhrase(incoming.detectedLanguage, "callForHelp", deps.config.languageDir);
+    return messageTwiml(message);
+  }
+  const flowResult = await processFlow(
+    deps,
+    registry,
+    phoneNumber,
+    incoming.processedMessage,
+    "sms"
+  );
+  if (flowResult.isFlowActive || flowResult.flowCompleted) {
+    if (flowResult.flowCompleted && flowResult.flowSuccess === false) {
+      const message = getSmsPhrase(
+        incoming.detectedLanguage,
+        "processingError",
+        deps.config.languageDir
+      );
+      return messageTwiml(message);
+    }
+    return messageTwiml(flowResult.response);
+  }
+  const botResponse = await chat(deps, phoneNumber, incoming.processedMessage);
+  const smsResponse = await processOutgoing(deps, phoneNumber, botResponse, "sms");
+  return messageTwiml(smsResponse);
+}
+
+// src/routes/sms/handle-incoming.ts
+async function handleIncomingSMS(c, deps, registry) {
+  const body = await c.req.parseBody();
+  const phoneNumber = (body.From || "unknown").trim();
+  const messageBody = body.Body || "";
+  logger.info("sms received", { phoneNumber, messageBody });
+  if (!messageBody.trim()) {
+    return c.text(messageTwiml(getSmsPhrase("en", "greeting", deps.config.languageDir)), 200, {
+      "Content-Type": "text/xml"
+    });
+  }
+  try {
+    const twiml = await processSms(deps, registry, phoneNumber, messageBody);
+    persistSession(phoneNumber, "sms");
+    return c.text(twiml, 200, { "Content-Type": "text/xml" });
+  } catch (error) {
+    logger.error("sms processing error", {
+      phoneNumber,
+      error: getErrorMessage(error)
+    });
+    return c.text(messageTwiml(getSmsPhrase("en", "genericError", deps.config.languageDir)), 200, {
+      "Content-Type": "text/xml"
+    });
+  }
+}
+
+// src/routes/sms/index.ts
+function smsRoutes(deps, registry) {
+  const app = new Hono2();
+  app.post("/sms", (c) => handleIncomingSMS(c, deps, registry));
+  app.get("/sms", (c) => c.text("SMS endpoint active"));
+  return app;
+}
+
+// src/plugin.ts
+var DEFAULT_CONTEXT_TTL_MS = 30 * 60 * 1e3;
+var DEFAULT_CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var DEFAULT_MODEL = "gpt-4o-mini";
+async function createTelephonyRoutes(app, chatterDeps, config) {
+  logger.info("initializing telephony routes");
+  const openaiApiKey = config.openaiApiKey || chatterDeps.config.openai.apiKey;
+  if (!openaiApiKey) {
+    throw new Error("OpenAI API key required for talker");
+  }
+  const deps = {
+    chatter: chatterDeps,
+    config,
+    openaiApiKey,
+    openaiModel: config.processing?.model || DEFAULT_MODEL
+  };
+  const dbUrl = config.database?.url || chatterDeps.config.database?.url;
+  const dbToken = config.database?.authToken || chatterDeps.config.database?.authToken;
+  if (dbUrl && dbToken) {
+    initDbClient(dbUrl, dbToken);
+    await runMigrations();
+  }
+  const registry = new FlowRegistry(config.flowsDir || "");
+  if (config.flowsDir) {
+    await registry.loadFlows();
+  }
+  startCleanup(
+    config.contextTtlMs ?? DEFAULT_CONTEXT_TTL_MS,
+    config.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS
+  );
+  const prefix = config.routePrefix || "";
+  app.route(prefix, callRoutes(deps, registry));
+  app.route(prefix, smsRoutes(deps, registry));
+  logger.info("telephony routes mounted", {
+    prefix: prefix || "/",
+    hasFlows: !!config.flowsDir,
+    flowCount: registry.getAllFlows().length,
+    hasTransferNumber: !!config.transferNumber
+  });
+}
+
+// src/standalone.ts
+import { Hono as Hono3 } from "hono";
+var DEFAULT_CONTEXT_TTL_MS2 = 30 * 60 * 1e3;
+var DEFAULT_CLEANUP_INTERVAL_MS2 = 5 * 60 * 1e3;
+var DEFAULT_MODEL2 = "gpt-4o-mini";
+async function createStandaloneServer(config) {
+  logger.info("initializing standalone talker server");
+  if (!config.openaiApiKey) {
+    throw new Error("openaiApiKey is required for standalone mode");
+  }
+  const stubChatterDeps = {
+    config: { openai: { apiKey: config.openaiApiKey } }
+  };
+  const deps = {
+    chatter: stubChatterDeps,
+    config,
+    openaiApiKey: config.openaiApiKey,
+    openaiModel: config.processing?.model || DEFAULT_MODEL2
+  };
+  if (config.database?.url && config.database?.authToken) {
+    initDbClient(config.database.url, config.database.authToken);
+    await runMigrations();
+  }
+  const registry = new FlowRegistry(config.flowsDir || "");
+  if (config.flowsDir) {
+    await registry.loadFlows();
+  }
+  startCleanup(
+    config.contextTtlMs ?? DEFAULT_CONTEXT_TTL_MS2,
+    config.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS2
+  );
+  const app = new Hono3();
+  app.get("/healthz", (c) => c.text("ok"));
+  const prefix = config.routePrefix || "";
+  app.route(prefix, callRoutes(deps, registry));
+  app.route(prefix, smsRoutes(deps, registry));
+  logger.info("standalone talker server ready", {
+    prefix: prefix || "/",
+    hasFlows: !!config.flowsDir,
+    flowCount: registry.getAllFlows().length,
+    hasChatFn: !!config.chatFn,
+    hasTransferNumber: !!config.transferNumber
+  });
+  return app;
+}
+
+// src/adapters/twilio.ts
+async function sendSMS(config, to, message) {
+  if (!config.accountSid || !config.authToken || !config.phoneNumber) {
+    logger.warn("Twilio credentials not configured, skipping SMS send", { to });
+    return false;
+  }
+  try {
+    const auth = Buffer.from(`${config.accountSid}:${config.authToken}`).toString("base64");
+    const response = await fetch(
+      `https://api.twilio.com/2010-04-01/Accounts/${config.accountSid}/Messages.json`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          From: config.phoneNumber,
+          To: to,
+          Body: message
+        })
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      logger.error("SMS send failed", { to, status: response.status, error });
+      return false;
+    }
+    const data = await response.json();
+    logger.info("SMS sent successfully", { to, messageSid: data.sid });
+    return true;
+  } catch (error) {
+    logger.error("SMS send error", {
+      to,
+      error: error instanceof Error ? error.message : "Unknown"
+    });
+    return false;
+  }
+}
+export {
+  FlowRegistry,
+  acknowledgmentTwiml,
+  addMessage,
+  callRoutes,
+  clearActiveFlow,
+  clearAllContexts,
+  clearContext,
+  closeDbClient,
+  createStandaloneServer,
+  createTelephonyRoutes,
+  escapeXml,
+  farewellTwiml,
+  gatherTwiml,
+  getActiveFlow,
+  getContext,
+  getDbClient,
+  getDefaultVoices,
+  getDetectedLanguage,
+  getExitMessage,
+  getFarewellPhrase,
+  getFlowPhrase,
+  getLastPrompt,
+  getMessageHistory,
+  getOrCreateContext,
+  getPhrase,
+  getSmsPhrase,
+  getVoiceConfig,
+  incrementNoSpeechRetries,
+  initDbClient,
+  loadFlowsFromDirectory,
+  loadPhrases,
+  logger,
+  messageTwiml,
+  persistFinalSession,
+  persistSession,
+  processFlow,
+  processIncoming,
+  processOutgoing,
+  resetNoSpeechRetries,
+  runMigrations,
+  sayTwiml,
+  sendSMS,
+  setActiveFlow,
+  setDetectedLanguage,
+  setLastPrompt,
+  shouldExitFlow,
+  smsRoutes,
+  startCleanup,
+  stopCleanup,
+  transferTwiml,
+  updateFlowParams
+};