@dtelecom/agents-js 0.1.0

package/dist/providers/index.js

@@ -0,0 +1,613 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  CartesiaTTS: () => CartesiaTTS,
+  DeepgramSTT: () => DeepgramSTT,
+  OpenRouterLLM: () => OpenRouterLLM
+});
+module.exports = __toCommonJS(providers_exports);
+
+// src/providers/deepgram-stt.ts
+var import_ws = __toESM(require("ws"));
+
+// src/core/base-stt-stream.ts
+var import_events = require("events");
+var BaseSTTStream = class extends import_events.EventEmitter {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event, cb) {
+    return super.on(event, cb);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/utils/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+function detectLevel() {
+  const debug = typeof process !== "undefined" && process.env?.DEBUG;
+  if (debug && (debug === "*" || debug.includes("@dtelecom/agents"))) {
+    return "debug";
+  }
+  return "info";
+}
+var globalLevel = detectLevel();
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${h}:${m}:${s}.${ms}`;
+}
+function createLogger(tag) {
+  const prefix = `[@dtelecom/agents:${tag}]`;
+  return {
+    debug(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.debug) console.debug(timestamp(), prefix, ...args);
+    },
+    info(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.info) console.info(timestamp(), prefix, ...args);
+    },
+    warn(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.warn) console.warn(timestamp(), prefix, ...args);
+    },
+    error(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.error) console.error(timestamp(), prefix, ...args);
+    }
+  };
+}
+
+// src/providers/deepgram-stt.ts
+var log = createLogger("DeepgramSTT");
+var DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
+var KEEPALIVE_INTERVAL_MS = 5e3;
+var DeepgramSTT = class {
+  options;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("DeepgramSTT requires an apiKey");
+    }
+    this.options = options;
+  }
+  createStream(options) {
+    const language = options?.language ?? this.options.language ?? "en";
+    return new DeepgramSTTStream(this.options, language);
+  }
+};
+var DeepgramSTTStream = class extends BaseSTTStream {
+  ws = null;
+  apiKey;
+  wsUrl;
+  _ready = false;
+  _closed = false;
+  pendingAudio = [];
+  keepAliveTimer = null;
+  lastAudioSentAt = 0;
+  /** Buffer of is_final=true transcripts for the current utterance */
+  utteranceBuffer = [];
+  /** Timestamp of the last non-empty interim result (approximates end of speech) */
+  lastInterimAt = 0;
+  constructor(options, language) {
+    super();
+    this.apiKey = options.apiKey;
+    this.wsUrl = buildWsUrl(options, language);
+    this.connect();
+  }
+  sendAudio(pcm16) {
+    if (this._closed) return;
+    if (!this._ready) {
+      this.pendingAudio.push(pcm16);
+      return;
+    }
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      this.ws.send(pcm16);
+      this.lastAudioSentAt = performance.now();
+    }
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._ready = false;
+    this.pendingAudio = [];
+    this.stopKeepAlive();
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      try {
+        this.ws.send(JSON.stringify({ type: "CloseStream" }));
+      } catch {
+      }
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    log.debug("DeepgramSTT stream closed");
+  }
+  connect() {
+    log.debug(`Connecting to Deepgram: ${this.wsUrl.replace(/token=[^&]+/, "token=***")}`);
+    this.ws = new import_ws.default(this.wsUrl, {
+      headers: {
+        Authorization: `Token ${this.apiKey}`
+      }
+    });
+    this.ws.on("open", () => {
+      log.info("Deepgram WebSocket connected");
+      this._ready = true;
+      for (const buf of this.pendingAudio) {
+        if (this.ws?.readyState === import_ws.default.OPEN) {
+          this.ws.send(buf);
+        }
+      }
+      this.pendingAudio = [];
+      this.startKeepAlive();
+    });
+    this.ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this.handleMessage(msg);
+      } catch (err) {
+        log.error("Failed to parse Deepgram message:", err);
+      }
+    });
+    this.ws.on("error", (err) => {
+      log.error("Deepgram WebSocket error:", err);
+      this.emit("error", err instanceof Error ? err : new Error(String(err)));
+    });
+    this.ws.on("close", (code, reason) => {
+      log.debug(`Deepgram WebSocket closed: ${code} ${reason.toString()}`);
+      this._ready = false;
+      this.stopKeepAlive();
+      if (!this._closed) {
+        log.info("Deepgram connection lost, reconnecting in 1s...");
+        setTimeout(() => {
+          if (!this._closed) this.connect();
+        }, 1e3);
+      }
+    });
+  }
+  handleMessage(msg) {
+    const type = msg.type;
+    if (type === "Results") {
+      this.handleResults(msg);
+    } else if (type === "UtteranceEnd") {
+      this.flushUtterance();
+    } else if (type === "Metadata") {
+      log.debug("Deepgram session metadata received");
+    } else if (type === "SpeechStarted") {
+      log.debug("Speech started detected");
+    }
+  }
+  handleResults(msg) {
+    const channel = msg.channel;
+    const transcript = channel?.alternatives?.[0]?.transcript ?? "";
+    const confidence = channel?.alternatives?.[0]?.confidence;
+    const isFinal = msg.is_final ?? false;
+    const speechFinal = msg.speech_final ?? false;
+    if (!transcript) return;
+    if (!isFinal) {
+      this.lastInterimAt = performance.now();
+      const fullInterim = this.utteranceBuffer.length > 0 ? this.utteranceBuffer.join(" ") + " " + transcript : transcript;
+      this.emit("transcription", {
+        text: fullInterim,
+        isFinal: false,
+        confidence: confidence ?? void 0
+      });
+      return;
+    }
+    this.utteranceBuffer.push(transcript);
+    if (speechFinal) {
+      this.flushUtterance();
+    }
+  }
+  /** Emit the buffered utterance as a single final transcription result. */
+  flushUtterance() {
+    if (this.utteranceBuffer.length === 0) return;
+    const now = performance.now();
+    const fullText = this.utteranceBuffer.join(" ");
+    this.utteranceBuffer = [];
+    const sttDuration = this.lastInterimAt > 0 ? now - this.lastInterimAt : void 0;
+    if (sttDuration !== void 0) {
+      log.info(`stt_final: ${sttDuration.toFixed(0)}ms "${fullText.slice(0, 50)}"`);
+    }
+    this.lastInterimAt = 0;
+    this.emit("transcription", {
+      text: fullText,
+      isFinal: true,
+      sttDuration
+    });
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveTimer = setInterval(() => {
+      if (this.ws?.readyState === import_ws.default.OPEN) {
+        this.ws.send(JSON.stringify({ type: "KeepAlive" }));
+      }
+    }, KEEPALIVE_INTERVAL_MS);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
+  }
+};
+function buildWsUrl(options, language) {
+  const params = new URLSearchParams();
+  params.set("model", options.model ?? "nova-3");
+  params.set("language", language);
+  params.set("encoding", "linear16");
+  params.set("sample_rate", "16000");
+  params.set("channels", "1");
+  params.set("interim_results", String(options.interimResults ?? true));
+  params.set("punctuate", String(options.punctuate ?? true));
+  if (options.endpointing === false) {
+    params.set("endpointing", "false");
+  } else {
+    params.set("endpointing", String(options.endpointing ?? 300));
+  }
+  if (options.smartFormat) {
+    params.set("smart_format", "true");
+  }
+  if (options.utteranceEndMs !== void 0) {
+    params.set("utterance_end_ms", String(options.utteranceEndMs));
+  } else if (options.interimResults !== false) {
+    params.set("utterance_end_ms", "1000");
+  }
+  if (options.keywords?.length) {
+    for (const kw of options.keywords) {
+      params.append("keywords", kw);
+    }
+  }
+  return `${DEEPGRAM_WS_URL}?${params.toString()}`;
+}
+
+// src/providers/openrouter-llm.ts
+var log2 = createLogger("OpenRouterLLM");
+var OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
+var OpenRouterLLM = class {
+  apiKey;
+  model;
+  maxTokens;
+  temperature;
+  provider;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("OpenRouterLLM requires an apiKey");
+    }
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.maxTokens = options.maxTokens ?? 512;
+    this.temperature = options.temperature ?? 0.7;
+    if (options.providerRouting) {
+      this.provider = {
+        sort: options.providerRouting.sort,
+        order: options.providerRouting.order,
+        allow_fallbacks: options.providerRouting.allowFallbacks
+      };
+    }
+  }
+  /**
+   * Warm up the LLM by sending the system prompt and a short message.
+   * Primes the HTTP/TLS connection and model loading on the provider side.
+   */
+  async warmup(systemPrompt) {
+    log2.info("Warming up LLM connection...");
+    const start = performance.now();
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: "Hello" }
+    ];
+    try {
+      const gen = this.chat(messages);
+      for await (const chunk of gen) {
+        if (chunk.type === "done") break;
+      }
+      log2.info(`LLM warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+    } catch (err) {
+      log2.warn("LLM warmup failed (non-fatal):", err);
+    }
+  }
+  async *chat(messages, signal) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      stream: true
+    };
+    if (this.provider) {
+      body.provider = this.provider;
+    }
+    log2.debug(`LLM request: model=${this.model}, messages=${messages.length}`);
+    const response = await fetch(OPENROUTER_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenRouter API error ${response.status}: ${errorText}`);
+    }
+    if (!response.body) {
+      throw new Error("OpenRouter response has no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        if (signal?.aborted) break;
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") {
+            yield { type: "done" };
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const choice = parsed.choices?.[0];
+            if (!choice) continue;
+            const delta = choice.delta;
+            if (delta?.content) {
+              yield { type: "token", token: delta.content };
+            }
+            if (parsed.usage) {
+              yield {
+                type: "done",
+                usage: {
+                  promptTokens: parsed.usage.prompt_tokens,
+                  completionTokens: parsed.usage.completion_tokens
+                }
+              };
+              return;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    yield { type: "done" };
+  }
+};
+
+// src/providers/cartesia-tts.ts
+var import_ws2 = __toESM(require("ws"));
+var log3 = createLogger("CartesiaTTS");
+var CARTESIA_WS_BASE = "wss://api.cartesia.ai/tts/websocket";
+var DEFAULT_API_VERSION = "2024-06-10";
+var DEFAULT_MODEL = "sonic-3";
+var DEFAULT_SAMPLE_RATE = 48e3;
+var CartesiaTTS = class {
+  apiKey;
+  voiceId;
+  modelId;
+  sampleRate;
+  apiVersion;
+  language;
+  speed;
+  emotion;
+  ws = null;
+  _connected = false;
+  connectPromise = null;
+  /** Active contexts keyed by context_id */
+  contexts = /* @__PURE__ */ new Map();
+  contextCounter = 0;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("CartesiaTTS requires an apiKey");
+    }
+    if (!options.voiceId) {
+      throw new Error("CartesiaTTS requires a voiceId");
+    }
+    this.apiKey = options.apiKey;
+    this.voiceId = options.voiceId;
+    this.modelId = options.modelId ?? DEFAULT_MODEL;
+    this.sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    this.apiVersion = options.apiVersion ?? DEFAULT_API_VERSION;
+    this.language = options.language;
+    this.speed = options.speed;
+    this.emotion = options.emotion;
+  }
+  /** Pre-connect the WebSocket so first synthesize() doesn't pay connection cost. */
+  async warmup() {
+    log3.info("Warming up TTS connection...");
+    const start = performance.now();
+    try {
+      await this.ensureConnection();
+      log3.info(`TTS warmup complete in ${(performance.now() - start).toFixed(0)}ms`);
+    } catch (err) {
+      log3.warn("TTS warmup failed (non-fatal):", err);
+    }
+  }
+  async *synthesize(text, signal) {
+    log3.debug(`Synthesizing: "${text.slice(0, 60)}"`);
+    await this.ensureConnection();
+    if (!this.ws || this.ws.readyState !== import_ws2.default.OPEN) {
+      throw new Error("Cartesia WebSocket not connected");
+    }
+    const contextId = `ctx-${++this.contextCounter}-${Date.now()}`;
+    const ctx = { chunks: [], done: false, error: null, wake: null };
+    this.contexts.set(contextId, ctx);
+    const request = {
+      model_id: this.modelId,
+      transcript: text,
+      voice: { mode: "id", id: this.voiceId },
+      output_format: {
+        container: "raw",
+        encoding: "pcm_s16le",
+        sample_rate: this.sampleRate
+      },
+      context_id: contextId,
+      continue: false
+    };
+    if (this.language) {
+      request.language = this.language;
+    }
+    if (this.speed !== void 0 || this.emotion !== void 0) {
+      const genConfig = {};
+      if (this.speed !== void 0) genConfig.speed = this.speed;
+      if (this.emotion !== void 0) genConfig.emotion = this.emotion;
+      request.generation_config = genConfig;
+    }
+    const onAbort = () => {
+      ctx.done = true;
+      ctx.wake?.();
+      if (this.ws?.readyState === import_ws2.default.OPEN) {
+        try {
+          this.ws.send(JSON.stringify({ context_id: contextId, cancel: true }));
+        } catch {
+        }
+      }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    this.ws.send(JSON.stringify(request));
+    try {
+      while (true) {
+        if (signal?.aborted) break;
+        if (ctx.error) throw ctx.error;
+        if (ctx.chunks.length > 0) {
+          yield ctx.chunks.shift();
+          continue;
+        }
+        if (ctx.done) break;
+        await new Promise((resolve) => {
+          ctx.wake = resolve;
+        });
+        ctx.wake = null;
+      }
+      while (ctx.chunks.length > 0) {
+        yield ctx.chunks.shift();
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      this.contexts.delete(contextId);
+    }
+  }
+  /** Ensure the persistent WebSocket is connected. */
+  ensureConnection() {
+    if (this._connected && this.ws?.readyState === import_ws2.default.OPEN) {
+      return Promise.resolve();
+    }
+    if (this.connectPromise) return this.connectPromise;
+    this.connectPromise = new Promise((resolve, reject) => {
+      const url = `${CARTESIA_WS_BASE}?api_key=${this.apiKey}&cartesia_version=${this.apiVersion}`;
+      log3.debug("Connecting to Cartesia...");
+      this.ws = new import_ws2.default(url);
+      this.ws.on("open", () => {
+        this._connected = true;
+        this.connectPromise = null;
+        log3.info("Cartesia WebSocket connected");
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.handleMessage(msg);
+        } catch (err) {
+          log3.error("Failed to parse Cartesia message:", err);
+        }
+      });
+      this.ws.on("error", (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        log3.error("Cartesia WebSocket error:", error);
+        for (const ctx of this.contexts.values()) {
+          ctx.error = error;
+          ctx.wake?.();
+        }
+        this._connected = false;
+        this.connectPromise = null;
+        reject(error);
+      });
+      this.ws.on("close", (code, reason) => {
+        log3.debug(`Cartesia WebSocket closed: ${code} ${reason.toString()}`);
+        this._connected = false;
+        this.connectPromise = null;
+        for (const ctx of this.contexts.values()) {
+          ctx.done = true;
+          ctx.wake?.();
+        }
+      });
+    });
+    return this.connectPromise;
+  }
+  handleMessage(msg) {
+    const contextId = msg.context_id;
+    if (!contextId) return;
+    const ctx = this.contexts.get(contextId);
+    if (!ctx) return;
+    const type = msg.type;
+    if (type === "chunk") {
+      const b64 = msg.data;
+      if (b64) {
+        const pcm = Buffer.from(b64, "base64");
+        ctx.chunks.push(pcm);
+        ctx.wake?.();
+      }
+    } else if (type === "done") {
+      log3.debug(`Cartesia synthesis done for ${contextId} (${ctx.chunks.length} chunks pending)`);
+      ctx.done = true;
+      ctx.wake?.();
+    } else if (type === "error") {
+      const errorMsg = msg.error ?? "Unknown Cartesia error";
+      log3.error(`Cartesia error for ${contextId}: ${errorMsg}`);
+      ctx.error = new Error(`Cartesia TTS error: ${errorMsg}`);
+      ctx.wake?.();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CartesiaTTS,
+  DeepgramSTT,
+  OpenRouterLLM
+});
+//# sourceMappingURL=index.js.map