@teamlearners/clawops 0.1.0

package/dist/agent/index.cjs

@@ -0,0 +1,2668 @@
+'use strict';
+
+var chunkJNSHMKDI_cjs = require('../chunk-JNSHMKDI.cjs');
+var fs = require('fs');
+var path = require('path');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+// src/agent/audio.ts
+var _BIAS = 132;
+var _CLIP = 32635;
+var DECODE_TABLE = [
+  -32124,
+  -31100,
+  -30076,
+  -29052,
+  -28028,
+  -27004,
+  -25980,
+  -24956,
+  -23932,
+  -22908,
+  -21884,
+  -20860,
+  -19836,
+  -18812,
+  -17788,
+  -16764,
+  -15996,
+  -15484,
+  -14972,
+  -14460,
+  -13948,
+  -13436,
+  -12924,
+  -12412,
+  -11900,
+  -11388,
+  -10876,
+  -10364,
+  -9852,
+  -9340,
+  -8828,
+  -8316,
+  -7932,
+  -7676,
+  -7420,
+  -7164,
+  -6908,
+  -6652,
+  -6396,
+  -6140,
+  -5884,
+  -5628,
+  -5372,
+  -5116,
+  -4860,
+  -4604,
+  -4348,
+  -4092,
+  -3900,
+  -3772,
+  -3644,
+  -3516,
+  -3388,
+  -3260,
+  -3132,
+  -3004,
+  -2876,
+  -2748,
+  -2620,
+  -2492,
+  -2364,
+  -2236,
+  -2108,
+  -1980,
+  -1884,
+  -1820,
+  -1756,
+  -1692,
+  -1628,
+  -1564,
+  -1500,
+  -1436,
+  -1372,
+  -1308,
+  -1244,
+  -1180,
+  -1116,
+  -1052,
+  -988,
+  -924,
+  -876,
+  -844,
+  -812,
+  -780,
+  -748,
+  -716,
+  -684,
+  -652,
+  -620,
+  -588,
+  -556,
+  -524,
+  -492,
+  -460,
+  -428,
+  -396,
+  -372,
+  -356,
+  -340,
+  -324,
+  -308,
+  -292,
+  -276,
+  -260,
+  -244,
+  -228,
+  -212,
+  -196,
+  -180,
+  -164,
+  -148,
+  -132,
+  -120,
+  -112,
+  -104,
+  -96,
+  -88,
+  -80,
+  -72,
+  -64,
+  -56,
+  -48,
+  -40,
+  -32,
+  -24,
+  -16,
+  -8,
+  0,
+  32124,
+  31100,
+  30076,
+  29052,
+  28028,
+  27004,
+  25980,
+  24956,
+  23932,
+  22908,
+  21884,
+  20860,
+  19836,
+  18812,
+  17788,
+  16764,
+  15996,
+  15484,
+  14972,
+  14460,
+  13948,
+  13436,
+  12924,
+  12412,
+  11900,
+  11388,
+  10876,
+  10364,
+  9852,
+  9340,
+  8828,
+  8316,
+  7932,
+  7676,
+  7420,
+  7164,
+  6908,
+  6652,
+  6396,
+  6140,
+  5884,
+  5628,
+  5372,
+  5116,
+  4860,
+  4604,
+  4348,
+  4092,
+  3900,
+  3772,
+  3644,
+  3516,
+  3388,
+  3260,
+  3132,
+  3004,
+  2876,
+  2748,
+  2620,
+  2492,
+  2364,
+  2236,
+  2108,
+  1980,
+  1884,
+  1820,
+  1756,
+  1692,
+  1628,
+  1564,
+  1500,
+  1436,
+  1372,
+  1308,
+  1244,
+  1180,
+  1116,
+  1052,
+  988,
+  924,
+  876,
+  844,
+  812,
+  780,
+  748,
+  716,
+  684,
+  652,
+  620,
+  588,
+  556,
+  524,
+  492,
+  460,
+  428,
+  396,
+  372,
+  356,
+  340,
+  324,
+  308,
+  292,
+  276,
+  260,
+  244,
+  228,
+  212,
+  196,
+  180,
+  164,
+  148,
+  132,
+  120,
+  112,
+  104,
+  96,
+  88,
+  80,
+  72,
+  64,
+  56,
+  48,
+  40,
+  32,
+  24,
+  16,
+  8,
+  0
+];
+function encodeUlawSample(sample) {
+  let sign = 0;
+  if (sample < 0) {
+    sign = 128;
+    sample = -sample;
+  }
+  if (sample > _CLIP) {
+    sample = _CLIP;
+  }
+  sample += _BIAS;
+  let exponent = 7;
+  const expValues = [16384, 8192, 4096, 2048, 1024, 512, 256];
+  for (const expVal of expValues) {
+    if (sample >= expVal) {
+      break;
+    }
+    exponent -= 1;
+  }
+  const mantissa = sample >> exponent + 3 & 15;
+  return ~(sign | exponent << 4 | mantissa) & 255;
+}
+function pcm16ToUlaw(pcm) {
+  if (!pcm.length) return Buffer.alloc(0);
+  const nSamples = pcm.length >> 1;
+  const out = Buffer.alloc(nSamples);
+  for (let i = 0; i < nSamples; i++) {
+    const sample = pcm.readInt16LE(i * 2);
+    out[i] = encodeUlawSample(sample);
+  }
+  return out;
+}
+function ulawToPcm16(ulaw) {
+  if (!ulaw.length) return Buffer.alloc(0);
+  const out = Buffer.alloc(ulaw.length * 2);
+  for (let i = 0; i < ulaw.length; i++) {
+    out.writeInt16LE(DECODE_TABLE[ulaw[i]], i * 2);
+  }
+  return out;
+}
+function resamplePcm16(pcm, fromRate, toRate) {
+  if (fromRate === toRate || !pcm.length) return pcm;
+  const nSamples = pcm.length >> 1;
+  const ratio = fromRate / toRate;
+  const outLen = Math.floor(nSamples / ratio);
+  const out = Buffer.alloc(outLen * 2);
+  for (let i = 0; i < outLen; i++) {
+    const srcPos = i * ratio;
+    const idx = Math.floor(srcPos);
+    const frac = srcPos - idx;
+    let val;
+    if (idx + 1 < nSamples) {
+      val = pcm.readInt16LE(idx * 2) * (1 - frac) + pcm.readInt16LE((idx + 1) * 2) * frac;
+    } else {
+      val = pcm.readInt16LE(idx * 2);
+    }
+    out.writeInt16LE(Math.round(val), i * 2);
+  }
+  return out;
+}
+
+// src/agent/control-ws.ts
+var DEFAULT_PATH = "/v1/agent/control";
+var INITIAL_RECONNECT_DELAY = 1e3;
+var MAX_RECONNECT_DELAY = 3e4;
+function buildControlWsUrl(options) {
+  const base = options.baseUrl.replace(/^http/, "ws").replace(/\/$/, "");
+  const path2 = options.path ?? DEFAULT_PATH;
+  return `${base}${path2}?api_key=${encodeURIComponent(options.apiKey)}&agent_id=${encodeURIComponent(options.agentId)}`;
+}
+var ControlWebSocket = class {
+  constructor(_options) {
+    this._options = _options;
+    this._url = buildControlWsUrl(_options);
+    this._connectedPromise = new Promise((resolve) => {
+      this._connectedResolve = resolve;
+    });
+  }
+  _url;
+  _ws = null;
+  _handlers = /* @__PURE__ */ new Map();
+  _reconnectDelay = INITIAL_RECONNECT_DELAY;
+  _closed = false;
+  _connectedResolve = null;
+  _connectedPromise;
+  /** Register an event handler for a specific event type. */
+  on(event, handler) {
+    let list = this._handlers.get(event);
+    if (!list) {
+      list = [];
+      this._handlers.set(event, list);
+    }
+    list.push(handler);
+  }
+  /** Connect to the control WebSocket. */
+  async connect() {
+    this._closed = false;
+    await this._doConnect();
+  }
+  /** Wait until the WebSocket is connected. */
+  async waitConnected() {
+    return this._connectedPromise;
+  }
+  /** Send a JSON message over the control WebSocket. */
+  send(message) {
+    if (this._ws && this._ws.readyState === 1) {
+      this._ws.send(JSON.stringify(message));
+    }
+  }
+  /** Close the WebSocket and stop reconnecting. */
+  close() {
+    this._closed = true;
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+  }
+  async _doConnect() {
+    const { WebSocket } = await import('ws');
+    const ws = new WebSocket(this._url);
+    this._ws = ws;
+    ws.on("open", () => {
+      this._reconnectDelay = INITIAL_RECONNECT_DELAY;
+      if (this._connectedResolve) {
+        this._connectedResolve();
+        this._connectedResolve = null;
+      }
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this._dispatchEvent(msg);
+      } catch {
+        console.error("[ControlWebSocket] Failed to parse message");
+      }
+    });
+    ws.on("close", () => {
+      if (!this._closed) {
+        this._scheduleReconnect();
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("[ControlWebSocket] Error:", err.message);
+    });
+  }
+  _dispatchEvent(event) {
+    const handlers = this._handlers.get(event.event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          const result = handler(event);
+          if (result && typeof result.catch === "function") {
+            result.catch((err) => {
+              console.error(`[ControlWebSocket] Error in handler for ${event.event}:`, err);
+            });
+          }
+        } catch (err) {
+          console.error(`[ControlWebSocket] Error in handler for ${event.event}:`, err);
+        }
+      }
+    }
+  }
+  _scheduleReconnect() {
+    const delay = this._reconnectDelay;
+    this._reconnectDelay = Math.min(this._reconnectDelay * 2, MAX_RECONNECT_DELAY);
+    setTimeout(() => {
+      if (!this._closed) {
+        this._doConnect().catch((err) => {
+          console.error("[ControlWebSocket] Reconnect failed:", err);
+          this._scheduleReconnect();
+        });
+      }
+    }, delay);
+  }
+};
+
+// src/agent/mcp/client.ts
+var MCPClient = class {
+  _servers = /* @__PURE__ */ new Map();
+  _clients = /* @__PURE__ */ new Map();
+  /** Add an MCP server configuration. */
+  addServer(name, config) {
+    this._servers.set(name, config);
+  }
+  /** Connect to all configured MCP servers and discover tools. */
+  async connect() {
+    const allTools = [];
+    for (const [name, config] of this._servers) {
+      try {
+        const tools = await this._connectServer(name, config);
+        allTools.push(...tools);
+      } catch (err) {
+        console.error(`[MCPClient] Failed to connect to server '${name}':`, err);
+      }
+    }
+    return allTools;
+  }
+  /** Disconnect from all MCP servers. */
+  async disconnect() {
+    for (const [name, client] of this._clients) {
+      try {
+        const c = client;
+        if (c.close) {
+          await c.close();
+        }
+      } catch (err) {
+        console.error(`[MCPClient] Error disconnecting from '${name}':`, err);
+      }
+    }
+    this._clients.clear();
+  }
+  async _connectServer(name, config) {
+    const sdk = await import('@modelcontextprotocol/sdk/client/index.js');
+    const { Client } = sdk;
+    const client = new Client({ name: `clawops-${name}`, version: "1.0.0" });
+    let transport;
+    if (config.type === "stdio") {
+      const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
+      transport = new StdioClientTransport({
+        command: config["command"],
+        args: config["args"] ?? [],
+        env: config["env"]
+      });
+    } else if (config.type === "http") {
+      const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');
+      transport = new StreamableHTTPClientTransport(
+        new URL(config["url"])
+      );
+    } else {
+      throw new Error(`Unsupported MCP server type: ${config.type}`);
+    }
+    await client.connect(transport);
+    this._clients.set(name, client);
+    const toolsResult = await client.listTools();
+    const tools = [];
+    for (const toolDef of toolsResult.tools) {
+      const inputSchema = toolDef.inputSchema;
+      tools.push({
+        name: toolDef.name,
+        description: toolDef.description ?? "",
+        parameters: inputSchema.properties ?? {},
+        required: inputSchema.required ?? [],
+        handler: async (args) => {
+          const result = await client.callTool({
+            name: toolDef.name,
+            arguments: args
+          });
+          const content = result.content;
+          if (content && content.length > 0) {
+            return content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+          }
+          return JSON.stringify(result);
+        }
+      });
+    }
+    return tools;
+  }
+};
+
+// src/agent/media-ws.ts
+function parseStartEvent(data) {
+  const start = data["start"];
+  return {
+    streamSid: start["streamSid"] ?? data["streamSid"] ?? "",
+    callSid: start["callSid"] ?? "",
+    accountSid: start["accountSid"] ?? "",
+    tracks: start["tracks"] ?? [],
+    customParameters: start["customParameters"] ?? {},
+    mediaFormat: start["mediaFormat"] ?? {
+      encoding: "audio/x-mulaw",
+      sampleRate: 8e3,
+      channels: 1
+    }
+  };
+}
+function parseMediaEvent(data) {
+  const media = data["media"];
+  return {
+    track: media["track"] ?? "inbound",
+    chunk: media["chunk"] ?? media["payload"] ?? "",
+    timestamp: media["timestamp"] ?? ""
+  };
+}
+function buildMediaResponse(streamSid, payload) {
+  return JSON.stringify({
+    event: "media",
+    streamSid,
+    media: {
+      payload
+    }
+  });
+}
+var MediaWebSocket = class {
+  _ws = null;
+  _streamSid = null;
+  _audioQueue = [];
+  _sendLoopRunning = false;
+  _closed = false;
+  _onAudio = null;
+  _onStart = null;
+  _onClose = null;
+  _markSeq = 0;
+  _markResolves = /* @__PURE__ */ new Map();
+  /** Set the handler for inbound audio data. */
+  onAudio(handler) {
+    this._onAudio = handler;
+  }
+  /** Set the handler for the start event. */
+  onStart(handler) {
+    this._onStart = handler;
+  }
+  /** Set the handler for connection close. */
+  onClose(handler) {
+    this._onClose = handler;
+  }
+  /** Connect to a media WebSocket URL. */
+  async connect(url) {
+    const { WebSocket } = await import('ws');
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      this._ws = ws;
+      this._closed = false;
+      ws.on("open", () => {
+        this._startSendLoop();
+        resolve();
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this._handleMessage(msg);
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        this._closed = true;
+        if (this._onClose) {
+          this._onClose();
+        }
+      });
+      ws.on("error", (err) => {
+        if (!this._ws) {
+          reject(err);
+        }
+        console.error("[MediaWebSocket] Error:", err.message);
+      });
+    });
+  }
+  /** Queue base64-encoded audio for sending. */
+  sendAudio(audioBase64) {
+    this._audioQueue.push(audioBase64);
+  }
+  /** Clear all queued outbound audio. */
+  sendClear() {
+    this._audioQueue.length = 0;
+    if (this._ws && this._streamSid && this._ws.readyState === 1) {
+      this._ws.send(
+        JSON.stringify({
+          event: "clear",
+          streamSid: this._streamSid
+        })
+      );
+    }
+  }
+  /** Send a mark event and return a promise that resolves when the mark is acknowledged. */
+  sendMark() {
+    const label = `mark_${++this._markSeq}`;
+    return new Promise((resolve) => {
+      this._markResolves.set(label, resolve);
+      if (this._ws && this._streamSid && this._ws.readyState === 1) {
+        this._ws.send(
+          JSON.stringify({
+            event: "mark",
+            streamSid: this._streamSid,
+            mark: { name: label }
+          })
+        );
+      }
+    });
+  }
+  /** Close the media WebSocket. */
+  close() {
+    this._closed = true;
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    for (const resolve of this._markResolves.values()) {
+      resolve();
+    }
+    this._markResolves.clear();
+  }
+  _handleMessage(msg) {
+    const event = msg["event"];
+    switch (event) {
+      case "start": {
+        const startEvt = parseStartEvent(msg);
+        this._streamSid = startEvt.streamSid;
+        if (this._onStart) {
+          this._onStart(startEvt);
+        }
+        break;
+      }
+      case "media": {
+        const mediaEvt = parseMediaEvent(msg);
+        if (mediaEvt.track === "inbound" && this._onAudio) {
+          const audioBuf = Buffer.from(mediaEvt.chunk, "base64");
+          this._onAudio(audioBuf);
+        }
+        break;
+      }
+      case "mark": {
+        const mark = msg["mark"];
+        const name = mark?.["name"];
+        if (name && this._markResolves.has(name)) {
+          this._markResolves.get(name)();
+          this._markResolves.delete(name);
+        }
+        break;
+      }
+      case "stop": {
+        this.close();
+        break;
+      }
+    }
+  }
+  _startSendLoop() {
+    if (this._sendLoopRunning) return;
+    this._sendLoopRunning = true;
+    const loop = () => {
+      if (this._closed) {
+        this._sendLoopRunning = false;
+        return;
+      }
+      while (this._audioQueue.length > 0 && this._ws && this._ws.readyState === 1) {
+        const payload = this._audioQueue.shift();
+        if (this._streamSid) {
+          this._ws.send(buildMediaResponse(this._streamSid, payload));
+        }
+      }
+      setTimeout(loop, 20);
+    };
+    loop();
+  }
+};
+var WAV_SAMPLE_RATE = 8e3;
+var WAV_CHANNELS = 1;
+var WAV_BITS_PER_SAMPLE = 16;
+function makeWavHeader(dataSize) {
+  const header = Buffer.alloc(44);
+  const byteRate = WAV_SAMPLE_RATE * WAV_CHANNELS * (WAV_BITS_PER_SAMPLE / 8);
+  const blockAlign = WAV_CHANNELS * (WAV_BITS_PER_SAMPLE / 8);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(WAV_CHANNELS, 22);
+  header.writeUInt32LE(WAV_SAMPLE_RATE, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(WAV_BITS_PER_SAMPLE, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  return header;
+}
+var AudioRecorder = class {
+  _outputDir;
+  _sampleRate;
+  _inboundChunks = [];
+  _outboundChunks = [];
+  _callId = null;
+  _started = false;
+  constructor(options) {
+    this._outputDir = options.outputDir;
+    this._sampleRate = options.sampleRate ?? WAV_SAMPLE_RATE;
+  }
+  /** Start recording for a call. */
+  start(callId) {
+    this._callId = callId;
+    this._inboundChunks = [];
+    this._outboundChunks = [];
+    this._started = true;
+    if (!fs__namespace.existsSync(this._outputDir)) {
+      fs__namespace.mkdirSync(this._outputDir, { recursive: true });
+    }
+  }
+  /** Write inbound (caller) PCM16 audio. */
+  writeInbound(pcm) {
+    if (this._started) {
+      this._inboundChunks.push(Buffer.from(pcm));
+    }
+  }
+  /** Write raw outbound (agent) PCM16 audio. */
+  writeRawOutbound(pcm) {
+    if (this._started) {
+      this._outboundChunks.push(Buffer.from(pcm));
+    }
+  }
+  /** Stop recording and write WAV files to disk. Returns file paths. */
+  stop() {
+    if (!this._started || !this._callId) {
+      return {};
+    }
+    this._started = false;
+    const result = {};
+    if (this._inboundChunks.length > 0) {
+      const inboundPath = path__namespace.join(this._outputDir, `${this._callId}_inbound.wav`);
+      this._writeWav(inboundPath, this._inboundChunks);
+      result.inbound = inboundPath;
+    }
+    if (this._outboundChunks.length > 0) {
+      const outboundPath = path__namespace.join(this._outputDir, `${this._callId}_outbound.wav`);
+      this._writeWav(outboundPath, this._outboundChunks);
+      result.outbound = outboundPath;
+    }
+    this._inboundChunks = [];
+    this._outboundChunks = [];
+    return result;
+  }
+  _writeWav(filePath, chunks) {
+    const pcmData = Buffer.concat(chunks);
+    const header = makeWavHeader(pcmData.length);
+    const fd = fs__namespace.openSync(filePath, "w");
+    fs__namespace.writeSync(fd, header);
+    fs__namespace.writeSync(fd, pcmData);
+    fs__namespace.closeSync(fd);
+  }
+};
+
+// src/agent/session.ts
+var CallSession = class {
+  callId;
+  fromNumber;
+  toNumber;
+  accountId;
+  direction;
+  startTime;
+  metadata;
+  _status;
+  _sendAudioFn = null;
+  _clearAudioFn = null;
+  _hangupFn = null;
+  _handlers = /* @__PURE__ */ new Map();
+  _endedPromise;
+  _resolveEnded;
+  constructor(options) {
+    this.callId = options.callId;
+    this.fromNumber = options.fromNumber;
+    this.toNumber = options.toNumber;
+    this.accountId = options.accountId;
+    this.direction = options.direction;
+    this.metadata = options.metadata ?? {};
+    this._status = "ringing";
+    this.startTime = /* @__PURE__ */ new Date();
+    this._endedPromise = new Promise((resolve) => {
+      this._resolveEnded = resolve;
+    });
+  }
+  get status() {
+    return this._status;
+  }
+  get duration() {
+    return (Date.now() - this.startTime.getTime()) / 1e3;
+  }
+  /** Bind transport functions (called internally by the agent). */
+  _bindTransport(send, clear, hangup) {
+    this._sendAudioFn = send;
+    this._clearAudioFn = clear;
+    this._hangupFn = hangup;
+    this._status = "active";
+  }
+  /** Send PCM16 or ulaw audio to the caller. */
+  sendAudio(audio) {
+    if (this._sendAudioFn) {
+      this._sendAudioFn(audio);
+    }
+  }
+  /** Clear any queued outbound audio. */
+  clearAudio() {
+    if (this._clearAudioFn) {
+      this._clearAudioFn();
+    }
+  }
+  /** Hang up the call. */
+  hangup() {
+    if (this._hangupFn) {
+      this._hangupFn();
+    }
+  }
+  /** Register an event handler. */
+  on(event, handler) {
+    let list = this._handlers.get(event);
+    if (!list) {
+      list = [];
+      this._handlers.set(event, list);
+    }
+    list.push(handler);
+  }
+  /** Wait for the call to end. */
+  async wait() {
+    return this._endedPromise;
+  }
+  /** Mark the session as ended (called internally). */
+  _markEnded() {
+    this._status = "ended";
+    this._emit({ type: "ended" });
+    this._resolveEnded();
+  }
+  /** Emit an event to registered handlers. */
+  _emit(event) {
+    const handlers = this._handlers.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          const result = handler(event);
+          if (result && typeof result.catch === "function") {
+            result.catch((err) => {
+              console.error(`[CallSession] Error in ${event.type} handler:`, err);
+            });
+          }
+        } catch (err) {
+          console.error(`[CallSession] Error in ${event.type} handler:`, err);
+        }
+      }
+    }
+  }
+};
+
+// src/agent/tool.ts
+function functionTool(fn) {
+  return fn;
+}
+var ToolRegistry = class _ToolRegistry {
+  _tools = /* @__PURE__ */ new Map();
+  _mcpTools = /* @__PURE__ */ new Map();
+  /** Register a function tool. */
+  register(tool) {
+    this._tools.set(tool.name, tool);
+  }
+  /** Register tools discovered from MCP servers. */
+  registerMcpTools(tools) {
+    for (const tool of tools) {
+      this._mcpTools.set(tool.name, tool);
+    }
+  }
+  /** Clear all MCP-registered tools. */
+  clearMcpTools() {
+    this._mcpTools.clear();
+  }
+  /**
+   * Create a fork (shallow copy) of this registry.
+   * Useful for per-session tool isolation.
+   */
+  fork() {
+    const copy = new _ToolRegistry();
+    for (const [name, tool] of this._tools) {
+      copy._tools.set(name, tool);
+    }
+    for (const [name, tool] of this._mcpTools) {
+      copy._mcpTools.set(name, tool);
+    }
+    return copy;
+  }
+  /** Check if a tool is registered. */
+  has(name) {
+    return this._tools.has(name) || this._mcpTools.has(name);
+  }
+  /** Get a tool by name. */
+  get(name) {
+    return this._tools.get(name) ?? this._mcpTools.get(name);
+  }
+  /** Convert all registered tools to OpenAI function-calling format. */
+  toOpenAITools() {
+    const result = [];
+    const allTools = [...this._tools.values(), ...this._mcpTools.values()];
+    for (const tool of allTools) {
+      result.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: {
+            type: "object",
+            properties: tool.parameters,
+            required: tool.required
+          }
+        }
+      });
+    }
+    return result;
+  }
+  /** Call a tool by name with the given arguments. */
+  async call(name, args) {
+    const tool = this.get(name);
+    if (!tool) {
+      throw new Error(`Tool '${name}' not found in registry`);
+    }
+    return tool.handler(args);
+  }
+  /** Get the number of registered tools (including MCP). */
+  get size() {
+    return this._tools.size + this._mcpTools.size;
+  }
+};
+function zodToToolParams(schema) {
+  const shape = schema.shape;
+  const parameters = {};
+  const required = [];
+  for (const [key, field] of Object.entries(shape)) {
+    const zodField = field;
+    const desc = zodField.description;
+    let isOptional = false;
+    let innerType = zodField;
+    if ("unwrap" in zodField && zodField._def?.typeName === "ZodOptional") {
+      isOptional = true;
+      innerType = zodField.unwrap();
+    }
+    const jsonSchema = {};
+    const typeName = innerType._def?.typeName;
+    switch (typeName) {
+      case "ZodString":
+        jsonSchema.type = "string";
+        break;
+      case "ZodNumber":
+        jsonSchema.type = "number";
+        break;
+      case "ZodBoolean":
+        jsonSchema.type = "boolean";
+        break;
+      case "ZodArray":
+        jsonSchema.type = "array";
+        break;
+      case "ZodEnum":
+        jsonSchema.type = "string";
+        jsonSchema.enum = innerType._def?.values;
+        break;
+      default:
+        jsonSchema.type = "string";
+    }
+    if (desc) {
+      jsonSchema.description = desc;
+    }
+    parameters[key] = jsonSchema;
+    if (!isOptional) {
+      required.push(key);
+    }
+  }
+  return { parameters, required };
+}
+
+// src/agent/tracing/config.ts
+var DEFAULT_CONFIG = {
+  enabled: false,
+  serviceName: "clawops-agent"
+};
+var _currentConfig = { ...DEFAULT_CONFIG };
+function getTracingConfig() {
+  return _currentConfig;
+}
+function setTracingConfig(config) {
+  _currentConfig = { ..._currentConfig, ...config };
+}
+function resetTracingConfig() {
+  _currentConfig = { ...DEFAULT_CONFIG };
+}
+
+// src/agent/tracing/spans.ts
+var _tracer = null;
+async function getTracer() {
+  const config = getTracingConfig();
+  if (!config.enabled) return null;
+  if (_tracer) return _tracer;
+  try {
+    const otel = await import('@opentelemetry/api');
+    const provider = config.tracerProvider ?? otel.trace.getTracerProvider();
+    _tracer = provider.getTracer(
+      config.serviceName ?? "clawops-agent",
+      "1.0.0"
+    );
+    return _tracer;
+  } catch {
+    return null;
+  }
+}
+async function withSpan(name, attributes, fn) {
+  const tracer = await getTracer();
+  if (!tracer) {
+    return fn(createNoOpSpan());
+  }
+  const span = tracer.startSpan(name, { attributes });
+  try {
+    const result = await fn(span);
+    span.setStatus({ code: 1 });
+    return result;
+  } catch (err) {
+    span.setStatus({ code: 2, message: String(err) });
+    if (err instanceof Error) {
+      span.recordException(err);
+    }
+    throw err;
+  } finally {
+    span.end();
+  }
+}
+function createNoOpSpan() {
+  return {
+    setAttribute() {
+    },
+    setStatus() {
+    },
+    recordException() {
+    },
+    end() {
+    }
+  };
+}
+
+// src/agent/tracing/attributes.ts
+var ATTR_CALL_ID = "clawops.call.id";
+var ATTR_CALL_DIRECTION = "clawops.call.direction";
+var ATTR_AGENT_ID = "clawops.agent.id";
+
+// src/agent/agent.ts
+var ClawOpsAgent = class {
+  _apiKey;
+  _agentId;
+  _baseUrl;
+  _sessionFactory = null;
+  _tools = new ToolRegistry();
+  _handlers = /* @__PURE__ */ new Map();
+  _controlWs = null;
+  _mcpClient = null;
+  _recordingDir;
+  _activeSessions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this._apiKey = options.apiKey ?? process.env["CLAWOPS_API_KEY"] ?? "";
+    this._agentId = options.agentId ?? process.env["CLAWOPS_AGENT_ID"] ?? "";
+    this._baseUrl = options.baseUrl ?? chunkJNSHMKDI_cjs.DEFAULT_BASE_URL;
+    this._recordingDir = options.recordingDir ?? null;
+    if (options.session) {
+      if (typeof options.session === "function") {
+        this._sessionFactory = options.session;
+      } else {
+        const sessionInstance = options.session;
+        this._sessionFactory = () => sessionInstance;
+      }
+    }
+    if (options.mcpServers) {
+      this._mcpClient = new MCPClient();
+      for (const [name, config] of Object.entries(options.mcpServers)) {
+        this._mcpClient.addServer(name, config);
+      }
+    }
+    if (options.tracing) {
+      setTracingConfig(options.tracing);
+    }
+  }
+  /** Register a function tool. */
+  tool(tool) {
+    this._tools.register(tool);
+    return this;
+  }
+  /** Register an event handler. */
+  on(event, handler) {
+    let list = this._handlers.get(event);
+    if (!list) {
+      list = [];
+      this._handlers.set(event, list);
+    }
+    list.push(handler);
+    return this;
+  }
+  /** Connect to the ClawOps platform and start listening for calls. */
+  async connect() {
+    if (!this._apiKey) {
+      throw new chunkJNSHMKDI_cjs.AgentError("API key is required. Set CLAWOPS_API_KEY or pass apiKey option.");
+    }
+    if (!this._agentId) {
+      throw new chunkJNSHMKDI_cjs.AgentError("Agent ID is required. Set CLAWOPS_AGENT_ID or pass agentId option.");
+    }
+    if (this._mcpClient) {
+      try {
+        const mcpTools = await this._mcpClient.connect();
+        this._tools.registerMcpTools(mcpTools);
+      } catch (err) {
+        console.error("[ClawOpsAgent] MCP connection error:", err);
+      }
+    }
+    this._controlWs = new ControlWebSocket({
+      baseUrl: this._baseUrl,
+      apiKey: this._apiKey,
+      agentId: this._agentId
+    });
+    this._controlWs.on("call.incoming", (event) => this._handleIncoming(event));
+    this._controlWs.on("call.ended", (event) => this._handleEnded(event));
+    this._controlWs.on("call.outbound_ready", (event) => this._handleOutboundReady(event));
+    this._controlWs.on("call.ringing", (event) => this._handleRinging(event));
+    this._controlWs.on("call.failed", (event) => this._handleFailed(event));
+    try {
+      await this._controlWs.connect();
+      await this._controlWs.waitConnected();
+    } catch (err) {
+      throw new chunkJNSHMKDI_cjs.AgentConnectionError(
+        `Failed to connect to ClawOps: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  /**
+   * Connect and block until disconnected.
+   * Convenience method for simple agent scripts.
+   */
+  async serve() {
+    await this.connect();
+    return new Promise((resolve) => {
+      const shutdown = () => {
+        this.disconnect().then(resolve).catch(() => resolve());
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+    });
+  }
+  /** Disconnect from the platform. */
+  async disconnect() {
+    if (this._controlWs) {
+      this._controlWs.close();
+      this._controlWs = null;
+    }
+    for (const session of this._activeSessions.values()) {
+      session._markEnded();
+    }
+    this._activeSessions.clear();
+    if (this._mcpClient) {
+      await this._mcpClient.disconnect();
+      this._tools.clearMcpTools();
+    }
+  }
+  /**
+   * Initiate an outbound call.
+   */
+  call(options) {
+    if (!this._controlWs) {
+      throw new chunkJNSHMKDI_cjs.AgentError("Agent is not connected. Call connect() first.");
+    }
+    this._controlWs.send({
+      action: "call.create",
+      data: {
+        to_number: options.to,
+        from_number: options.from,
+        metadata: options.metadata
+      }
+    });
+  }
+  _handleIncoming(event) {
+    const data = event.data;
+    const session = new CallSession({
+      callId: data.call_id,
+      fromNumber: data.from_number ?? "",
+      toNumber: data.to_number ?? "",
+      accountId: data.account_id ?? "",
+      direction: data.direction ?? "inbound",
+      metadata: data.metadata
+    });
+    this._activeSessions.set(data.call_id, session);
+    this._emitEvent("call.incoming", session);
+    if (data.media_ws_url) {
+      this._startCallSession(session, data.media_ws_url).catch((err) => {
+        console.error(`[ClawOpsAgent] Error in call session ${data.call_id}:`, err);
+      });
+    }
+  }
+  _handleEnded(event) {
+    const session = this._activeSessions.get(event.data.call_id);
+    if (session) {
+      session._markEnded();
+      this._activeSessions.delete(event.data.call_id);
+      this._emitEvent("call.ended", session);
+    }
+  }
+  _handleOutboundReady(event) {
+    const data = event.data;
+    const session = new CallSession({
+      callId: data.call_id,
+      fromNumber: data.from_number ?? "",
+      toNumber: data.to_number ?? "",
+      accountId: data.account_id ?? "",
+      direction: "outbound",
+      metadata: data.metadata
+    });
+    this._activeSessions.set(data.call_id, session);
+    this._emitEvent("call.outbound_ready", session);
+    if (data.media_ws_url) {
+      this._startCallSession(session, data.media_ws_url).catch((err) => {
+        console.error(`[ClawOpsAgent] Error in call session ${data.call_id}:`, err);
+      });
+    }
+  }
+  _handleRinging(event) {
+    const session = this._activeSessions.get(event.data.call_id);
+    if (session) {
+      this._emitEvent("call.ringing", session);
+    }
+  }
+  _handleFailed(event) {
+    const session = this._activeSessions.get(event.data.call_id);
+    if (session) {
+      session._markEnded();
+      this._activeSessions.delete(event.data.call_id);
+      this._emitEvent("call.failed", session);
+    }
+  }
+  async _startCallSession(session, mediaWsUrl) {
+    await withSpan(
+      "clawops.call_session",
+      {
+        [ATTR_CALL_ID]: session.callId,
+        [ATTR_CALL_DIRECTION]: session.direction,
+        [ATTR_AGENT_ID]: this._agentId
+      },
+      async () => {
+        const sessionTools = this._tools.fork();
+        let recorder = null;
+        if (this._recordingDir) {
+          recorder = new AudioRecorder({ outputDir: this._recordingDir });
+          recorder.start(session.callId);
+        }
+        const mediaWs = new MediaWebSocket();
+        session._bindTransport(
+          (audio) => {
+            const ulaw = pcm16ToUlaw(audio);
+            mediaWs.sendAudio(ulaw.toString("base64"));
+            if (recorder) {
+              recorder.writeRawOutbound(audio);
+            }
+          },
+          () => {
+            mediaWs.sendClear();
+          },
+          () => {
+            mediaWs.close();
+          }
+        );
+        const sessionHandler = this._sessionFactory ? this._sessionFactory() : null;
+        mediaWs.onAudio((ulawAudio) => {
+          const pcm = ulawToPcm16(ulawAudio);
+          if (recorder) {
+            recorder.writeInbound(pcm);
+          }
+          if (sessionHandler) {
+            const resampled = resamplePcm16(pcm, 8e3, 16e3);
+            sessionHandler.feedAudio(resampled);
+          }
+        });
+        mediaWs.onClose(() => {
+          if (recorder) {
+            recorder.stop();
+          }
+          session._markEnded();
+        });
+        try {
+          await mediaWs.connect(mediaWsUrl);
+          if (sessionHandler) {
+            await sessionHandler.start(session, sessionTools);
+          }
+          await session.wait();
+          if (sessionHandler) {
+            await sessionHandler.stop();
+          }
+        } catch (err) {
+          console.error(`[ClawOpsAgent] Call session error:`, err);
+        } finally {
+          mediaWs.close();
+          if (recorder) {
+            recorder.stop();
+          }
+        }
+      }
+    );
+  }
+  _emitEvent(event, session) {
+    const handlers = this._handlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          const result = handler(session);
+          if (result && typeof result.catch === "function") {
+            result.catch((err) => {
+              console.error(`[ClawOpsAgent] Error in ${event} handler:`, err);
+            });
+          }
+        } catch (err) {
+          console.error(`[ClawOpsAgent] Error in ${event} handler:`, err);
+        }
+      }
+    }
+  }
+};
+
+// src/agent/pipeline/openai-realtime.ts
+var OpenAIRealtime = class {
+  _options;
+  _ws = null;
+  _callSession = null;
+  _tools = null;
+  _closed = false;
+  constructor(options = {}) {
+    this._options = {
+      model: "gpt-4o-realtime-preview",
+      voice: "alloy",
+      inputAudioFormat: "pcm16",
+      outputAudioFormat: "pcm16",
+      ...options
+    };
+  }
+  async start(callSession, tools) {
+    this._callSession = callSession;
+    this._tools = tools ?? null;
+    this._closed = false;
+    const apiKey = this._options.apiKey ?? process.env["OPENAI_API_KEY"];
+    if (!apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    const { WebSocket } = await import('ws');
+    const url = `wss://api.openai.com/v1/realtime?model=${this._options.model}`;
+    this._ws = new WebSocket(url, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "OpenAI-Beta": "realtime=v1"
+      }
+    });
+    return new Promise((resolve, reject) => {
+      const ws = this._ws;
+      ws.on("open", () => {
+        this._sendSessionUpdate();
+        resolve();
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this._handleMessage(msg);
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        this._closed = true;
+      });
+      ws.on("error", (err) => {
+        if (!this._ws) {
+          reject(err);
+        }
+        console.error("[OpenAIRealtime] WebSocket error:", err.message);
+      });
+    });
+  }
+  feedAudio(audio) {
+    if (this._ws && this._ws.readyState === 1 && !this._closed) {
+      this._ws.send(
+        JSON.stringify({
+          type: "input_audio_buffer.append",
+          audio: audio.toString("base64")
+        })
+      );
+    }
+  }
+  async stop() {
+    this._closed = true;
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+  }
+  _sendSessionUpdate() {
+    if (!this._ws || this._ws.readyState !== 1) return;
+    const sessionConfig = {
+      modalities: ["text", "audio"],
+      voice: this._options.voice,
+      input_audio_format: this._options.inputAudioFormat,
+      output_audio_format: this._options.outputAudioFormat
+    };
+    if (this._options.instructions) {
+      sessionConfig["instructions"] = this._options.instructions;
+    }
+    if (this._options.temperature !== void 0) {
+      sessionConfig["temperature"] = this._options.temperature;
+    }
+    if (this._options.turnDetection !== void 0) {
+      sessionConfig["turn_detection"] = this._options.turnDetection;
+    }
+    if (this._tools && this._tools.size > 0) {
+      sessionConfig["tools"] = this._tools.toOpenAITools().map((t) => t.function);
+    }
+    this._ws.send(
+      JSON.stringify({
+        type: "session.update",
+        session: sessionConfig
+      })
+    );
+  }
+  _handleMessage(msg) {
+    const type = msg["type"];
+    switch (type) {
+      case "response.audio.delta": {
+        const delta = msg["delta"];
+        if (delta && this._callSession) {
+          const audio = Buffer.from(delta, "base64");
+          this._callSession.sendAudio(audio);
+        }
+        break;
+      }
+      case "response.audio.done": {
+        break;
+      }
+      case "response.function_call_arguments.done": {
+        this._handleFunctionCall(msg);
+        break;
+      }
+      case "input_audio_buffer.speech_started": {
+        if (this._callSession) {
+          this._callSession.clearAudio();
+        }
+        break;
+      }
+      case "error": {
+        console.error("[OpenAIRealtime] API error:", msg["error"]);
+        break;
+      }
+    }
+  }
+  async _handleFunctionCall(msg) {
+    const name = msg["name"];
+    const callId = msg["call_id"];
+    const argsStr = msg["arguments"];
+    if (!this._tools || !this._tools.has(name)) {
+      console.error(`[OpenAIRealtime] Unknown tool: ${name}`);
+      return;
+    }
+    try {
+      const args = JSON.parse(argsStr);
+      const result = await this._tools.call(name, args);
+      if (this._ws && this._ws.readyState === 1) {
+        this._ws.send(
+          JSON.stringify({
+            type: "conversation.item.create",
+            item: {
+              type: "function_call_output",
+              call_id: callId,
+              output: typeof result === "string" ? result : JSON.stringify(result)
+            }
+          })
+        );
+        this._ws.send(JSON.stringify({ type: "response.create" }));
+      }
+    } catch (err) {
+      console.error(`[OpenAIRealtime] Tool call error for ${name}:`, err);
+    }
+  }
+};
+
+// src/agent/pipeline/gemini-realtime.ts
+var GeminiRealtime = class {
+  _options;
+  _ws = null;
+  _callSession = null;
+  _tools = null;
+  _closed = false;
+  constructor(options = {}) {
+    this._options = {
+      model: "gemini-2.0-flash-exp",
+      ...options
+    };
+  }
+  async start(callSession, tools) {
+    this._callSession = callSession;
+    this._tools = tools ?? null;
+    this._closed = false;
+    const apiKey = this._options.apiKey ?? process.env["GOOGLE_API_KEY"];
+    if (!apiKey) {
+      throw new Error("Google API key is required");
+    }
+    const { WebSocket } = await import('ws');
+    this._options.model;
+    const url = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent?key=${apiKey}`;
+    this._ws = new WebSocket(url);
+    return new Promise((resolve, reject) => {
+      const ws = this._ws;
+      ws.on("open", () => {
+        this._sendSetup();
+        resolve();
+      });
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this._handleMessage(msg);
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        this._closed = true;
+      });
+      ws.on("error", (err) => {
+        if (!this._ws) {
+          reject(err);
+        }
+        console.error("[GeminiRealtime] WebSocket error:", err.message);
+      });
+    });
+  }
+  feedAudio(audio) {
+    if (this._ws && this._ws.readyState === 1 && !this._closed) {
+      this._ws.send(
+        JSON.stringify({
+          realtimeInput: {
+            mediaChunks: [
+              {
+                mimeType: "audio/pcm;rate=16000",
+                data: audio.toString("base64")
+              }
+            ]
+          }
+        })
+      );
+    }
+  }
+  async stop() {
+    this._closed = true;
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+  }
+  _sendSetup() {
+    if (!this._ws || this._ws.readyState !== 1) return;
+    const setupConfig = {
+      model: `models/${this._options.model}`,
+      generationConfig: {
+        responseModalities: ["AUDIO"],
+        speechConfig: {
+          voiceConfig: {
+            prebuiltVoiceConfig: {
+              voiceName: this._options.voice ?? "Aoede"
+            }
+          }
+        },
+        ...this._options.generationConfig
+      }
+    };
+    if (this._options.systemInstruction) {
+      setupConfig["systemInstruction"] = {
+        parts: [{ text: this._options.systemInstruction }]
+      };
+    }
+    if (this._tools && this._tools.size > 0) {
+      const toolDefs = this._tools.toOpenAITools().map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters
+      }));
+      setupConfig["tools"] = [{ functionDeclarations: toolDefs }];
+    }
+    this._ws.send(JSON.stringify({ setup: setupConfig }));
+  }
+  _handleMessage(msg) {
+    const serverContent = msg["serverContent"];
+    if (serverContent) {
+      const modelTurn = serverContent["modelTurn"];
+      if (modelTurn) {
+        const parts = modelTurn["parts"];
+        if (parts) {
+          for (const part of parts) {
+            const inlineData = part["inlineData"];
+            if (inlineData && inlineData["data"] && this._callSession) {
+              const audio = Buffer.from(inlineData["data"], "base64");
+              this._callSession.sendAudio(audio);
+            }
+          }
+        }
+      }
+    }
+    const toolCall = msg["toolCall"];
+    if (toolCall) {
+      this._handleToolCall(toolCall);
+    }
+  }
+  async _handleToolCall(toolCall) {
+    const functionCalls = toolCall["functionCalls"];
+    if (!functionCalls || !this._tools) return;
+    const responses = [];
+    for (const fc of functionCalls) {
+      const name = fc["name"];
+      const args = fc["args"] ?? {};
+      try {
+        const result = await this._tools.call(name, args);
+        responses.push({
+          name,
+          response: { result: typeof result === "string" ? result : JSON.stringify(result) }
+        });
+      } catch (err) {
+        console.error(`[GeminiRealtime] Tool call error for ${name}:`, err);
+        responses.push({
+          name,
+          response: { error: String(err) }
+        });
+      }
+    }
+    if (this._ws && this._ws.readyState === 1) {
+      this._ws.send(
+        JSON.stringify({
+          toolResponse: {
+            functionResponses: responses
+          }
+        })
+      );
+    }
+  }
+};
+
+// src/agent/pipeline/pipeline-session.ts
+var PipelineSession = class {
+  _stt;
+  _llm;
+  _tts;
+  _systemPrompt;
+  _temperature;
+  _maxTokens;
+  _sampleRate;
+  _interruptOnSpeech;
+  _callSession = null;
+  _tools = null;
+  _conversation = [];
+  _audioBuffer = [];
+  _running = false;
+  _speaking = false;
+  constructor(options) {
+    this._stt = options.stt;
+    this._llm = options.llm;
+    this._tts = options.tts;
+    this._systemPrompt = options.systemPrompt;
+    this._temperature = options.temperature;
+    this._maxTokens = options.maxTokens;
+    this._sampleRate = options.sampleRate ?? 8e3;
+    this._interruptOnSpeech = options.interruptOnSpeech ?? true;
+  }
+  async start(callSession, tools) {
+    this._callSession = callSession;
+    this._tools = tools ?? null;
+    this._running = true;
+    this._conversation = [];
+    if (this._systemPrompt) {
+      this._conversation.push({
+        role: "system",
+        content: this._systemPrompt
+      });
+    }
+    this._runSttLoop().catch((err) => {
+      console.error("[PipelineSession] STT loop error:", err);
+    });
+  }
+  feedAudio(audio) {
+    if (this._running) {
+      this._audioBuffer.push(audio);
+    }
+  }
+  async stop() {
+    this._running = false;
+    this._audioBuffer = [];
+  }
+  async _runSttLoop() {
+    const audioStream = this._createAudioStream();
+    for await (const event of this._stt.transcribe(audioStream, {
+      sampleRate: this._sampleRate
+    })) {
+      if (!this._running) break;
+      if (event.type === "interim" && this._speaking && this._interruptOnSpeech) {
+        this._speaking = false;
+        if (this._callSession) {
+          this._callSession.clearAudio();
+        }
+      }
+      if (event.type === "final" && event.transcript.trim()) {
+        await this._handleUserSpeech(event.transcript);
+      }
+    }
+  }
+  async *_createAudioStream() {
+    while (this._running) {
+      if (this._audioBuffer.length > 0) {
+        yield this._audioBuffer.shift();
+      } else {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+    }
+  }
+  async _handleUserSpeech(transcript) {
+    this._conversation.push({ role: "user", content: transcript });
+    let fullResponse = "";
+    const textChunks = [];
+    const llmStream = this._llm.generate(this._conversation, {
+      tools: this._tools ?? void 0,
+      temperature: this._temperature,
+      maxTokens: this._maxTokens
+    });
+    for await (const chunk of llmStream) {
+      if (!this._running) break;
+      if (chunk.type === "text" && chunk.text) {
+        textChunks.push(chunk.text);
+        fullResponse += chunk.text;
+      } else if (chunk.type === "tool_call" && chunk.toolCall) {
+        await this._handleToolCall(chunk);
+      }
+    }
+    if (fullResponse.trim()) {
+      this._conversation.push({ role: "assistant", content: fullResponse });
+      await this._synthesizeAndSend(fullResponse);
+    }
+  }
+  async _handleToolCall(chunk) {
+    if (!chunk.toolCall || !this._tools) return;
+    const { id, name, arguments: argsStr } = chunk.toolCall;
+    try {
+      const args = JSON.parse(argsStr);
+      const result = await this._tools.call(name, args);
+      this._conversation.push({
+        role: "assistant",
+        content: ""
+        // Tool call info stored in the message flow
+      });
+      this._conversation.push({
+        role: "tool",
+        content: typeof result === "string" ? result : JSON.stringify(result),
+        tool_call_id: id,
+        name
+      });
+      let followUpText = "";
+      const followUpStream = this._llm.generate(this._conversation, {
+        tools: this._tools ?? void 0,
+        temperature: this._temperature,
+        maxTokens: this._maxTokens
+      });
+      for await (const followChunk of followUpStream) {
+        if (!this._running) break;
+        if (followChunk.type === "text" && followChunk.text) {
+          followUpText += followChunk.text;
+        }
+      }
+      if (followUpText.trim()) {
+        this._conversation.push({ role: "assistant", content: followUpText });
+        await this._synthesizeAndSend(followUpText);
+      }
+    } catch (err) {
+      console.error(`[PipelineSession] Tool call error for ${name}:`, err);
+    }
+  }
+  async _synthesizeAndSend(text) {
+    if (!this._callSession || !this._running) return;
+    this._speaking = true;
+    try {
+      for await (const audioChunk of this._tts.synthesize(text, {
+        sampleRate: this._sampleRate
+      })) {
+        if (!this._running || !this._speaking) break;
+        this._callSession.sendAudio(audioChunk);
+      }
+    } catch (err) {
+      console.error("[PipelineSession] TTS error:", err);
+    } finally {
+      this._speaking = false;
+    }
+  }
+};
+
+// src/agent/pipeline/deepgram-stt.ts
+var DeepgramSTT = class {
+  _options;
+  constructor(options = {}) {
+    this._options = {
+      model: "nova-2",
+      language: "ko",
+      interimResults: true,
+      punctuate: true,
+      smartFormat: true,
+      encoding: "linear16",
+      sampleRate: 8e3,
+      channels: 1,
+      ...options
+    };
+  }
+  async *transcribe(audioStream, options) {
+    const apiKey = this._options.apiKey ?? process.env["DEEPGRAM_API_KEY"];
+    if (!apiKey) {
+      throw new Error("Deepgram API key is required");
+    }
+    const language = options?.language ?? this._options.language;
+    const sampleRate = options?.sampleRate ?? this._options.sampleRate;
+    const { WebSocket } = await import('ws');
+    const params = new URLSearchParams({
+      model: this._options.model,
+      language,
+      punctuate: String(this._options.punctuate),
+      interim_results: String(this._options.interimResults),
+      smart_format: String(this._options.smartFormat),
+      encoding: this._options.encoding,
+      sample_rate: String(sampleRate),
+      channels: String(this._options.channels)
+    });
+    const url = `wss://api.deepgram.com/v1/listen?${params.toString()}`;
+    const ws = new WebSocket(url, {
+      headers: { Authorization: `Token ${apiKey}` }
+    });
+    const eventQueue = [];
+    let resolveWait = null;
+    let done = false;
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        const channel = msg["channel"];
+        if (!channel) return;
+        const alternatives = channel["alternatives"];
+        if (!alternatives || alternatives.length === 0) return;
+        const transcript = alternatives[0]["transcript"] ?? "";
+        if (!transcript) return;
+        const isFinal = msg["is_final"];
+        const speechFinal = msg["speech_final"];
+        const event = {
+          type: isFinal || speechFinal ? "final" : "interim",
+          transcript
+        };
+        eventQueue.push(event);
+        if (resolveWait) {
+          resolveWait();
+          resolveWait = null;
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      done = true;
+      if (resolveWait) {
+        resolveWait();
+        resolveWait = null;
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("[DeepgramSTT] WebSocket error:", err.message);
+      done = true;
+      if (resolveWait) {
+        resolveWait();
+        resolveWait = null;
+      }
+    });
+    await new Promise((resolve, reject) => {
+      ws.on("open", resolve);
+      ws.on("error", reject);
+    });
+    const feedPromise = (async () => {
+      try {
+        for await (const chunk of audioStream) {
+          if (done) break;
+          if (ws.readyState === 1) {
+            ws.send(chunk);
+          }
+        }
+      } finally {
+        if (ws.readyState === 1) {
+          ws.send(JSON.stringify({ type: "CloseStream" }));
+        }
+      }
+    })();
+    try {
+      while (!done || eventQueue.length > 0) {
+        if (eventQueue.length > 0) {
+          yield eventQueue.shift();
+        } else if (!done) {
+          await new Promise((resolve) => {
+            resolveWait = resolve;
+          });
+        }
+      }
+    } finally {
+      done = true;
+      ws.close();
+      await feedPromise.catch(() => {
+      });
+    }
+  }
+};
+
+// src/agent/pipeline/elevenlabs-tts.ts
+var ElevenLabsTTS = class {
+  _options;
+  constructor(options = {}) {
+    this._options = {
+      voiceId: "21m00Tcm4TlvDq8ikWAM",
+      modelId: "eleven_multilingual_v2",
+      outputFormat: "pcm_16000",
+      stability: 0.5,
+      similarityBoost: 0.75,
+      style: 0,
+      useSpeakerBoost: true,
+      ...options
+    };
+  }
+  async *synthesize(text, options) {
+    const apiKey = this._options.apiKey ?? process.env["ELEVENLABS_API_KEY"];
+    if (!apiKey) {
+      throw new Error("ElevenLabs API key is required");
+    }
+    const voiceId = options?.voice ?? this._options.voiceId;
+    if (typeof text === "string") {
+      yield* this._synthesizeSingle(apiKey, voiceId, text);
+    } else {
+      yield* this._synthesizeStreaming(apiKey, voiceId, text);
+    }
+  }
+  async *_synthesizeSingle(apiKey, voiceId, text) {
+    const url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}?output_format=${this._options.outputFormat}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "xi-api-key": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        text,
+        model_id: this._options.modelId,
+        voice_settings: {
+          stability: this._options.stability,
+          similarity_boost: this._options.similarityBoost,
+          style: this._options.style,
+          use_speaker_boost: this._options.useSpeakerBoost
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`ElevenLabs API error: ${response.status} ${response.statusText}`);
+    }
+    const body = response.body;
+    if (!body) {
+      throw new Error("ElevenLabs returned empty response");
+    }
+    const reader = body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        yield Buffer.from(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async *_synthesizeStreaming(apiKey, voiceId, textStream) {
+    const { WebSocket } = await import('ws');
+    const url = `wss://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream-input?model_id=${this._options.modelId}&output_format=${this._options.outputFormat}`;
+    const ws = new WebSocket(url);
+    const audioQueue = [];
+    let resolveWait = null;
+    let done = false;
+    ws.on("open", () => {
+      ws.send(
+        JSON.stringify({
+          text: " ",
+          voice_settings: {
+            stability: this._options.stability,
+            similarity_boost: this._options.similarityBoost,
+            style: this._options.style,
+            use_speaker_boost: this._options.useSpeakerBoost
+          },
+          xi_api_key: apiKey
+        })
+      );
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        const audio = msg["audio"];
+        if (audio) {
+          audioQueue.push(Buffer.from(audio, "base64"));
+          if (resolveWait) {
+            resolveWait();
+            resolveWait = null;
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      done = true;
+      if (resolveWait) {
+        resolveWait();
+        resolveWait = null;
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("[ElevenLabsTTS] WebSocket error:", err.message);
+      done = true;
+      if (resolveWait) {
+        resolveWait();
+        resolveWait = null;
+      }
+    });
+    await new Promise((resolve, reject) => {
+      ws.on("open", resolve);
+      ws.on("error", reject);
+    });
+    const feedPromise = (async () => {
+      try {
+        for await (const chunk of textStream) {
+          if (done) break;
+          if (ws.readyState === 1) {
+            ws.send(JSON.stringify({ text: chunk }));
+          }
+        }
+      } finally {
+        if (ws.readyState === 1) {
+          ws.send(JSON.stringify({ text: "" }));
+        }
+      }
+    })();
+    try {
+      while (!done || audioQueue.length > 0) {
+        if (audioQueue.length > 0) {
+          yield audioQueue.shift();
+        } else if (!done) {
+          await new Promise((resolve) => {
+            resolveWait = resolve;
+          });
+        }
+      }
+    } finally {
+      done = true;
+      ws.close();
+      await feedPromise.catch(() => {
+      });
+    }
+  }
+};
+
+// src/agent/pipeline/openai-llm.ts
+var OpenAILLM = class {
+  _options;
+  constructor(options = {}) {
+    this._options = {
+      model: "gpt-4o",
+      ...options
+    };
+  }
+  async *generate(messages, options) {
+    const OpenAI = (await import('openai')).default;
+    const client = new OpenAI({
+      apiKey: this._options.apiKey ?? process.env["OPENAI_API_KEY"]
+    });
+    const requestParams = {
+      model: this._options.model,
+      messages: messages.map((m) => {
+        const msg = { role: m.role, content: m.content };
+        if (m.name) msg["name"] = m.name;
+        if (m.tool_call_id) msg["tool_call_id"] = m.tool_call_id;
+        return msg;
+      }),
+      stream: true,
+      temperature: options?.temperature ?? this._options.temperature,
+      max_tokens: options?.maxTokens ?? this._options.maxTokens
+    };
+    if (options?.tools && options.tools.size > 0) {
+      requestParams["tools"] = options.tools.toOpenAITools();
+    }
+    const stream = await client.chat.completions.create(
+      requestParams
+    );
+    let currentToolCall = null;
+    for await (const chunk of stream) {
+      const choices = chunk["choices"];
+      if (!choices || choices.length === 0) continue;
+      const delta = choices[0]["delta"];
+      if (!delta) continue;
+      const content = delta["content"];
+      if (content) {
+        yield { type: "text", text: content };
+      }
+      const toolCalls = delta["tool_calls"];
+      if (toolCalls) {
+        for (const tc of toolCalls) {
+          const fn = tc["function"];
+          if (fn) {
+            if (fn["name"]) {
+              if (currentToolCall) {
+                yield {
+                  type: "tool_call",
+                  toolCall: {
+                    id: currentToolCall.id,
+                    name: currentToolCall.name,
+                    arguments: currentToolCall.arguments
+                  }
+                };
+              }
+              currentToolCall = {
+                id: tc["id"] ?? "",
+                name: fn["name"],
+                arguments: fn["arguments"] ?? ""
+              };
+            } else if (currentToolCall && fn["arguments"]) {
+              currentToolCall.arguments += fn["arguments"];
+            }
+          }
+        }
+      }
+    }
+    if (currentToolCall) {
+      yield {
+        type: "tool_call",
+        toolCall: {
+          id: currentToolCall.id,
+          name: currentToolCall.name,
+          arguments: currentToolCall.arguments
+        }
+      };
+    }
+    yield { type: "done" };
+  }
+};
+
+// src/agent/pipeline/anthropic-llm.ts
+var AnthropicLLM = class {
+  _options;
+  constructor(options = {}) {
+    this._options = {
+      model: "claude-sonnet-4-20250514",
+      maxTokens: 1024,
+      ...options
+    };
+  }
+  async *generate(messages, options) {
+    const AnthropicModule = await import('@anthropic-ai/sdk');
+    const Anthropic = AnthropicModule.default;
+    const client = new Anthropic({
+      apiKey: this._options.apiKey ?? process.env["ANTHROPIC_API_KEY"]
+    });
+    let systemPrompt;
+    const conversationMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+      } else {
+        conversationMessages.push({
+          role: msg.role === "tool" ? "user" : msg.role,
+          content: msg.role === "tool" ? [
+            {
+              type: "tool_result",
+              tool_use_id: msg.tool_call_id,
+              content: msg.content
+            }
+          ] : msg.content
+        });
+      }
+    }
+    const requestParams = {
+      model: this._options.model,
+      messages: conversationMessages,
+      max_tokens: options?.maxTokens ?? this._options.maxTokens,
+      stream: true
+    };
+    if (systemPrompt) {
+      requestParams["system"] = systemPrompt;
+    }
+    if (options?.temperature ?? this._options.temperature) {
+      requestParams["temperature"] = options?.temperature ?? this._options.temperature;
+    }
+    if (options?.tools && options.tools.size > 0) {
+      const toolDefs = options.tools.toOpenAITools().map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters
+      }));
+      requestParams["tools"] = toolDefs;
+    }
+    const stream = client.messages.stream(
+      requestParams
+    );
+    let currentToolCall = null;
+    for await (const event of stream) {
+      const eventType = event["type"];
+      switch (eventType) {
+        case "content_block_start": {
+          const contentBlock = event["content_block"];
+          if (contentBlock?.["type"] === "tool_use") {
+            currentToolCall = {
+              id: contentBlock["id"],
+              name: contentBlock["name"],
+              arguments: ""
+            };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const delta = event["delta"];
+          if (delta?.["type"] === "text_delta") {
+            yield { type: "text", text: delta["text"] };
+          } else if (delta?.["type"] === "input_json_delta" && currentToolCall) {
+            currentToolCall.arguments += delta["partial_json"] ?? "";
+          }
+          break;
+        }
+        case "content_block_stop": {
+          if (currentToolCall) {
+            yield {
+              type: "tool_call",
+              toolCall: {
+                id: currentToolCall.id,
+                name: currentToolCall.name,
+                arguments: currentToolCall.arguments
+              }
+            };
+            currentToolCall = null;
+          }
+          break;
+        }
+        case "message_stop": {
+          yield { type: "done" };
+          break;
+        }
+      }
+    }
+  }
+};
+
+// src/agent/pipeline/gemini-llm.ts
+var GeminiLLM = class {
+  _options;
+  constructor(options = {}) {
+    this._options = {
+      model: "gemini-2.0-flash",
+      ...options
+    };
+  }
+  async *generate(messages, options) {
+    const { GoogleGenAI } = await import('@google/genai');
+    const client = new GoogleGenAI({
+      apiKey: this._options.apiKey ?? process.env["GOOGLE_API_KEY"]
+    });
+    let systemInstruction;
+    const contents = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemInstruction = msg.content;
+        continue;
+      }
+      const role = msg.role === "assistant" ? "model" : "user";
+      contents.push({
+        role,
+        parts: [{ text: msg.content }]
+      });
+    }
+    const requestConfig = {
+      contents
+    };
+    if (systemInstruction) {
+      requestConfig["systemInstruction"] = { parts: [{ text: systemInstruction }] };
+    }
+    const generationConfig = {};
+    if (options?.temperature ?? this._options.temperature) {
+      generationConfig["temperature"] = options?.temperature ?? this._options.temperature;
+    }
+    if (options?.maxTokens ?? this._options.maxTokens) {
+      generationConfig["maxOutputTokens"] = options?.maxTokens ?? this._options.maxTokens;
+    }
+    if (Object.keys(generationConfig).length > 0) {
+      requestConfig["generationConfig"] = generationConfig;
+    }
+    if (options?.tools && options.tools.size > 0) {
+      const toolDefs = options.tools.toOpenAITools().map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        parameters: t.function.parameters
+      }));
+      requestConfig["tools"] = [{ functionDeclarations: toolDefs }];
+    }
+    const response = await client.models.generateContentStream({
+      model: this._options.model,
+      ...requestConfig
+    });
+    for await (const chunk of response) {
+      const candidates = chunk["candidates"];
+      if (!candidates || candidates.length === 0) continue;
+      const content = candidates[0]?.["content"];
+      const parts = content?.["parts"];
+      if (!parts) continue;
+      for (const part of parts) {
+        if ("text" in part && part["text"]) {
+          yield { type: "text", text: part["text"] };
+        }
+        if ("functionCall" in part && part["functionCall"]) {
+          const fc = part["functionCall"];
+          yield {
+            type: "tool_call",
+            toolCall: {
+              id: `gemini_${Date.now()}`,
+              name: fc.name,
+              arguments: JSON.stringify(fc.args ?? {})
+            }
+          };
+        }
+      }
+    }
+    yield { type: "done" };
+  }
+};
+
+// src/agent/pipeline/openai-compat-llm.ts
+var OpenAICompatLLM = class {
+  _options;
+  constructor(options) {
+    this._options = options;
+  }
+  async *generate(messages, options) {
+    const OpenAI = (await import('openai')).default;
+    const client = new OpenAI({
+      apiKey: this._options.apiKey ?? "not-needed",
+      baseURL: this._options.baseUrl,
+      defaultHeaders: this._options.defaultHeaders
+    });
+    const requestParams = {
+      model: this._options.model,
+      messages: messages.map((m) => {
+        const msg = { role: m.role, content: m.content };
+        if (m.name) msg["name"] = m.name;
+        if (m.tool_call_id) msg["tool_call_id"] = m.tool_call_id;
+        return msg;
+      }),
+      stream: true,
+      temperature: options?.temperature ?? this._options.temperature,
+      max_tokens: options?.maxTokens ?? this._options.maxTokens
+    };
+    if (options?.tools && options.tools.size > 0) {
+      requestParams["tools"] = options.tools.toOpenAITools();
+    }
+    const stream = await client.chat.completions.create(
+      requestParams
+    );
+    let currentToolCall = null;
+    for await (const chunk of stream) {
+      const choices = chunk["choices"];
+      if (!choices || choices.length === 0) continue;
+      const delta = choices[0]["delta"];
+      if (!delta) continue;
+      const content = delta["content"];
+      if (content) {
+        yield { type: "text", text: content };
+      }
+      const toolCalls = delta["tool_calls"];
+      if (toolCalls) {
+        for (const tc of toolCalls) {
+          const fn = tc["function"];
+          if (fn) {
+            if (fn["name"]) {
+              if (currentToolCall) {
+                yield {
+                  type: "tool_call",
+                  toolCall: {
+                    id: currentToolCall.id,
+                    name: currentToolCall.name,
+                    arguments: currentToolCall.arguments
+                  }
+                };
+              }
+              currentToolCall = {
+                id: tc["id"] ?? "",
+                name: fn["name"],
+                arguments: fn["arguments"] ?? ""
+              };
+            } else if (currentToolCall && fn["arguments"]) {
+              currentToolCall.arguments += fn["arguments"];
+            }
+          }
+        }
+      }
+    }
+    if (currentToolCall) {
+      yield {
+        type: "tool_call",
+        toolCall: {
+          id: currentToolCall.id,
+          name: currentToolCall.name,
+          arguments: currentToolCall.arguments
+        }
+      };
+    }
+    yield { type: "done" };
+  }
+};
+
+// src/agent/pipeline/ollama-llm.ts
+var OllamaLLM = class {
+  _inner;
+  constructor(options = {}) {
+    const baseUrl = (options.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
+    this._inner = new OpenAICompatLLM({
+      baseUrl: `${baseUrl}/v1`,
+      model: options.model ?? "llama3.1",
+      apiKey: "ollama",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/mistral-llm.ts
+var MistralLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["MISTRAL_API_KEY"],
+      baseUrl: "https://api.mistral.ai/v1",
+      model: options.model ?? "mistral-small-latest",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/groq-llm.ts
+var GroqLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["GROQ_API_KEY"],
+      baseUrl: "https://api.groq.com/openai/v1",
+      model: options.model ?? "meta-llama/llama-4-scout-17b-16e-instruct",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/perplexity-llm.ts
+var PerplexityLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["PERPLEXITY_API_KEY"],
+      baseUrl: "https://api.perplexity.ai",
+      model: options.model ?? "sonar",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/together-llm.ts
+var TogetherLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["TOGETHER_API_KEY"],
+      baseUrl: "https://api.together.xyz/v1",
+      model: options.model ?? "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/fireworks-llm.ts
+var FireworksLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["FIREWORKS_API_KEY"],
+      baseUrl: "https://api.fireworks.ai/inference/v1",
+      model: options.model ?? "accounts/fireworks/models/llama4-scout-instruct-basic",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/deepseek-llm.ts
+var DeepSeekLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["DEEPSEEK_API_KEY"],
+      baseUrl: "https://api.deepseek.com",
+      model: options.model ?? "deepseek-chat",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/pipeline/xai-llm.ts
+var XaiLLM = class {
+  _inner;
+  constructor(options = {}) {
+    this._inner = new OpenAICompatLLM({
+      apiKey: options.apiKey ?? process.env["XAI_API_KEY"],
+      baseUrl: "https://api.x.ai/v1",
+      model: options.model ?? "grok-4-1-fast",
+      temperature: options.temperature,
+      maxTokens: options.maxTokens
+    });
+  }
+  async *generate(messages, options) {
+    yield* this._inner.generate(messages, options);
+  }
+};
+
+// src/agent/mcp/stdio.ts
+function mcpServerStdio(options) {
+  return {
+    type: "stdio",
+    command: options.command,
+    args: options.args,
+    env: options.env
+  };
+}
+
+// src/agent/mcp/http.ts
+function mcpServerHTTP(options) {
+  return {
+    type: "http",
+    url: options.url,
+    headers: options.headers
+  };
+}
+
+exports.AnthropicLLM = AnthropicLLM;
+exports.AudioRecorder = AudioRecorder;
+exports.CallSession = CallSession;
+exports.ClawOpsAgent = ClawOpsAgent;
+exports.DECODE_TABLE = DECODE_TABLE;
+exports.DeepSeekLLM = DeepSeekLLM;
+exports.DeepgramSTT = DeepgramSTT;
+exports.ElevenLabsTTS = ElevenLabsTTS;
+exports.FireworksLLM = FireworksLLM;
+exports.GeminiLLM = GeminiLLM;
+exports.GeminiRealtime = GeminiRealtime;
+exports.GroqLLM = GroqLLM;
+exports.MCPClient = MCPClient;
+exports.MistralLLM = MistralLLM;
+exports.OllamaLLM = OllamaLLM;
+exports.OpenAICompatLLM = OpenAICompatLLM;
+exports.OpenAILLM = OpenAILLM;
+exports.OpenAIRealtime = OpenAIRealtime;
+exports.PerplexityLLM = PerplexityLLM;
+exports.PipelineSession = PipelineSession;
+exports.TogetherLLM = TogetherLLM;
+exports.ToolRegistry = ToolRegistry;
+exports.XaiLLM = XaiLLM;
+exports.functionTool = functionTool;
+exports.getTracingConfig = getTracingConfig;
+exports.mcpServerHTTP = mcpServerHTTP;
+exports.mcpServerStdio = mcpServerStdio;
+exports.pcm16ToUlaw = pcm16ToUlaw;
+exports.resamplePcm16 = resamplePcm16;
+exports.resetTracingConfig = resetTracingConfig;
+exports.setTracingConfig = setTracingConfig;
+exports.ulawToPcm16 = ulawToPcm16;
+exports.zodToToolParams = zodToToolParams;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map