@sinch/functions-runtime 0.3.8 → 0.4.0

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 = {
@@ -982,11 +1021,11 @@ function isVoiceCallback(functionName) {
 function isNotificationEvent(functionName) {
   return NOTIFICATION_EVENTS.includes(functionName);
 }
-function extractFunctionName(path5, body) {
+function extractFunctionName(path6, body) {
   if (body?.event && isVoiceCallback(body.event)) {
     return body.event;
   }
-  const pathname = path5.split("?")[0];
+  const pathname = path6.split("?")[0];
   const segments = pathname.split("/").filter((s) => s && s !== "*");
   if (segments.length === 1 && isVoiceCallback(segments[0])) {
     return segments[0];
@@ -1003,10 +1042,10 @@ function generateRequestId() {
   return `req_${Date.now()}_${Math.random().toString(36).substring(7)}`;
 }
 function findFunctionPath() {
-  const fs4 = requireCjs2("fs");
+  const fs5 = requireCjs2("fs");
   const distPath = nodePath.join(process.cwd(), "dist", "function.js");
   const rootPath = nodePath.join(process.cwd(), "function.js");
-  if (fs4.existsSync(distPath)) {
+  if (fs5.existsSync(distPath)) {
     return distPath;
   }
   return rootPath;
@@ -1084,6 +1123,15 @@ var noOpCache = {
   keys: async () => [],
   getMany: async () => ({})
 };
+var noOpStorage = {
+  write: async () => {
+  },
+  read: async () => Buffer.alloc(0),
+  list: async () => [],
+  exists: async () => false,
+  delete: async () => {
+  }
+};
 function buildBaseContext(req, config = {}) {
   return {
     requestId: req.headers["x-request-id"] || generateRequestId(),
@@ -1096,6 +1144,8 @@ function buildBaseContext(req, config = {}) {
       variables: config.variables
     },
     cache: noOpCache,
+    storage: noOpStorage,
+    database: "",
     assets: (filename) => {
       const filePath = nodePath.join(process.cwd(), "assets", filename);
       return nodeFs.promises.readFile(filePath, "utf-8");
@@ -1412,145 +1462,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 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");
     }
-    const directPath = path.join(searchDir, "pages", templateName);
-    if (fs.existsSync(directPath)) {
-      return directPath;
+  }
+  /**
+   * 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";
 
@@ -1651,6 +2451,69 @@ function createCacheClient(_projectId, _functionName) {
   return new LocalCache();
 }
 
+// src/storage/local.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+var LocalStorage = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir ?? path4.join(process.cwd(), "storage");
+  }
+  resolvePath(key) {
+    const sanitized = key.replace(/^\/+/, "").replace(/\.\./g, "_");
+    return path4.join(this.baseDir, sanitized);
+  }
+  async write(key, data) {
+    const filePath = this.resolvePath(key);
+    await fs3.mkdir(path4.dirname(filePath), { recursive: true });
+    await fs3.writeFile(filePath, data);
+  }
+  async read(key) {
+    const filePath = this.resolvePath(key);
+    return fs3.readFile(filePath);
+  }
+  async list(prefix) {
+    const results = [];
+    await this.walkDir(this.baseDir, "", results);
+    if (prefix) {
+      return results.filter((f) => f.startsWith(prefix));
+    }
+    return results;
+  }
+  async exists(key) {
+    const filePath = this.resolvePath(key);
+    try {
+      await fs3.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(key) {
+    const filePath = this.resolvePath(key);
+    await fs3.rm(filePath, { force: true });
+  }
+  async walkDir(dir, relative, results) {
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const rel = relative ? `${relative}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        await this.walkDir(path4.join(dir, entry.name), rel, results);
+      } else {
+        results.push(rel);
+      }
+    }
+  }
+};
+function createStorageClient(baseDir) {
+  return new LocalStorage(baseDir);
+}
+
 // src/tunnel/index.ts
 import WebSocket from "ws";
 import axios from "axios";
@@ -2042,9 +2905,242 @@ function getTunnelClient(localPort = 3e3) {
 }
 
 // src/secrets/index.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs4 from "fs";
+import path5 from "path";
 import os from "os";
+
+// src/secrets/keychain.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function b64(value) {
+  return Buffer.from(value, "utf8").toString("base64");
+}
+function psParam(name, value) {
+  return `$${name} = [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${b64(value)}'));`;
+}
+var WIN32_CRED_READ_SCRIPT = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public class CredManager {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  private struct CREDENTIAL {
+    public int Flags;
+    public int Type;
+    public IntPtr TargetName;
+    public IntPtr Comment;
+    public long LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public IntPtr TargetAlias;
+    public IntPtr UserName;
+  }
+  [DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
+  private static extern bool CredReadW(string target, int type, int flags, out IntPtr cred);
+  [DllImport("advapi32.dll")]
+  private static extern void CredFree(IntPtr cred);
+  public static string Read(string target) {
+    IntPtr credPtr;
+    if (!CredReadW(target, 1, 0, out credPtr)) return null;
+    try {
+      CREDENTIAL c = (CREDENTIAL)Marshal.PtrToStructure(credPtr, typeof(CREDENTIAL));
+      if (c.CredentialBlobSize > 0 && c.CredentialBlob != IntPtr.Zero)
+        return Marshal.PtrToStringUni(c.CredentialBlob, c.CredentialBlobSize / 2);
+      return "";
+    } finally { CredFree(credPtr); }
+  }
+}
+'@
+$r = [CredManager]::Read($target)
+if ($r -ne $null) { [Console]::Write($r) }
+else { exit 1 }
+`;
+var WIN32_CRED_WRITE_SCRIPT = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+public class CredWriter {
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
+  private struct CREDENTIAL {
+    public int Flags;
+    public int Type;
+    public string TargetName;
+    public string Comment;
+    public long LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public string TargetAlias;
+    public string UserName;
+  }
+  [DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
+  private static extern bool CredWriteW(ref CREDENTIAL cred, int flags);
+  public static bool Write(string target, string password) {
+    byte[] blob = Encoding.Unicode.GetBytes(password);
+    CREDENTIAL c = new CREDENTIAL();
+    c.Type = 1;
+    c.TargetName = target;
+    c.CredentialBlobSize = blob.Length;
+    c.CredentialBlob = Marshal.AllocHGlobal(blob.Length);
+    Marshal.Copy(blob, 0, c.CredentialBlob, blob.Length);
+    c.Persist = 2;
+    try { return CredWriteW(ref c, 0); }
+    finally { Marshal.FreeHGlobal(c.CredentialBlob); }
+  }
+}
+'@
+if (-not [CredWriter]::Write($target, $password)) { exit 1 }
+`;
+var WIN32_CRED_DELETE_SCRIPT = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public class CredDeleter {
+  [DllImport("advapi32.dll", SetLastError=true, CharSet=CharSet.Unicode)]
+  private static extern bool CredDeleteW(string target, int type, int flags);
+  public static bool Delete(string target) { return CredDeleteW(target, 1, 0); }
+}
+'@
+if (-not [CredDeleter]::Delete($target)) { exit 1 }
+`;
+function winTarget(service, account) {
+  return `${service}/${account}`;
+}
+var windowsKeychain = {
+  async getPassword(service, account) {
+    try {
+      const params = psParam("target", winTarget(service, account));
+      const { stdout } = await execFileAsync(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-Command", params + WIN32_CRED_READ_SCRIPT],
+        { timeout: 15e3, windowsHide: true }
+      );
+      return stdout;
+    } catch {
+      return null;
+    }
+  },
+  async setPassword(service, account, password) {
+    const params = psParam("target", winTarget(service, account)) + psParam("password", password);
+    await execFileAsync(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Command", params + WIN32_CRED_WRITE_SCRIPT],
+      { timeout: 15e3, windowsHide: true }
+    );
+  },
+  async deletePassword(service, account) {
+    try {
+      const params = psParam("target", winTarget(service, account));
+      await execFileAsync(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-Command", params + WIN32_CRED_DELETE_SCRIPT],
+        { timeout: 15e3, windowsHide: true }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var macKeychain = {
+  async getPassword(service, account) {
+    try {
+      const { stdout } = await execFileAsync(
+        "security",
+        ["find-generic-password", "-s", service, "-a", account, "-w"],
+        { timeout: 15e3 }
+      );
+      return stdout.trimEnd();
+    } catch {
+      return null;
+    }
+  },
+  async setPassword(service, account, password) {
+    await execFileAsync(
+      "security",
+      ["add-generic-password", "-U", "-s", service, "-a", account, "-w", password],
+      { timeout: 15e3 }
+    );
+  },
+  async deletePassword(service, account) {
+    try {
+      await execFileAsync(
+        "security",
+        ["delete-generic-password", "-s", service, "-a", account],
+        { timeout: 15e3 }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var linuxKeychain = {
+  async getPassword(service, account) {
+    try {
+      const { stdout } = await execFileAsync(
+        "secret-tool",
+        ["lookup", "service", service, "account", account],
+        { timeout: 15e3 }
+      );
+      return stdout.trimEnd();
+    } catch {
+      return null;
+    }
+  },
+  // secret-tool reads password from stdin (avoids exposing it in process args)
+  async setPassword(service, account, password) {
+    const child = spawn(
+      "secret-tool",
+      ["store", "--label", `${service}/${account}`, "service", service, "account", account],
+      { stdio: ["pipe", "pipe", "pipe"] }
+    );
+    child.stdin.write(password);
+    child.stdin.end();
+    await new Promise((resolve, reject) => {
+      child.on(
+        "close",
+        (code) => code === 0 ? resolve() : reject(new Error("secret-tool store failed"))
+      );
+      child.on("error", reject);
+    });
+  },
+  async deletePassword(service, account) {
+    try {
+      await execFileAsync(
+        "secret-tool",
+        ["clear", "service", service, "account", account],
+        { timeout: 15e3 }
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function getBackend() {
+  switch (process.platform) {
+    case "win32":
+      return windowsKeychain;
+    case "darwin":
+      return macKeychain;
+    default:
+      return linuxKeychain;
+  }
+}
+var backend = getBackend();
+async function getPassword(service, account) {
+  return backend.getPassword(service, account);
+}
+
+// src/secrets/index.ts
 var SecretsLoader = class {
   // Same service name as CLI uses
   SERVICE_NAME = "sinch-functions-cli";
@@ -2058,24 +3154,12 @@ var SecretsLoader = class {
       return false;
     }
     try {
-      let keytar;
-      try {
-        keytar = await import("keytar");
-      } catch (error) {
-        if (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND") {
-          console.debug("[Secrets] Keytar not available - secrets not loaded");
-          return false;
-        } else {
-          console.error("[Secrets] Error loading keytar:", error.message);
-        }
-        return false;
-      }
-      const envPath = path4.join(process.cwd(), ".env");
-      if (!fs3.existsSync(envPath)) {
+      const envPath = path5.join(process.cwd(), ".env");
+      if (!fs4.existsSync(envPath)) {
         console.debug("[Secrets] No .env file found, skipping keychain load");
         return false;
       }
-      const envContent = fs3.readFileSync(envPath, "utf8");
+      const envContent = fs4.readFileSync(envPath, "utf8");
       const envLines = envContent.replace(/\r\n/g, "\n").split("\n");
       const secretsToLoad = [];
       envLines.forEach((line) => {
@@ -2097,7 +3181,7 @@ var SecretsLoader = class {
       }
       let secretsLoaded = 0;
       if (secretsToLoad.includes("PROJECT_ID_API_SECRET")) {
-        const apiSecret = await keytar.getPassword(this.SERVICE_NAME, `${this.username}-keySecret`);
+        const apiSecret = await getPassword(this.SERVICE_NAME, `${this.username}-keySecret`);
         if (apiSecret) {
           process.env.PROJECT_ID_API_SECRET = apiSecret;
           console.log("\u2705 Loaded PROJECT_ID_API_SECRET from secure storage");
@@ -2107,7 +3191,7 @@ var SecretsLoader = class {
       if (secretsToLoad.includes("VOICE_APPLICATION_SECRET")) {
         const applicationKey = process.env.VOICE_APPLICATION_KEY || this.getApplicationKeyFromConfig();
         if (applicationKey) {
-          const appSecret = await keytar.getPassword(this.SERVICE_NAME, applicationKey);
+          const appSecret = await getPassword(this.SERVICE_NAME, applicationKey);
           if (appSecret) {
             process.env.VOICE_APPLICATION_SECRET = appSecret;
             console.log("\u2705 Loaded VOICE_APPLICATION_SECRET from secure storage");
@@ -2121,7 +3205,7 @@ var SecretsLoader = class {
           continue;
         }
         if (functionName) {
-          const value = await keytar.getPassword(
+          const value = await getPassword(
             this.SERVICE_NAME,
             `${functionName}-${secretName}`
           );
@@ -2149,9 +3233,9 @@ var SecretsLoader = class {
    */
   getApplicationKeyFromConfig() {
     try {
-      const sinchJsonPath = path4.join(process.cwd(), "sinch.json");
-      if (fs3.existsSync(sinchJsonPath)) {
-        const sinchConfig = JSON.parse(fs3.readFileSync(sinchJsonPath, "utf8"));
+      const sinchJsonPath = path5.join(process.cwd(), "sinch.json");
+      if (fs4.existsSync(sinchJsonPath)) {
+        const sinchConfig = JSON.parse(fs4.readFileSync(sinchJsonPath, "utf8"));
         return sinchConfig.voiceAppId || sinchConfig.applicationKey || null;
       }
     } catch (error) {
@@ -2164,9 +3248,9 @@ var SecretsLoader = class {
    */
   getFunctionNameFromConfig() {
     try {
-      const sinchJsonPath = path4.join(process.cwd(), "sinch.json");
-      if (fs3.existsSync(sinchJsonPath)) {
-        const sinchConfig = JSON.parse(fs3.readFileSync(sinchJsonPath, "utf8"));
+      const sinchJsonPath = path5.join(process.cwd(), "sinch.json");
+      if (fs4.existsSync(sinchJsonPath)) {
+        const sinchConfig = JSON.parse(fs4.readFileSync(sinchJsonPath, "utf8"));
         return sinchConfig.name || null;
       }
     } catch (error) {
@@ -2180,14 +3264,13 @@ var SecretsLoader = class {
   async loadCustomSecrets(secretNames = []) {
     const secrets = {};
     try {
-      const keytar = await import("keytar");
       const functionName = this.getFunctionNameFromConfig();
       if (!functionName) {
         console.debug("[Secrets] Could not determine function name for custom secrets");
         return secrets;
       }
       for (const secretName of secretNames) {
-        const value = await keytar.getPassword(this.SERVICE_NAME, `${functionName}-${secretName}`);
+        const value = await getPassword(this.SERVICE_NAME, `${functionName}-${secretName}`);
         if (value) {
           secrets[secretName] = value;
           process.env[secretName] = value;
@@ -2199,58 +3282,88 @@ var SecretsLoader = class {
     return secrets;
   }
   /**
-   * Check if keytar is available
+   * Check if the native keychain is available.
+   * Always true — no native npm deps required. The underlying OS tool
+   * (secret-tool, security, CredManager) may still be absent, in which
+   * case getPassword() silently returns null per credential.
    */
   async isAvailable() {
-    try {
-      await import("keytar");
-      return true;
-    } catch {
-      return false;
-    }
+    return true;
   }
 };
 var secretsLoader = new SecretsLoader();
 export {
   AceSvamlBuilder,
-  DefaultEndpointHandler,
+  AgentProvider,
+  ConversationController,
+  ConversationMessage,
+  ConversationMessageBuilder,
+  ElevenLabsAutoConfigurator,
+  ElevenLabsClient,
+  ElevenLabsController,
+  ElevenLabsState,
   IceSvamlBuilder,
   LocalCache,
+  LocalStorage,
   MenuBuilder,
   MenuTemplates,
   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,
+  createStorageClient,
   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,
@@ -2259,9 +3372,12 @@ export {
   setupJsonParsing as setupJsonMiddleware,
   setupJsonParsing,
   setupRequestHandler,
+  textReply,
   toCamelCase,
+  toLocalPhoneNumber,
   transformKeys,
   transformKeys as transformKeysToCamelCase,
+  tryAutoConfigureAsync,
   validateVoiceRequest
 };
 //# sourceMappingURL=index.js.map