@sinch/functions-runtime 0.1.0-beta.28 → 0.2.2-beta

package/dist/index.js

@@ -1,3 +1,52 @@
+// ../runtime-shared/dist/ai/connect-agent.js
+var AgentProvider;
+(function(AgentProvider2) {
+  AgentProvider2["ElevenLabs"] = "elevenlabs";
+})(AgentProvider || (AgentProvider = {}));
+var AgentSipHelper = class {
+  /**
+   * Build a SIP URI for connecting to an ElevenLabs agent
+   */
+  static buildElevenLabsSipUri(agentId, options) {
+    const baseUri = `sip:${agentId}@sip.elevenlabs.io`;
+    if (options?.customHeaders && Object.keys(options.customHeaders).length > 0) {
+      const headers = Object.entries(options.customHeaders).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+      return `${baseUri};${headers}`;
+    }
+    return baseUri;
+  }
+  /**
+   * Build a SIP URI for the given provider and agent
+   */
+  static buildSipUri(provider, agentId, options) {
+    switch (provider) {
+      case AgentProvider.ElevenLabs:
+        return this.buildElevenLabsSipUri(agentId, options);
+      default:
+        throw new Error(`Unsupported agent provider: ${provider}`);
+    }
+  }
+};
+function createConnectAgentAction(provider, agentId, options) {
+  const sipUri = AgentSipHelper.buildSipUri(provider, agentId, options);
+  const action = {
+    name: "connectSip",
+    destination: {
+      endpoint: sipUri
+    }
+  };
+  if (options?.cli) {
+    action.cli = options.cli;
+  }
+  if (options?.maxDuration !== void 0) {
+    action.maxDuration = options.maxDuration;
+  }
+  if (options?.suppressCallbacks !== void 0) {
+    action.suppressCallbacks = options.suppressCallbacks;
+  }
+  return action;
+}
+
 // ../runtime-shared/dist/builders/svaml.js
 var BaseSvamlBuilder = class {
   instructions = [];
@@ -201,6 +250,25 @@ var IceSvamlBuilder = class extends BaseSvamlBuilder {
     };
     return this;
   }
+  /**
+   * Connect to an AI voice agent
+   *
+   * @param provider - The AI agent provider (e.g., AgentProvider.ElevenLabs)
+   * @param agentId - The agent ID to connect to
+   * @param options - Connection options
+   *
+   * @example
+   * ```typescript
+   * return new IceSvamlBuilder()
+   *   .say('Connecting you to our AI assistant.')
+   *   .connectAgent(AgentProvider.ElevenLabs, 'agent_123')
+   *   .build();
+   * ```
+   */
+  connectAgent(provider, agentId, options) {
+    this.action = createConnectAgentAction(provider, agentId, options);
+    return this;
+  }
 };
 var AceSvamlBuilder = class extends BaseSvamlBuilder {
 };
@@ -250,6 +318,28 @@ var PieSvamlBuilder = class extends BaseSvamlBuilder {
     };
     return this;
   }
