@sinch/functions-runtime 0.3.7 → 0.3.9

package/dist/index.js

@@ -168,6 +168,21 @@ var IceSvamlBuilder = class extends BaseSvamlBuilder {
    *
    * @param number - E.164 formatted phone number (e.g., '+15551234567')
    * @param options - Connection options
+   *
+   * @example
+   * ```typescript
+   * // Simple connect
+   * new IceSvamlBuilder().connectPstn('+15551234567').build();
+   *
+   * // With options: caller ID, timeout, and AMD
+   * new IceSvamlBuilder()
+   *   .connectPstn('+15551234567', {
+   *     cli: '+15559876543',
+   *     timeout: 30,
+   *     amd: { enabled: true },
+   *   })
+   *   .build();
+   * ```
    */
   connectPstn(number, options) {
     this.action = {
@@ -224,6 +239,22 @@ var IceSvamlBuilder = class extends BaseSvamlBuilder {
    *
    * @param menus - Array of menu definitions or MenuStructure from createMenu().build()
    * @param options - Menu options
+   *
+   * @example
+   * ```typescript
+   * // Using MenuTemplates
+   * new IceSvamlBuilder()
+   *   .runMenu(MenuTemplates.business('Acme Corp'))
+   *   .build();
+   *
+   * // Using createMenu builder
+   * const menu = createMenu()
+   *   .prompt('Press 1 for sales, 2 for support.')
+   *   .option('1', 'return(sales)')
+   *   .option('2', 'return(support)')
+   *   .build();
+   * new IceSvamlBuilder().runMenu(menu).build();
+   * ```
    */
   runMenu(menus, options) {
     const menuArray = Array.isArray(menus) ? menus : menus.menus;
@@ -241,6 +272,14 @@ var IceSvamlBuilder = class extends BaseSvamlBuilder {
    *
    * @param holdPrompt - Prompt to play while on hold
    * @param options - Park options
+   *
+   * @example
+   * ```typescript
+   * // Park with hold music prompt
+   * new IceSvamlBuilder()
+   *   .park('Please hold while we connect you.', { maxDuration: 120 })
+   *   .build();
+   * ```
    */
   park(holdPrompt, options) {
     this.action = {
@@ -869,7 +908,10 @@ function createLenientJsonParser(options = {}) {
     }
     try {
       let parsed = parseJson(raw, opts.allowJson5);
-      parsed = transformKeys(parsed, opts.camelCase);
+      const isWebhookPath = req.path.startsWith("/webhook");
+      if (!isWebhookPath) {
+        parsed = transformKeys(parsed, opts.camelCase);
+      }
       req._keysTransformed = true;
       req.body = parsed;
       next();
@@ -988,6 +1030,12 @@ function extractFunctionName(path5, body) {
   if (segments.length === 1 && isVoiceCallback(segments[0])) {
     return segments[0];
   }
+  if (segments.length >= 2 && segments[0] === "webhook") {
+    return `${segments[1]}Webhook`;
+  }
+  if (segments.length === 1 && segments[0] === "webhook") {
+    return "webhook";
+  }
   return segments[segments.length - 1] || "default";
 }
 function generateRequestId() {
@@ -1403,145 +1451,895 @@ var ElevenLabsStateManager = class {
 };
 var ElevenLabsState = new ElevenLabsStateManager();
 
-// ../runtime-shared/dist/utils/templateRender.js
-import fs from "fs";
-import path from "path";
-var TemplateRender = class {
+// ../runtime-shared/dist/ai/elevenlabs/client.js
+var ELEVENLABS_API_BASE = "https://api.elevenlabs.io/v1";
+var FETCH_TIMEOUT_MS = 1e4;
+var ElevenLabsClient = class {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey || process.env.ELEVENLABS_API_KEY || "";
+    if (!this.apiKey) {
+      console.warn("[ElevenLabs] No API key provided. Set ELEVENLABS_API_KEY environment variable.");
+    }
+  }
+  get authHeaders() {
+    return { "xi-api-key": this.apiKey, "Content-Type": "application/json" };
+  }
   /**
-   * Load and render an HTML template with variables
-   * @param templatePath - Path to the HTML template file
-   * @param variables - Object containing variables to replace in template
-   * @returns Rendered HTML string
+   * Initiate an outbound call to a phone number using an ElevenLabs agent
    */
-  static render(templatePath, variables = {}) {
-    try {
-      const template = fs.readFileSync(templatePath, "utf8");
-      let rendered = template;
-      for (const [key, value] of Object.entries(variables)) {
-        const placeholder = `{{${key}}}`;
-        const regex = new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
-        rendered = rendered.replace(regex, String(value));
-      }
-      return rendered;
-    } catch (error) {
-      console.error("Error rendering template:", error);
-      throw new Error(`Failed to render template: ${templatePath}`);
+  async makeCall(options) {
+    const phoneNumberId = ElevenLabsState.getPhoneNumberId();
+    const request = {
+      agent_id: options.agentId,
+      customer_phone_number: options.toNumber,
+      agent_phone_number_id: phoneNumberId
+    };
+    if (options.dynamicVariables && Object.keys(options.dynamicVariables).length > 0) {
+      request.custom_llm_extra_body = {
+        dynamic_variables: options.dynamicVariables
+      };
     }
+    const response = await fetch(`${ELEVENLABS_API_BASE}/convai/conversation/create_call`, {
+      method: "POST",
+      headers: this.authHeaders,
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`ElevenLabs API error: ${response.status} - ${error}`);
+    }
+    return response.json();
   }
   /**
-   * Get the absolute path to a template file relative to the current directory
-   * @param templateName - Name of the template file (e.g., 'index.html')
-   * @param baseDir - Base directory to search from (defaults to cwd)
-   * @returns Absolute path to the template file
+   * Get conversation details including transcript and analysis
    */
-  static getTemplatePath(templateName, baseDir) {
-    const searchDir = baseDir || process.cwd();
-    const pagesPath = path.join(searchDir, "utils", "pages", templateName);
-    if (fs.existsSync(pagesPath)) {
-      return pagesPath;
+  async getConversationDetails(conversationId) {
+    const response = await fetch(`${ELEVENLABS_API_BASE}/convai/conversations/${encodeURIComponent(conversationId)}`, {
+      headers: { "xi-api-key": this.apiKey },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`ElevenLabs API error: ${response.status} - ${error}`);
     }
-    const directPath = path.join(searchDir, "pages", templateName);
-    if (fs.existsSync(directPath)) {
-      return directPath;
+    const data = await response.json();
+    return this.mapConversationResponse(data);
+  }
+  /**
+   * Auto-configure ElevenLabs with Sinch SIP trunk.
+   *
+   * Step 1: Get or import phone number with SIP trunk config
+   * Step 2: Configure agent conversation-init webhook
+   *
+   * Called by tryAutoConfigureAsync (the orchestrator that reads env vars).
+   */
+  async autoConfigureAsync(options) {
+    console.log(`[ElevenLabs] Starting auto-configuration for agent ${options.agentId}`);
+    const phoneResult = await this.getOrImportPhoneNumber(options);
+    if (options.webhookBaseUrl) {
+      await this.configureAgentWebhooks(options.agentId, options.webhookBaseUrl);
+    }
+    console.log(`[ElevenLabs] Auto-configuration completed: PhoneNumberId=${phoneResult.phoneNumberId}`);
+    return {
+      success: true,
+      phoneNumberId: phoneResult.phoneNumberId,
+      phoneNumber: options.phoneNumber,
+      sipAddress: options.sipAddress
+    };
+  }
+  /**
+   * Check if phone number already exists in ElevenLabs; create or update it.
+   * Matches C# GetOrImportPhoneNumberAsync.
+   */
+  async getOrImportPhoneNumber(config) {
+    const listResponse = await fetch(`${ELEVENLABS_API_BASE}/convai/phone-numbers`, {
+      headers: this.authHeaders,
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!listResponse.ok) {
+      throw new Error(`Failed to list phone numbers: ${listResponse.status}`);
+    }
+    const phoneNumbers = await listResponse.json();
+    const sipConfig = {
+      address: config.sipAddress,
+      transport: "tcp",
+      media_encryption: "disabled",
+      credentials: { username: config.sipUsername, password: config.sipPassword }
+    };
+    const existing = phoneNumbers.find((p) => p.phone_number === config.phoneNumber);
+    if (existing) {
+      console.log(`[ElevenLabs] Phone number already exists (${existing.phone_number_id}), updating config`);
+      await this.updatePhoneNumberConfig(existing.phone_number_id, config.agentId, sipConfig);
+      return { phoneNumberId: existing.phone_number_id };
+    }
+    const label = `Sinch Functions - ${config.functionName || "Sinch Function"}`;
+    console.log("[ElevenLabs] Creating SIP trunk phone number");
+    const createResponse2 = await fetch(`${ELEVENLABS_API_BASE}/convai/phone-numbers`, {
+      method: "POST",
+      headers: this.authHeaders,
+      body: JSON.stringify({
+        phone_number: config.phoneNumber,
+        label,
+        provider: "sip_trunk",
+        supports_inbound: true,
+        supports_outbound: true,
+        inbound_trunk_config: { media_encryption: "disabled" },
+        outbound_trunk_config: sipConfig
+      }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!createResponse2.ok) {
+      const err = await createResponse2.text();
+      throw new Error(`Failed to create phone number: ${createResponse2.status} - ${err}`);
+    }
+    const created = await createResponse2.json();
+    console.log("[ElevenLabs] Phone number created successfully");
+    await this.updatePhoneNumberConfig(created.phone_number_id, config.agentId, sipConfig);
+    return { phoneNumberId: created.phone_number_id };
+  }
+  /**
+   * Update phone number with agent association and SIP trunk config.
+   * Matches C# UpdatePhoneNumberConfigAsync.
+   */
+  async updatePhoneNumberConfig(phoneNumberId, agentId, sipConfig) {
+    const response = await fetch(`${ELEVENLABS_API_BASE}/convai/phone-numbers/${encodeURIComponent(phoneNumberId)}`, {
+      method: "PATCH",
+      headers: this.authHeaders,
+      body: JSON.stringify({
+        agent_id: agentId,
+        outbound_trunk_config: sipConfig
+      }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      await response.text();
+      console.warn(`[ElevenLabs] Failed to update phone number config: ${response.status}`);
+    } else {
+      console.log("[ElevenLabs] Phone number configuration updated");
+    }
+  }
+  /**
+   * Configure agent webhook for conversation-init events.
+   * Matches C# ConfigureAgentWebhooksAsync.
+   */
+  async configureAgentWebhooks(agentId, webhookBaseUrl) {
+    const webhookUrl = `${webhookBaseUrl}/webhook/elevenlabs/conversation-init`;
+    console.log(`[ElevenLabs] Configuring agent webhook`);
+    const response = await fetch(`${ELEVENLABS_API_BASE}/convai/agents/${encodeURIComponent(agentId)}`, {
+      method: "PATCH",
+      headers: this.authHeaders,
+      body: JSON.stringify({
+        platform_settings: {
+          workspace_overrides: {
+            conversation_initiation_client_data_webhook: {
+              url: webhookUrl,
+              request_headers: {}
+            }
+          },
+          overrides: {
+            enable_conversation_initiation_client_data_from_webhook: true
+          }
+        }
+      }),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      await response.text();
+      console.error(`[ElevenLabs] Failed to configure agent webhooks: ${response.status}`);
+    } else {
+      console.log("[ElevenLabs] Agent webhooks configured successfully");
     }
-    return path.join(searchDir, "utils", "pages", templateName);
+  }
+  /**
+   * Map API response to our interface
+   */
+  mapConversationResponse(data) {
+    return {
+      conversationId: data.conversation_id,
+      agentId: data.agent_id,
+      status: data.status,
+      metadata: data.metadata ? {
+        callDurationSeconds: data.metadata.call_duration_secs,
+        startTime: data.metadata.start_time_unix_secs ? new Date(data.metadata.start_time_unix_secs * 1e3) : void 0,
+        endTime: data.metadata.end_time_unix_secs ? new Date(data.metadata.end_time_unix_secs * 1e3) : void 0
+      } : void 0,
+      transcript: data.transcript?.map((t) => ({
+        role: t.role,
+        message: t.message,
+        timeInCallSeconds: t.time_in_call_secs
+      })),
+      analysis: data.analysis ? {
+        summary: data.analysis.transcript_summary,
+        customData: data.analysis.custom_data
+      } : void 0
+    };
   }
 };
+function createElevenLabsClient(apiKey) {
+  return new ElevenLabsClient(apiKey);
+}
 
-// ../runtime-shared/dist/utils/versionExtractor.js
-import fs2 from "fs";
-import path2 from "path";
-var VersionExtractor = class {
+// ../runtime-shared/dist/ai/elevenlabs/controller.js
+var ElevenLabsController = class {
   /**
-   * Extract version from README.md file in the template directory
-   * Looks for "Template Version: X.X.X" pattern in the last few lines
-   * @param templateDir - Path to the template directory containing README.md
-   * @returns Version string or default fallback
+   * Handle conversation initialization webhook
+   * Called when an inbound call is received - allows customizing the conversation
+   *
+   * @param request - The conversation init request with caller info
+   * @returns Response with dynamic variables and/or config overrides
    */
-  static getTemplateVersion(templateDir = process.cwd()) {
-    try {
-      const readmePath = path2.join(templateDir, "README.md");
-      if (!fs2.existsSync(readmePath)) {
-        console.warn("README.md not found, using default version");
-        return "v1.0.0";
+  async handleConversationInit(request) {
+    return {};
+  }
+  /**
+   * Handle post-call webhook with transcript and analysis
+   *
+   * @param webhook - The post-call webhook payload
+   */
+  async handlePostCall(webhook) {
+    console.log("[ElevenLabs] Post-call webhook received:", {
+      conversationId: webhook.data.conversation_id,
+      agentId: webhook.data.agent_id,
+      status: webhook.data.status,
+      duration: webhook.data.metadata.call_duration_secs
+    });
+  }
+  /**
+   * Handle post-call audio webhook with recording
+   *
+   * @param webhook - The audio webhook with base64-encoded MP3
+   */
+  async handlePostCallAudio(webhook) {
+    console.log("[ElevenLabs] Post-call audio received:", {
+      conversationId: webhook.data.conversation_id,
+      agentId: webhook.data.agent_id
+    });
+  }
+  /**
+   * Handle call initiation failure webhook
+   *
+   * @param webhook - The failure webhook with error details
+   */
+  async handleCallInitiationFailure(webhook) {
+    console.error("[ElevenLabs] Call initiation failed:", {
+      agentId: webhook.data.agent_id,
+      customerNumber: webhook.data.customer_phone_number,
+      reason: webhook.data.failure_reason
+    });
+  }
+  /**
+   * Express route handler for conversation init endpoint
+   * Mount at: POST /elevenlabs/conversation-init
+   */
+  getConversationInitHandler() {
+    return async (req, res) => {
+      try {
+        const request = req.body;
+        const response = await this.handleConversationInit(request);
+        res.json(response);
+      } catch (error) {
+        console.error("[ElevenLabs] Error in conversation init:", error);
+        res.status(500).json({ error: "Internal server error" });
       }
-      const readmeContent = fs2.readFileSync(readmePath, "utf8");
-      const lines = readmeContent.split("\n");
-      const versionPattern = /Template Version:\s*([\d.]+)/i;
-      for (let i = lines.length - 1; i >= Math.max(0, lines.length - 10); i--) {
-        const match = lines[i].match(versionPattern);
-        if (match) {
-          return `v${match[1]}`;
+    };
+  }
+  /**
+   * Express route handler for webhook endpoint
+   * Mount at: POST /elevenlabs/webhook
+   * Handles all webhook types based on the 'type' field
+   */
+  getWebhookHandler() {
+    return async (req, res) => {
+      try {
+        const webhook = req.body;
+        switch (webhook.type) {
+          case "post_call_transcription":
+            await this.handlePostCall(webhook);
+            break;
+          case "post_call_audio":
+            await this.handlePostCallAudio(webhook);
+            break;
+          case "call_initiation_failure":
+            await this.handleCallInitiationFailure(webhook);
+            break;
+          default:
+            console.warn("[ElevenLabs] Unknown webhook type:", webhook.type);
         }
+        res.status(200).send("OK");
+      } catch (error) {
+        console.error("[ElevenLabs] Error processing webhook:", error);
+        res.status(500).json({ error: "Internal server error" });
       }
-      console.warn("Version pattern not found in README.md, using default");
-      return "v1.0.0";
-    } catch (error) {
-      console.error("Error reading template version:", error.message);
-      return "v1.0.0";
+    };
+  }
+};
+
+// ../runtime-shared/dist/ai/elevenlabs/autoconfigurator.js
+var FETCH_TIMEOUT_MS2 = 1e4;
+function maskPhone(phone) {
+  if (phone.length <= 6)
+    return "***";
+  return phone.slice(0, 4) + "***" + phone.slice(-4);
+}
+async function tryAutoConfigureAsync(webhookUrl, functionName, sinchPhoneNumber) {
+  const autoConfig = process.env.ELEVENLABS_AUTO_CONFIGURE;
+  if (!autoConfig || autoConfig.toLowerCase() !== "true") {
+    return null;
+  }
+  console.log("[ElevenLabs] Auto-configuration is enabled");
+  const agentId = process.env.ELEVENLABS_AGENT_ID;
+  const apiKey = process.env.ELEVENLABS_API_KEY;
+  if (!agentId) {
+    console.warn("[ElevenLabs] Auto-configuration skipped: ELEVENLABS_AGENT_ID not set. Please configure your agent ID in environment variables.");
+    return null;
+  }
+  if (!apiKey) {
+    console.warn("[ElevenLabs] Auto-configuration skipped: ELEVENLABS_API_KEY not set. Please store your API key using: sinch secrets add ELEVENLABS_API_KEY sk_...");
+    return null;
+  }
+  let phoneNumber = sinchPhoneNumber ?? process.env.SINCH_PHONE_NUMBER;
+  if (!phoneNumber) {
+    console.log("[ElevenLabs] SINCH_PHONE_NUMBER not configured, attempting auto-discovery from Voice API...");
+    phoneNumber = await autoDiscoverPhoneNumber();
+  }
+  if (!phoneNumber) {
+    console.warn("[ElevenLabs] Auto-configuration skipped: Sinch phone number not provided and auto-discovery failed. Please set SINCH_PHONE_NUMBER or ensure Voice API credentials are configured.");
+    return null;
+  }
+  if (!webhookUrl) {
+    console.warn("[ElevenLabs] Auto-configuration skipped: Webhook URL not provided.");
+    return null;
+  }
+  try {
+    new URL(webhookUrl);
+  } catch {
+    console.warn("[ElevenLabs] Auto-configuration skipped: Webhook URL is not a valid URL.");
+    return null;
+  }
+  const voiceAppKey = process.env.VOICE_APPLICATION_KEY || "";
+  const voiceAppSecret = process.env.VOICE_APPLICATION_SECRET || "";
+  const safeName = functionName ? functionName.slice(0, 100) : "Sinch Function";
+  try {
+    console.log(`[ElevenLabs] Starting auto-configuration: Agent=${agentId}, Number=${maskPhone(phoneNumber)}`);
+    const client = new ElevenLabsClient(apiKey);
+    const result = await client.autoConfigureAsync({
+      agentId,
+      phoneNumber,
+      sipAddress: "use1.vp.sip.sinch.com",
+      sipUsername: voiceAppKey,
+      sipPassword: voiceAppSecret,
+      webhookBaseUrl: webhookUrl,
+      functionName: safeName
+    });
+    if (result.success) {
+      ElevenLabsState.setConfigured({
+        phoneNumberId: result.phoneNumberId,
+        phoneNumber: result.phoneNumber,
+        agentId,
+        sipAddress: result.sipAddress
+      });
+      console.log(`[ElevenLabs] Auto-configuration completed! Phone: ${maskPhone(result.phoneNumber ?? "")}, SIP: ${result.sipAddress}`);
     }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[ElevenLabs] Auto-configuration failed: ${message}. The function will start but ElevenLabs integration may not work.`);
+    return null;
   }
+}
+async function autoDiscoverPhoneNumber() {
+  const appKey = process.env.VOICE_APPLICATION_KEY || "";
+  const appSecret = process.env.VOICE_APPLICATION_SECRET || "";
+  if (!appKey || !appSecret) {
+    console.warn("[ElevenLabs] Voice client not available for phone number auto-discovery. Ensure VOICE_APPLICATION_KEY and VOICE_APPLICATION_SECRET are configured.");
+    return void 0;
+  }
+  try {
+    const auth = Buffer.from(`${appKey}:${appSecret}`).toString("base64");
+    const configResponse = await fetch(`https://callingapi.sinch.com/v1/configuration/numbers/`, {
+      headers: { Authorization: `Basic ${auth}` },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2)
+    });
+    if (!configResponse.ok) {
+      console.warn(`[ElevenLabs] Failed to query Voice API for phone numbers: ${configResponse.status}`);
+      return void 0;
+    }
+    const data = await configResponse.json();
+    const numbers = (data.numbers || []).filter((n) => n.applicationkey === appKey).map((n) => n.number).filter(Boolean);
+    if (numbers.length > 0) {
+      console.log(`[ElevenLabs] Auto-discovered ${numbers.length} phone number(s), using first`);
+      return numbers[0];
+    }
+    console.warn("[ElevenLabs] No phone numbers found for the configured Voice application");
+    return void 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[ElevenLabs] Failed to auto-discover phone number: ${message}`);
+    return void 0;
+  }
+}
+var ElevenLabsAutoConfigurator = class {
+  static tryAutoConfigureAsync = tryAutoConfigureAsync;
 };
 
-// ../runtime-shared/dist/utils/defaultEndpointHandler.js
-var DefaultEndpointHandler = class {
-  /**
-   * Handle the default endpoint with content negotiation
-   * @param context - Function context with config and cache
-   * @param request - HTTP request object with method, path, query, headers, body, params
-   * @param options - Configuration options for the response
-   * @returns HTTP response object with statusCode, headers, and body
-   */
-  static async handle(context, request, options = {}) {
-    const { serviceName = "Sinch Function", companyName = "Your Company", templateVersion = "v1.0.0", availableEndpoints = {} } = options;
-    console.info("Default endpoint called");
-    console.info(`Request: ${request.method} ${request.path}`);
-    const acceptHeader = request.headers?.accept || request.headers?.Accept || "";
-    const wantsHtml = acceptHeader.includes("text/html") || !acceptHeader.includes("application/json") && !acceptHeader.includes("application/*") && !acceptHeader.includes("*/*");
-    if (wantsHtml) {
-      try {
-        const templatePath = TemplateRender.getTemplatePath("index.html");
-        const html = TemplateRender.render(templatePath, {
-          companyName: serviceName,
-          requestId: context.requestId,
-          method: request.method,
-          path: request.path,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          templateVersion,
-          runtime: "Node.js"
-        });
-        return {
-          statusCode: 200,
-          headers: {
-            "Content-Type": "text/html; charset=utf-8"
-          },
-          body: html
+// ../runtime-shared/dist/conversation/message-builder.js
+var ConversationMessageBuilder = class {
+  config;
+  appId;
+  channel;
+  identity;
+  conversationId;
+  messageText;
+  /**
+   * Create a new builder with configuration
+   */
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Pre-fill builder from an inbound message (for replies)
+   */
+  fromInbound(inbound) {
+    this.appId = inbound.app_id;
+    this.channel = inbound.message?.channel_identity?.channel;
+    this.identity = inbound.message?.channel_identity?.identity;
+    this.conversationId = inbound.message?.conversation_id;
+    return this;
+  }
+  /**
+   * Set the app ID (defaults to CONVERSATION_APP_ID from config)
+   */
+  setAppId(appId) {
+    this.appId = appId;
+    return this;
+  }
+  /**
+   * Set the recipient channel and identity
+   *
+   * @param channel - Channel name (SMS, WHATSAPP, MESSENGER, etc.)
+   * @param identity - Channel-specific identity (phone number, PSID, etc.)
+   */
+  to(channel, identity) {
+    this.channel = channel;
+    this.identity = identity;
+    return this;
+  }
+  /**
+   * Set the conversation ID (for non-DISPATCH mode apps)
+   */
+  setConversationId(conversationId) {
+    this.conversationId = conversationId;
+    return this;
+  }
+  /**
+   * Set a text message
+   */
+  text(text) {
+    this.messageText = text;
+    return this;
+  }
+  /**
+   * Build the SendMessageRequest.
+   * Automatically sets SMS_SENDER from config if sending to SMS channel.
+   *
+   * @returns A SendMessageRequest ready to send via context.conversation.messages.send()
+   */
+  build() {
+    const appId = this.appId || this.config.CONVERSATION_APP_ID;
+    if (!appId) {
+      throw new Error("AppId required - use setAppId() or set CONVERSATION_APP_ID in config");
+    }
+    if (!this.channel || !this.identity) {
+      throw new Error("Recipient required - use to() or fromInbound()");
+    }
+    if (!this.messageText) {
+      throw new Error("Message required - use text()");
+    }
+    const request = {
+      app_id: appId,
+      message: {
+        text_message: {
+          text: this.messageText
+        }
+      },
+      recipient: {
+        identified_by: {
+          channel_identities: [
+            {
+              channel: this.channel,
+              identity: this.identity
+            }
+          ]
+        }
+      }
+    };
+    if (this.channel.toUpperCase() === "SMS") {
+      const smsSender = this.config.FROM_NUMBER;
+      if (smsSender) {
+        request.channel_properties = {
+          SMS_SENDER: smsSender
         };
-      } catch (error) {
-        console.warn("HTML template not found, returning JSON");
       }
     }
-    return {
-      statusCode: 200,
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: {
-        message: `Welcome to ${serviceName}`,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        requestId: context.requestId,
-        method: request.method,
-        path: request.path,
-        availableEndpoints,
-        usage: {
-          html: "Set Accept: text/html header or visit in browser",
-          json: "Set Accept: application/json header or use API client"
+    return request;
+  }
+};
+function createMessageBuilder(config = {}) {
+  return new ConversationMessageBuilder(config);
+}
+
+// ../runtime-shared/dist/conversation/message-helpers.js
+function textReply(inbound, text, smsSender) {
+  const channelIdentity = inbound.message?.channel_identity;
+  if (!channelIdentity) {
+    throw new Error("Inbound message has no channel identity");
+  }
+  const channel = channelIdentity.channel;
+  const identity = channelIdentity.identity;
+  if (!channel || !identity) {
+    throw new Error("Inbound message has no channel or identity");
+  }
+  return createChannelMessage(inbound.app_id, channel, identity, text, smsSender);
+}
+function createSms(appId, phoneNumber, text, smsSender) {
+  return createChannelMessage(appId, "SMS", phoneNumber, text, smsSender);
+}
+function createWhatsApp(appId, phoneNumber, text) {
+  return createChannelMessage(appId, "WHATSAPP", phoneNumber, text);
+}
+function createMessenger(appId, psid, text) {
+  return createChannelMessage(appId, "MESSENGER", psid, text);
+}
+function createChannelMessage(appId, channel, identity, text, smsSender) {
+  if (!appId)
+    throw new Error("appId is required");
+  if (!channel)
+    throw new Error("channel is required");
+  if (!identity)
+    throw new Error("identity is required");
+  if (!text)
+    throw new Error("text is required");
+  const request = {
+    app_id: appId,
+    message: {
+      text_message: {
+        text
+      }
+    },
+    recipient: {
+      identified_by: {
+        channel_identities: [
+          {
+            channel,
+            identity
+          }
+        ]
+      }
+    }
+  };
+  if (channel.toUpperCase() === "SMS" && smsSender) {
+    request.channel_properties = {
+      SMS_SENDER: smsSender
+    };
+  }
+  return request;
+}
+var ConversationMessage = {
+  textReply,
+  createSms,
+  createWhatsApp,
+  createMessenger,
+  createChannelMessage
+};
+
+// ../runtime-shared/dist/conversation/controller.js
+var ConversationController = class {
+  conversation;
+  config;
+  constructor(conversation, config = {}) {
+    this.conversation = conversation;
+    this.config = config;
+  }
+  /**
+   * MESSAGE_INBOUND - Called when a user sends a message.
+   * Override this to handle incoming messages from users.
+   */
+  async handleMessageInbound(event) {
+  }
+  /**
+   * MESSAGE_DELIVERY - Called when message delivery status updates.
+   * Override this to track delivery receipts.
+   */
+  async handleMessageDelivery(event) {
+  }
+  /**
+   * EVENT_INBOUND - Called for events like composing indicators.
+   * Override this to handle typing indicators, read receipts, etc.
+   */
+  async handleEventInbound(event) {
+  }
+  /**
+   * CONVERSATION_START - Called when a conversation begins.
+   * Override this to handle conversation initialization.
+   */
+  async handleConversationStart(event) {
+  }
+  /**
+   * CONVERSATION_STOP - Called when a conversation ends.
+   * Override this to handle conversation cleanup.
+   */
+  async handleConversationStop(event) {
+  }
+  /**
+   * Gets the sender number from configuration (FROM_NUMBER).
+   * Used for setting SMS_SENDER channel property when sending to SMS channel.
+   */
+  get fromNumber() {
+    return this.config.FROM_NUMBER;
+  }
+  /**
+   * Create a text reply to an inbound message.
+   * Automatically sets SMS_SENDER from FROM_NUMBER config.
+   */
+  reply(inbound, text) {
+    return textReply(inbound, text, this.fromNumber);
+  }
+  /**
+   * Create a ConversationMessageBuilder for building messages with full control.
+   */
+  createMessage() {
+    return new ConversationMessageBuilder(this.config);
+  }
+  /**
+   * Create a ConversationMessageBuilder pre-filled from an inbound message.
+   */
+  createReply(inbound) {
+    return new ConversationMessageBuilder(this.config).fromInbound(inbound);
+  }
+  /**
+   * Express route handler for the webhook endpoint.
+   * Mount at: POST /conversation
+   *
+   * Routes to appropriate handler based on event type.
+   * Uses manual JSON parsing as workaround for SDK issues with extra fields.
+   */
+  getWebhookHandler() {
+    return async (req, res) => {
+      try {
+        const body = req.body;
+        const verbose = this.config.VERBOSE === "true";
+        if (!body) {
+          res.status(400).json({ error: "Empty request body" });
+          return;
+        }
+        if (!this.conversation) {
+          console.error("[Conversation] Client not configured");
+          res.status(500).json({ error: "Conversation API not configured" });
+          return;
         }
+        if (body.message?.direction === "TO_APP" && body.message?.contact_message) {
+          if (verbose) {
+            console.log("[Conversation] MESSAGE_INBOUND event detected");
+          }
+          await this.handleMessageInbound(body);
+          res.status(200).send("OK");
+          return;
+        }
+        if (body.message_delivery_report) {
+          if (verbose) {
+            console.log("[Conversation] MESSAGE_DELIVERY event detected");
+          }
+          await this.handleMessageDelivery(body);
+          res.status(200).send("OK");
+          return;
+        }
+        if (body.event?.contact_event) {
+          if (verbose) {
+            console.log("[Conversation] EVENT_INBOUND event detected");
+          }
+          await this.handleEventInbound(body);
+          res.status(200).send("OK");
+          return;
+        }
+        if (body.conversation_event) {
+          const eventType = body.conversation_event.type;
+          if (eventType === "CONVERSATION_START") {
+            if (verbose) {
+              console.log("[Conversation] CONVERSATION_START event detected");
+            }
+            await this.handleConversationStart(body);
+          } else if (eventType === "CONVERSATION_STOP") {
+            if (verbose) {
+              console.log("[Conversation] CONVERSATION_STOP event detected");
+            }
+            await this.handleConversationStop(body);
+          }
+          res.status(200).send("OK");
+          return;
+        }
+        if (verbose) {
+          console.log("[Conversation] Unknown event type, ignoring");
+        }
+        res.status(200).json({ status: "ignored", reason: "unknown_event_type" });
+      } catch (error) {
+        console.error("[Conversation] Error processing webhook:", error);
+        res.status(500).json({ error: "Internal server error" });
       }
     };
   }
 };
 
+// ../runtime-shared/dist/conversation/extensions.js
+function getText(event) {
+  return event.message?.contact_message?.text_message?.text;
+}
+function getMedia(event) {
+  return event.message?.contact_message?.media_message;
+}
+function getPostbackData(event) {
+  return event.message?.contact_message?.choice_response_message?.postback_data;
+}
+function getContactId(event) {
+  return event.message?.contact_id;
+}
+function getConversationId(event) {
+  return event.message?.conversation_id;
+}
+function getChannel(event) {
+  return event.message?.channel_identity?.channel;
+}
+function getIdentity(event) {
+  return event.message?.channel_identity?.identity;
+}
+function getTo(event) {
+  return event.message?.sender_id;
+}
+function getLocation(event) {
+  return event.message?.contact_message?.location_message;
+}
+function isTextMessage(event) {
+  return event.message?.contact_message?.text_message !== void 0;
+}
+function isMediaMessage(event) {
+  return event.message?.contact_message?.media_message !== void 0;
+}
+function isPostback(event) {
+  return event.message?.contact_message?.choice_response_message !== void 0;
+}
+function createMessageHelper(event) {
+  return {
+    getText: () => getText(event),
+    getMedia: () => getMedia(event),
+    getPostbackData: () => getPostbackData(event),
+    getContactId: () => getContactId(event),
+    getConversationId: () => getConversationId(event),
+    getChannel: () => getChannel(event),
+    getIdentity: () => getIdentity(event),
+    getTo: () => getTo(event),
+    getLocation: () => getLocation(event),
+    isTextMessage: () => isTextMessage(event),
+    isMediaMessage: () => isMediaMessage(event),
+    isPostback: () => isPostback(event)
+  };
+}
+
+// ../runtime-shared/dist/voice/helpers.js
+var COUNTRY_CODES = {
+  "+1": { code: "US", format: (n) => `(${n.slice(0, 3)}) ${n.slice(3, 6)}-${n.slice(6)}` },
+  "+44": { code: "GB", format: (n) => `0${n.slice(0, 4)} ${n.slice(4)}` },
+  "+46": {
+    code: "SE",
+    format: (n) => `0${n.slice(0, 2)}-${n.slice(2, 5)} ${n.slice(5, 7)} ${n.slice(7)}`
+  },
+  "+49": { code: "DE", format: (n) => `0${n.slice(0, 3)} ${n.slice(3)}` },
+  "+33": {
+    code: "FR",
+    format: (n) => `0${n.slice(0, 1)} ${n.slice(1, 3)} ${n.slice(3, 5)} ${n.slice(5, 7)} ${n.slice(7)}`
+  },
+  "+61": { code: "AU", format: (n) => `0${n.slice(0, 1)} ${n.slice(1, 5)} ${n.slice(5)}` }
+};
+function toLocalPhoneNumber(phoneNumber, defaultRegion = "US") {
+  if (!phoneNumber || !phoneNumber.startsWith("+")) {
+    return phoneNumber;
+  }
+  const sortedCodes = Object.keys(COUNTRY_CODES).sort((a, b) => b.length - a.length);
+  for (const prefix of sortedCodes) {
+    if (phoneNumber.startsWith(prefix)) {
+      const national = phoneNumber.slice(prefix.length);
+      try {
+        return COUNTRY_CODES[prefix].format(national);
+      } catch {
+        return phoneNumber;
+      }
+    }
+  }
+  return phoneNumber.slice(1);
+}
+function formatPhoneNumber(phoneNumber) {
+  const cleaned = phoneNumber.replace(/[^\d+]/g, "");
+  if (cleaned.startsWith("+")) {
+    return toLocalPhoneNumber(cleaned);
+  }
+  if (cleaned.length === 10) {
+    return `(${cleaned.slice(0, 3)}) ${cleaned.slice(3, 6)}-${cleaned.slice(6)}`;
+  }
+  return phoneNumber;
+}
+var VoiceErrorHelper = {
+  /**
+   * Create a standard error response that plays a message and hangs up
+   *
+   * @param message - Error message to speak
+   * @param locale - Language locale (default: "en-US")
+   * @returns SVAML response object
+   */
+  createErrorResponse(message, locale = "en-US") {
+    return new IceSvamlBuilder().say(message, locale).hangup().build();
+  },
+  /**
+   * Create a service unavailable response
+   *
+   * @param locale - Language locale (default: "en-US")
+   * @returns SVAML response object
+   */
+  serviceUnavailable(locale = "en-US") {
+    return this.createErrorResponse("We're sorry, our service is temporarily unavailable. Please try again later.", locale);
+  },
+  /**
+   * Create an invalid input response for PIE handlers
+   *
+   * @param locale - Language locale (default: "en-US")
+   * @returns SVAML response object
+   */
+  invalidInput(locale = "en-US") {
+    return new PieSvamlBuilder().say("Invalid selection. Please try again.", locale).continue().build();
+  },
+  /**
+   * Create a timeout response for PIE handlers
+   *
+   * @param locale - Language locale (default: "en-US")
+   * @returns SVAML response object
+   */
+  timeout(locale = "en-US") {
+    return new PieSvamlBuilder().say("We did not receive a response. Please try again.", locale).continue().build();
+  },
+  /**
+   * Create a goodbye response that thanks the caller and hangs up
+   *
+   * @param locale - Language locale (default: "en-US")
+   * @returns SVAML response object
+   */
+  goodbye(locale = "en-US") {
+    return new IceSvamlBuilder().say("Thank you for calling. Goodbye!", locale).hangup().build();
+  }
+};
+function formatDuration(seconds) {
+  if (seconds < 60) {
+    return `${Math.round(seconds)}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = Math.round(seconds % 60);
+  if (remainingSeconds === 0) {
+    return `${minutes}m`;
+  }
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function extractCallerNumber(cli) {
+  if (!cli)
+    return void 0;
+  return cli.replace(/[^\d+]/g, "");
+}
+
+// ../runtime-shared/dist/utils/templateRender.js
+import fs from "fs";
+import path from "path";
+
+// ../runtime-shared/dist/utils/versionExtractor.js
+import fs2 from "fs";
+import path2 from "path";
+
 // ../runtime-shared/dist/utils/functionLoader.js
 import path3 from "path";
 
@@ -1658,7 +2456,7 @@ async function configureConversationWebhooks(tunnelUrl, config) {
       console.log("\u{1F4A1} Conversation API not fully configured - skipping webhook setup");
       return;
     }
-    const webhookUrl = `${tunnelUrl}/webhook`;
+    const webhookUrl = `${tunnelUrl}/webhook/conversation`;
     console.log(`\u{1F4AC} Conversation webhook URL: ${webhookUrl}`);
     const sinchClient = new SinchClient2({
       projectId,
@@ -2204,7 +3002,14 @@ var SecretsLoader = class {
 var secretsLoader = new SecretsLoader();
 export {
   AceSvamlBuilder,
-  DefaultEndpointHandler,
+  AgentProvider,
+  ConversationController,
+  ConversationMessage,
+  ConversationMessageBuilder,
+  ElevenLabsAutoConfigurator,
+  ElevenLabsClient,
+  ElevenLabsController,
+  ElevenLabsState,
   IceSvamlBuilder,
   LocalCache,
   MenuBuilder,
@@ -2212,36 +3017,59 @@ export {
   NOTIFICATION_EVENTS,
   PieSvamlBuilder,
   SecretsLoader,
-  TemplateRender,
   TunnelClient,
   UniversalConfig,
   VOICE_CALLBACKS,
-  VersionExtractor,
+  VoiceErrorHelper,
   buildBaseContext,
   toCamelCase as convertToCamelCase,
   createAceBuilder,
   createApp,
   createCacheClient,
+  createChannelMessage,
   createConfig,
+  createElevenLabsClient,
   createErrorResponse,
   createIceBuilder,
   createLenientJsonParser as createJsonParser,
   createJsonResponse,
   createLenientJsonParser,
   createMenu,
+  createMessageBuilder,
+  createMessageHelper,
+  createMessenger,
   createPieBuilder,
   createResponse,
   createSimpleMenu,
+  createSms,
   createUniversalConfig,
+  createWhatsApp,
+  extractCallerNumber,
   extractFunctionName,
   formatCustomResponse,
+  formatDuration,
+  formatPhoneNumber,
   formatSvamlResponse,
   generateRequestId,
+  getChannel,
+  getContactId,
+  getConversationId,
+  getFaviconSvg,
+  getIdentity,
+  getLandingPageHtml,
+  getLocation,
+  getMedia,
+  getPostbackData,
   getSinchClients,
+  getText,
+  getTo,
   getTunnelClient,
   handleCustomEndpoint,
   handleVoiceCallback,
+  isMediaMessage,
   isNotificationEvent,
+  isPostback,
+  isTextMessage,
   isVoiceCallback,
   parseJson,
   parseJson as parseJsonLenient,
@@ -2250,9 +3078,12 @@ export {
   setupJsonParsing as setupJsonMiddleware,
   setupJsonParsing,
   setupRequestHandler,
+  textReply,
   toCamelCase,
+  toLocalPhoneNumber,
   transformKeys,
   transformKeys as transformKeysToCamelCase,
+  tryAutoConfigureAsync,
   validateVoiceRequest
 };
 //# sourceMappingURL=index.js.map