getpatter 0.4.2 → 0.4.4

package/dist/index.mjs

@@ -39,7 +39,7 @@ import {
   resample16kTo8k,
   resample24kTo16k,
   resample8kTo16k
-} from "./chunk-35EVXMGB.mjs";
+} from "./chunk-O3RQG3NL.mjs";
 import {
   getLogger,
   setLogger
@@ -191,13 +191,21 @@ var STTConfigImpl = class {
   provider;
   apiKey;
   language;
-  constructor(provider, apiKey, language = "en") {
+  options;
+  constructor(provider, apiKey, language = "en", options) {
     this.provider = provider;
     this.apiKey = apiKey;
     this.language = language;
+    if (options) this.options = options;
   }
   toDict() {
-    return { provider: this.provider, api_key: this.apiKey, language: this.language };
+    const out = {
+      provider: this.provider,
+      api_key: this.apiKey,
+      language: this.language
+    };
+    if (this.options) out.options = { ...this.options };
+    return out;
   }
 };
 var TTSConfigImpl = class {
@@ -214,7 +222,15 @@ var TTSConfigImpl = class {
   }
 };
 function deepgram(opts) {
-  return new STTConfigImpl("deepgram", opts.apiKey, opts.language ?? "en");
+  const options = {
+    model: opts.model ?? "nova-3",
+    endpointing_ms: opts.endpointingMs ?? 150,
+    utterance_end_ms: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
+    smart_format: opts.smartFormat ?? true,
+    interim_results: opts.interimResults ?? true
+  };
+  if (opts.vadEvents !== void 0) options.vad_events = opts.vadEvents;
+  return new STTConfigImpl("deepgram", opts.apiKey, opts.language ?? "en", options);
 }
 function whisper(opts) {
   return new STTConfigImpl("whisper", opts.apiKey, opts.language ?? "en");
@@ -225,10 +241,41 @@ function elevenlabs(opts) {
 function openaiTts(opts) {
   return new TTSConfigImpl("openai", opts.apiKey, opts.voice ?? "alloy");
 }
+function cartesia(opts) {
+  return new TTSConfigImpl(
+    "cartesia",
+    opts.apiKey,
+    opts.voice ?? "f786b574-daa5-4673-aa0c-cbe3e8534c02"
+  );
+}
+function rime(opts) {
+  return new TTSConfigImpl("rime", opts.apiKey, opts.voice ?? "astra");
+}
+function lmnt(opts) {
+  return new TTSConfigImpl("lmnt", opts.apiKey, opts.voice ?? "leah");
+}
 
 // src/client.ts
 var DEFAULT_BACKEND_URL2 = "wss://api.getpatter.com";
 var DEFAULT_REST_URL = "https://api.getpatter.com";
+function sttConfigToDict(cfg) {
+  const out = {
+    provider: cfg.provider,
+    api_key: cfg.apiKey,
+    language: cfg.language
+  };
+  if (cfg.options) out.options = { ...cfg.options };
+  return out;
+}
+function ttsConfigToDict(cfg) {
+  const out = {
+    provider: cfg.provider,
+    api_key: cfg.apiKey,
+    voice: cfg.voice
+  };
+  if (cfg.options) out.options = { ...cfg.options };
+  return out;
+}
 var Patter = class {
   apiKey;
   backendUrl;
@@ -239,7 +286,8 @@ var Patter = class {
   embeddedServer = null;
   tunnelHandle = null;
   constructor(options) {
-    if ("mode" in options && options.mode === "local") {
+    const isLocal = "mode" in options && options.mode === "local" || !("apiKey" in options) && ("twilioSid" in options && options.twilioSid || "telnyxKey" in options && options.telnyxKey);
+    if (isLocal) {
       const local = options;
       if (!local.phoneNumber) {
         throw new Error("Local mode requires phoneNumber");
@@ -353,7 +401,7 @@ var Patter = class {
     if (this.mode !== "local") {
       throw new Error("test() is only available in local mode");
     }
-    const { TestSession: TestSession2 } = await import("./test-mode-RH65MMSP.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-ASSLSQU2.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -399,23 +447,42 @@ var Patter = class {
         const telnyxKey = this.localConfig.telnyxKey ?? "";
         const connectionId = this.localConfig.telnyxConnectionId ?? "";
         const streamUrl = `wss://${webhookUrl}/ws/stream/${encodeURIComponent(localOpts.to)}?caller=${encodeURIComponent(phoneNumber)}&callee=${encodeURIComponent(localOpts.to)}`;
+        const telnyxPayload = {
+          connection_id: connectionId,
+          from: phoneNumber,
+          to: localOpts.to,
+          stream_url: streamUrl,
+          stream_track: "both_tracks"
+        };
+        if (localOpts.ringTimeout !== void 0) {
+          telnyxPayload.timeout_secs = Math.max(1, Math.floor(localOpts.ringTimeout));
+        }
         const response2 = await fetch("https://api.telnyx.com/v2/calls", {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${telnyxKey}`
           },
-          body: JSON.stringify({
-            connection_id: connectionId,
-            from: phoneNumber,
-            to: localOpts.to,
-            stream_url: streamUrl,
-            stream_track: "both_tracks"
-          })
+          body: JSON.stringify(telnyxPayload)
         });
         if (!response2.ok) {
           throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
         }
+        if (this.embeddedServer) {
+          try {
+            const body = await response2.clone().json();
+            const callId = body.data?.call_control_id;
+            if (callId) {
+              this.embeddedServer.metricsStore.recordCallInitiated({
+                call_id: callId,
+                caller: phoneNumber,
+                callee: localOpts.to,
+                direction: "outbound"
+              });
+            }
+          } catch {
+          }
+        }
         return;
       }
       const twilioSid = this.localConfig.twilioSid ?? "";
@@ -427,13 +494,19 @@ var Patter = class {
         From: phoneNumber,
         Url: `https://${webhookUrl}/webhooks/twilio/voice`,
         StatusCallback: statusCallbackUrl,
-        StatusCallbackMethod: "POST"
+        StatusCallbackMethod: "POST",
+        // Full lifecycle so the dashboard sees ringing/no-answer/busy/failed
+        // transitions even when media never arrives.
+        StatusCallbackEvent: "initiated ringing answered completed"
       });
       if (localOpts.machineDetection) {
         params.append("MachineDetection", "DetectMessageEnd");
         params.append("AsyncAmd", "true");
         params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
       }
+      if (localOpts.ringTimeout !== void 0) {
+        params.append("Timeout", String(Math.max(1, Math.floor(localOpts.ringTimeout))));
+      }
       if (localOpts.voicemailMessage && this.embeddedServer) {
         this.embeddedServer.voicemailMessage = localOpts.voicemailMessage;
       }
@@ -448,6 +521,21 @@ var Patter = class {
       if (!response.ok) {
         throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
       }
+      if (this.embeddedServer) {
+        try {
+          const body = await response.clone().json();
+          const callSid = body.sid;
+          if (callSid) {
+            this.embeddedServer.metricsStore.recordCallInitiated({
+              call_id: callSid,
+              caller: phoneNumber,
+              callee: localOpts.to,
+              direction: "outbound"
+            });
+          }
+        } catch {
+        }
+      }
       return;
     }
     const cloudOpts = options;
@@ -530,11 +618,15 @@ var Patter = class {
     const data = await response.json();
     return data.map((c) => ({ id: c.id, direction: c.direction, caller: c.caller, callee: c.callee, startedAt: c.started_at, endedAt: c.ended_at, durationSeconds: c.duration_seconds, status: c.status, transcript: c.transcript }));
   }
-  // Provider helpers
+  // Provider helpers — mirror the Python classmethod factories so callers can
+  // write ``Patter.deepgram({ apiKey })`` without importing the top-level.
   static deepgram = deepgram;
   static whisper = whisper;
   static elevenlabs = elevenlabs;
   static openaiTts = openaiTts;
+  static cartesia = cartesia;
+  static rime = rime;
+  static lmnt = lmnt;
   static guardrail(opts) {
     return {
       name: opts.name,
@@ -600,8 +692,8 @@ var Patter = class {
         provider,
         provider_credentials: credentials,
         country,
-        stt_config: stt?.toDict() ?? null,
-        tts_config: tts?.toDict() ?? null
+        stt_config: stt ? stt.toDict?.() ?? sttConfigToDict(stt) : null,
+        tts_config: tts ? tts.toDict?.() ?? ttsConfigToDict(tts) : null
       })
     });
     if (response.status === 409) return;
@@ -719,6 +811,37 @@ var FallbackLLMProvider = class {
       }
     }
   }
+  /**
+   * Async-friendly disposer. Parity with Python's ``FallbackLLMProvider.aclose()``
+   * — safe to call multiple times, returns a resolved Promise once all probe
+   * timers are cleared. Prefer this in async contexts so awaiting the
+   * shutdown integrates naturally with the owning lifecycle.
+   */
+  async aclose() {
+    this.destroy();
+  }
+  /**
+   * Explicit-resource-management hook so callers can write
+   * ``await using fallback = new FallbackLLMProvider([...])`` and have
+   * background probe timers cleared automatically when the block exits.
+   * Mirrors Python's ``async with FallbackLLMProvider(...)``.
+   */
+  async [Symbol.asyncDispose]() {
+    await this.aclose();
+  }
+  /**
+   * Stream only the text deltas, flattening the chunk envelope. Parity with
+   * Python's ``FallbackLLMProvider.complete_stream``. Tool-call and done
+   * markers are filtered out so callers can concatenate the yielded strings
+   * directly.
+   */
+  async *completeStream(messages, tools) {
+    for await (const chunk of this.stream(messages, tools)) {
+      if (chunk.type === "text") {
+        yield chunk.content ?? "";
+      }
+    }
+  }
   // -----------------------------------------------------------------------
   // LLMProvider implementation
   // -----------------------------------------------------------------------
@@ -1235,13 +1358,37 @@ function wrapCallback(cb) {
     }
   };
 }
-async function scheduleCron(cron, callback) {
-  const cm = await loadCron();
-  if (!cm.validate(cron)) {
-    throw new Error(`Invalid cron expression: ${cron}`);
-  }
-  const task = cm.schedule(cron, wrapCallback(callback));
-  return makeHandle(`cron-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, task);
+function scheduleCron(cron, callback) {
+  let cancelled = false;
+  let task = null;
+  const jobId = `cron-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  loadCron().then((cm) => {
+    if (cancelled) return;
+    if (!cm.validate(cron)) {
+      throw new Error(`Invalid cron expression: ${cron}`);
+    }
+    task = cm.schedule(cron, wrapCallback(callback));
+  }).catch((err) => getLogger().error(`scheduleCron failed: ${String(err)}`));
+  return {
+    jobId,
+    cancel() {
+      if (cancelled) return;
+      cancelled = true;
+      if (task) {
+        try {
+          task.stop();
+        } catch {
+        }
+        try {
+          task.destroy?.();
+        } catch {
+        }
+      }
+    },
+    get pending() {
+      return !cancelled;
+    }
+  };
 }
 function scheduleOnce(at, callback) {
   const delayMs = at.getTime() - Date.now();
@@ -1263,8 +1410,18 @@ function scheduleOnce(at, callback) {
     }
   };
 }
-function scheduleInterval(intervalMs, callback) {
-  if (intervalMs <= 0) throw new Error("intervalMs must be positive");
+function scheduleInterval(intervalOrOpts, callback) {
+  let intervalMs;
+  if (typeof intervalOrOpts === "number") {
+    intervalMs = intervalOrOpts;
+  } else if (intervalOrOpts.intervalMs !== void 0) {
+    intervalMs = intervalOrOpts.intervalMs;
+  } else if (intervalOrOpts.seconds !== void 0) {
+    intervalMs = intervalOrOpts.seconds * 1e3;
+  } else {
+    throw new Error("scheduleInterval requires seconds or intervalMs");
+  }
+  if (intervalMs <= 0) throw new Error("interval must be positive");
   let cancelled = false;
   const wrapped = wrapCallback(callback);
   const timer = setInterval(() => {
@@ -1281,27 +1438,6 @@ function scheduleInterval(intervalMs, callback) {
     }
   };
 }
-function makeHandle(jobId, task) {
-  let cancelled = false;
-  return {
-    jobId,
-    cancel() {
-      if (cancelled) return;
-      cancelled = true;
-      try {
-        task.stop();
-      } catch {
-      }
-      try {
-        task.destroy?.();
-      } catch {
-      }
-    },
-    get pending() {
-      return !cancelled;
-    }
-  };
-}
 
 // src/providers/soniox-stt.ts
 import WebSocket3 from "ws";

package/dist/{test-mode-RH65MMSP.mjs → test-mode-ASSLSQU2.mjs}

@@ -1,6 +1,6 @@
 import {
   TestSession
-} from "./chunk-35EVXMGB.mjs";
+} from "./chunk-O3RQG3NL.mjs";
 import "./chunk-FMNRCP5X.mjs";
 import "./chunk-OOIUSZB4.mjs";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getpatter",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Open-source voice AI SDK — connect any AI agent to real phone calls in 4 lines of code",
   "license": "MIT",
   "author": {