+  /**
+   * Connect to an AI voice agent
+   *
+   * @param provider - The AI agent provider (e.g., AgentProvider.ElevenLabs)
+   * @param agentId - The agent ID to connect to
+   * @param options - Connection options
+   *
+   * @example
+   * ```typescript
+   * // Transfer to AI agent based on menu selection
+   * if (event.menuResult?.value === 'ai') {
+   *   return new PieSvamlBuilder()
+   *     .say('Connecting you to our AI assistant.')
+   *     .connectAgent(AgentProvider.ElevenLabs, 'agent_123')
+   *     .build();
+   * }
+   * ```
+   */
+  connectAgent(provider, agentId, options) {
+    this.action = createConnectAgentAction(provider, agentId, options);
+    return this;
+  }
 };
 function createIceBuilder() {
   return new IceSvamlBuilder();
@@ -1161,30 +1251,9 @@ function setupRequestHandler(app, options = {}) {
 }
 
 // ../runtime-shared/dist/sinch/index.js
-var SinchClient = null;
-var validateAuthenticationHeader = null;
-async function loadSinchSdk() {
-  if (SinchClient !== null) {
-    return SinchClient !== false;
-  }
-  try {
-    const sdk = await import("@sinch/sdk-core");
-    SinchClient = sdk.SinchClient;
-    validateAuthenticationHeader = sdk.validateAuthenticationHeader;
-    return true;
-  } catch {
-    SinchClient = false;
-    validateAuthenticationHeader = false;
-    console.debug("[SINCH] SDK not available - Sinch API features disabled");
-    return false;
-  }
-}
-async function createSinchClients() {
+import { SinchClient, validateAuthenticationHeader } from "@sinch/sdk-core";
+function createSinchClients() {
   const clients = {};
-  const sdkAvailable = await loadSinchSdk();
-  if (!sdkAvailable) {
-    return clients;
-  }
   const hasCredentials = process.env.PROJECT_ID && process.env.PROJECT_ID_API_KEY && process.env.PROJECT_ID_API_SECRET;
   if (!hasCredentials) {
     return clients;
@@ -1193,8 +1262,7 @@ async function createSinchClients() {
     const sinchClient = new SinchClient({
       projectId: process.env.PROJECT_ID,
       keyId: process.env.PROJECT_ID_API_KEY,
-      keySecret: process.env.PROJECT_ID_API_SECRET,
-      region: process.env.SINCH_REGION || "us"
+      keySecret: process.env.PROJECT_ID_API_SECRET
     });
     if (process.env.CONVERSATION_APP_ID) {
       clients.conversation = sinchClient.conversation;
@@ -1206,8 +1274,7 @@ async function createSinchClients() {
         keyId: process.env.PROJECT_ID_API_KEY,
         keySecret: process.env.PROJECT_ID_API_SECRET,
         applicationKey: process.env.VOICE_APPLICATION_KEY,
-        applicationSecret: process.env.VOICE_APPLICATION_SECRET,
-        region: process.env.SINCH_REGION || "us"
+        applicationSecret: process.env.VOICE_APPLICATION_SECRET
       });
       clients.voice = voiceClient.voice;
       console.log("[SINCH] Voice API initialized with application credentials");
@@ -1224,7 +1291,7 @@ async function createSinchClients() {
     console.error("[SINCH] Failed to initialize Sinch clients:", error.message);
     return {};
   }
-  if (process.env.VOICE_APPLICATION_KEY && process.env.VOICE_APPLICATION_SECRET && validateAuthenticationHeader) {
+  if (process.env.VOICE_APPLICATION_KEY && process.env.VOICE_APPLICATION_SECRET) {
     clients.validateWebhookSignature = (requestData) => {
       console.log("[SINCH] Validating Voice webhook signature");
       try {
@@ -1240,24 +1307,72 @@ async function createSinchClients() {
   return clients;
 }
 var cachedClients = null;
-var initPromise = null;
 function getSinchClients() {
-  if (cachedClients) {
-    return cachedClients;
+  if (!cachedClients) {
+    cachedClients = createSinchClients();
   }
-  if (!initPromise) {
-    initPromise = createSinchClients().then((clients) => {
-      cachedClients = clients;
-      return clients;
-    });
-  }
-  return {};
+  return cachedClients;
 }
 function resetSinchClients() {
   cachedClients = null;
-  initPromise = null;
 }
 
+// ../runtime-shared/dist/ai/elevenlabs/state.js
+var ElevenLabsStateManager = class {
+  state = {
+    isConfigured: false
+  };
+  /**
+   * Get the current state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Check if ElevenLabs is configured
+   */
+  isConfigured() {
+    return this.state.isConfigured;
+  }
+  /**
+   * Update state with auto-configuration results
+   */
+  setConfigured(data) {
+    this.state = {
+      ...data,
+      isConfigured: true,
+      configuredAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Clear the configuration state
+   */
+  clear() {
+    this.state = {
+      isConfigured: false
+    };
+  }
+  /**
+   * Get the phone number ID for making calls
+   */
+  getPhoneNumberId() {
+    return this.state.phoneNumberId;
+  }
+  /**
+   * Get the SIP address for connecting to the agent
+   */
+  getSipAddress() {
+    return this.state.sipAddress;
+  }
+  /**
+   * Get the configured agent ID
+   */
+  getAgentId() {
+    return this.state.agentId;
+  }
+};
+var ElevenLabsState = new ElevenLabsStateManager();
+
 // ../runtime-shared/dist/utils/templateRender.js
 import fs from "fs";
 import path from "path";
@@ -1500,53 +1615,158 @@ function createCacheClient(_projectId, _functionName) {
 // src/tunnel/index.ts
 import WebSocket from "ws";
 import axios from "axios";
+
+// src/tunnel/webhook-config.ts
+import { SinchClient as SinchClient2 } from "@sinch/sdk-core";
+async function configureConversationWebhooks(tunnelUrl, config) {
+  try {
+    const conversationAppId = process.env.CONVERSATION_APP_ID;
+    const projectId = process.env.PROJECT_ID;
+    const keyId = process.env.KEY_ID;
+    const keySecret = process.env.KEY_SECRET;
+    if (!conversationAppId || !projectId || !keyId || !keySecret) {
+      console.log("\u{1F4A1} Conversation API not fully configured - skipping webhook setup");
+      return;
+    }
+    const webhookUrl = `${tunnelUrl}/conversation`;
+    console.log(`\u{1F4AC} Conversation webhook URL: ${webhookUrl}`);
+    const sinchClient = new SinchClient2({
+      projectId,
+      keyId,
+      keySecret
+    });
+    const webhooksResult = await sinchClient.conversation.webhooks.list({ app_id: conversationAppId });
+    const existingWebhooks = webhooksResult.webhooks || [];
+    const tunnelWebhooks = existingWebhooks.filter(
+      (w) => w.target?.includes("/api/ingress/")
+    );
+    for (const staleWebhook of tunnelWebhooks) {
+      try {
+        await sinchClient.conversation.webhooks.delete({ webhook_id: staleWebhook.id });
+        console.log(`\u{1F9F9} Cleaned up stale tunnel webhook: ${staleWebhook.id}`);
+      } catch (err) {
+      }
+    }
+    const createResult = await sinchClient.conversation.webhooks.create({
+      webhookCreateRequestBody: {
+        app_id: conversationAppId,
+        target: webhookUrl,
+        target_type: "HTTP",
+        triggers: ["MESSAGE_INBOUND"]
+      }
+    });
+    config.conversationWebhookId = createResult.id;
+    console.log(`\u2705 Created Conversation webhook: ${webhookUrl}`);
+    console.log("\u{1F4AC} Send a message to your Conversation app to test!");
+  } catch (error) {
+    console.log("\u26A0\uFE0F Could not configure Conversation webhooks:", error.message);
+  }
+}
+async function cleanupConversationWebhook(config) {
+  if (!config.conversationWebhookId) return;
+  try {
+    const conversationAppId = process.env.CONVERSATION_APP_ID;
+    const projectId = process.env.PROJECT_ID;
+    const keyId = process.env.KEY_ID;
+    const keySecret = process.env.KEY_SECRET;
+    if (!conversationAppId || !projectId || !keyId || !keySecret) return;
+    const sinchClient = new SinchClient2({
+      projectId,
+      keyId,
+      keySecret
+    });
+    await sinchClient.conversation.webhooks.delete({ webhook_id: config.conversationWebhookId });
+    console.log("\u{1F9F9} Cleaned up tunnel webhook");
+    config.conversationWebhookId = void 0;
+  } catch (error) {
+  }
+}
+async function configureElevenLabs() {
+  try {
+    const agentId = process.env.ELEVENLABS_AGENT_ID;
+    const apiKey = process.env.ELEVENLABS_API_KEY;
+    if (!agentId || !apiKey) {
+      console.log("\u{1F4A1} ElevenLabs not fully configured - skipping auto-configuration");
+      return;
+    }
+    void apiKey;
+    console.log("\u{1F916} ElevenLabs auto-configuration enabled");
+    console.log(`   Agent ID: ${agentId}`);
+  } catch (error) {
+    console.log("\u26A0\uFE0F Could not configure ElevenLabs:", error.message);
+  }
+}
+
+// src/tunnel/index.ts
+var TUNNEL_GATEWAY_DEFAULT = "https://tunnel.fn.sinch.com";
 var TunnelClient = class {
   ws = null;
   tunnelUrl = null;
+  tunnelId = null;
   isConnected = false;
   reconnectAttempts = 0;
   maxReconnectAttempts = 10;
   reconnectDelay = 5e3;
   heartbeatInterval = null;
   localPort;
+  webhookConfig = {};
+  welcomeResolver = null;
   constructor(localPort = 3e3) {
     this.localPort = localPort;
   }
+  getTunnelGatewayUrl() {
+    const explicitUrl = process.env.TUNNEL_GATEWAY_URL;
+    if (explicitUrl) {
+      return explicitUrl;
+    }
+    return TUNNEL_GATEWAY_DEFAULT;
+  }
+  generateTunnelId() {
+    const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    const timestamp = Date.now();
+    let timestampPart = "";
+    let t = timestamp;
+    for (let i = 0; i < 10; i++) {
+      timestampPart = ENCODING[t % 32] + timestampPart;
+      t = Math.floor(t / 32);
+    }
+    const randomBytes = new Uint8Array(10);
+    crypto.getRandomValues(randomBytes);
+    let randomPart = "";
+    for (let i = 0; i < 10; i++) {
+      const byte = randomBytes[i];
+      randomPart += ENCODING[byte >> 3];
+      if (randomPart.length < 16) {
+        randomPart += ENCODING[(byte & 7) << 2 | (i + 1 < 10 ? randomBytes[i + 1] >> 6 : 0)];
+      }
+    }
+    randomPart = randomPart.substring(0, 16);
+    return timestampPart + randomPart;
+  }
   async connect() {
     if (process.env.SINCH_TUNNEL !== "true") {
       console.log("Tunnel is disabled (set SINCH_TUNNEL=true to enable)");
       return;
     }
-    const projectId = process.env.PROJECT_ID;
-    const apiKey = process.env.PROJECT_ID_API_KEY;
-    if (!projectId || !apiKey) {
-      console.warn("PROJECT_ID or PROJECT_ID_API_KEY not configured, tunnel cannot connect");
-      return;
-    }
-    const sessionId = `${projectId}-local-dev`;
-    const apiUrl = process.env.API_URL || "https://functions.api.sinch.com";
-    const baseUrl = new URL(apiUrl);
-    const wsUrl = new URL(baseUrl.toString());
-    wsUrl.protocol = baseUrl.protocol === "https:" ? "wss:" : "ws:";
-    wsUrl.pathname = `/api/tunnel/${projectId}/${sessionId}`;
+    const gatewayUrl = this.getTunnelGatewayUrl();
+    this.tunnelId = this.generateTunnelId();
+    const gatewayUri = new URL(gatewayUrl);
+    const wsUrl = new URL(gatewayUrl);
+    wsUrl.protocol = gatewayUri.protocol === "https:" ? "wss:" : "ws:";
+    wsUrl.pathname = "/ws";
+    wsUrl.searchParams.set("tunnel", this.tunnelId);
     const tunnelEndpoint = wsUrl.toString();
-    const tunnelUrlObj = new URL(baseUrl.toString());
-    tunnelUrlObj.pathname = `/api/ingress/${sessionId}`;
-    this.tunnelUrl = tunnelUrlObj.toString();
-    console.log("Connecting to tunnel server...");
+    console.log(`Connecting to tunnel gateway at ${tunnelEndpoint}...`);
     try {
-      this.ws = new WebSocket(tunnelEndpoint, {
-        headers: {
-          "Authorization": `Bearer ${apiKey}`
-        }
+      this.ws = new WebSocket(tunnelEndpoint);
+      const welcomePromise = new Promise((resolve, reject) => {
+        this.welcomeResolver = resolve;
+        setTimeout(() => reject(new Error("Timed out waiting for welcome message")), 1e4);
       });
-      this.ws.on("open", async () => {
+      this.ws.on("open", () => {
         this.isConnected = true;
         this.reconnectAttempts = 0;
-        console.log("\u2705 Tunnel connected successfully!");
-        console.log(`\u{1F4CD} Tunnel URL: ${this.tunnelUrl}`);
-        console.log(`\u{1F4DE} Voice webhook URL: ${this.tunnelUrl}/`);
-        await this.displayTestPhoneNumbers();
+        console.log("WebSocket connected, waiting for welcome message...");
       });
       this.ws.on("message", async (data) => {
         try {
@@ -1556,7 +1776,7 @@ var TunnelClient = class {
           console.error("Error processing tunnel message:", error);
         }
       });
-      this.ws.on("close", () => {
+      this.ws.on("close", async () => {
         this.isConnected = false;
         console.log("Tunnel connection closed");
         this.stopHeartbeat();
@@ -1565,14 +1785,23 @@ var TunnelClient = class {
       this.ws.on("error", (error) => {
         console.error("Tunnel connection error:", error.message);
       });
+      await welcomePromise;
+      if (!this.tunnelUrl) {
+        throw new Error("Did not receive tunnel URL from gateway");
+      }
+      console.log("Tunnel connected successfully!");
       this.startHeartbeat();
+      await this.configureWebhooks();
     } catch (error) {
-      console.error("Failed to establish tunnel connection:", error);
+      console.error("Failed to establish tunnel connection:", error.message);
       this.scheduleReconnect();
     }
   }
   async handleMessage(message) {
     switch (message.type) {
+      case "welcome":
+        this.handleWelcomeMessage(message);
+        break;
       case "request":
         await this.handleRequest(message);
         break;
@@ -1581,6 +1810,15 @@ var TunnelClient = class {
         break;
     }
   }
+  handleWelcomeMessage(message) {
+    this.tunnelId = message.tunnelId || null;
+    this.tunnelUrl = message.publicUrl || null;
+    console.log(`Received welcome: tunnelId=${this.tunnelId}`);
+    if (this.welcomeResolver) {
+      this.welcomeResolver(true);
+      this.welcomeResolver = null;
+    }
+  }
   async handleRequest(message) {
     console.log(`Forwarding ${message.method} request to ${message.path}`);
     try {
@@ -1597,12 +1835,23 @@ var TunnelClient = class {
         axiosConfig.data = message.body;
       }
       const response = await axios(axiosConfig);
+      const headers = {};
+      for (const [key, value] of Object.entries(response.headers)) {
+        if (value) {
+          const normalizedKey = key.toLowerCase() === "content-type" ? "Content-Type" : key.toLowerCase() === "content-length" ? "Content-Length" : key;
+          headers[normalizedKey] = String(value);
+        }
+      }
+      if (!headers["Content-Type"] && response.data) {
+        headers["Content-Type"] = "application/json";
+      }
+      const body = typeof response.data === "string" ? response.data : JSON.stringify(response.data);
       const responseMessage = {
         type: "response",
         id: message.id,
         statusCode: response.status,
-        headers: response.headers,
-        body: typeof response.data === "string" ? response.data : JSON.stringify(response.data)
+        headers,
+        body
       };
       this.ws?.send(JSON.stringify(responseMessage));
     } catch (error) {
@@ -1637,7 +1886,29 @@ var TunnelClient = class {
       this.heartbeatInterval = null;
     }
   }
-  async displayTestPhoneNumbers() {
+  /**
+   * Configure all webhooks (Voice, Conversation, ElevenLabs)
+   */
+  async configureWebhooks() {
+    const autoConfigVoice = process.env.AUTO_CONFIGURE_VOICE !== "false";
+    const autoConfigConversation = process.env.AUTO_CONFIGURE_CONVERSATION !== "false";
+    if (autoConfigVoice && process.env.VOICE_APPLICATION_KEY) {
+      await this.configureVoiceWebhooks();
+    }
+    if (autoConfigConversation && process.env.CONVERSATION_APP_ID) {
+      await configureConversationWebhooks(this.tunnelUrl, this.webhookConfig);
+    }
+    if (process.env.ELEVENLABS_AUTO_CONFIGURE === "true") {
+      await configureElevenLabs();
+    }
+  }
+  /**
+   * Cleanup webhooks on disconnect
+   */
+  async cleanupWebhooks() {
+    await cleanupConversationWebhook(this.webhookConfig);
+  }
+  async configureVoiceWebhooks() {
     try {
       const appKey = process.env.VOICE_APPLICATION_KEY;
       const appSecret = process.env.VOICE_APPLICATION_SECRET;
@@ -1659,7 +1930,7 @@ var TunnelClient = class {
             "Content-Type": "application/json"
           }
         });
-        console.log(`\u2705 Updated voice webhook URL to: ${this.tunnelUrl}`);
+        console.log("\u2705 Updated voice webhook URL");
       } catch (error) {
         console.log("\u26A0\uFE0F Could not update webhook URL:", error.message);
       }
@@ -1700,8 +1971,9 @@ var TunnelClient = class {
     console.log(`Attempting to reconnect in ${delay / 1e3} seconds...`);
     setTimeout(() => this.connect(), delay);
   }
-  disconnect() {
+  async disconnect() {
     this.stopHeartbeat();
+    await this.cleanupWebhooks();
     if (this.ws) {
       this.ws.close();
       this.ws = null;