@teamlearners/clawops 0.1.0 → 0.3.0

package/dist/agent/index.js

@@ -324,13 +324,16 @@ function resamplePcm16(pcm, fromRate, toRate) {
 }
 
 // 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)}`;
+  const scheme = options.baseUrl.startsWith("https") ? "wss" : "ws";
+  const host = options.baseUrl.replace(/^https?:\/\//, "").replace(/\/$/, "");
+  let url = `${scheme}://${host}/v1/accounts/${encodeURIComponent(options.accountId)}/agent/listen`;
+  if (options.number) {
+    url += `?number=${encodeURIComponent(options.number)}`;
+  }
+  return url;
 }
 var ControlWebSocket = class {
   constructor(_options) {
@@ -381,7 +384,12 @@ var ControlWebSocket = class {
   }
   async _doConnect() {
     const { WebSocket } = await import('ws');
-    const ws = new WebSocket(this._url);
+    const ws = new WebSocket(this._url, {
+      followRedirects: true,
+      headers: {
+        Authorization: `Bearer ${this._options.apiKey}`
+      }
+    });
     this._ws = ws;
     ws.on("open", () => {
       this._reconnectDelay = INITIAL_RECONNECT_DELAY;
@@ -524,47 +532,37 @@ var MCPClient = class {
 // src/agent/media-ws.ts
 function parseStartEvent(data) {
   const start = data["start"];
+  const fmt = start["mediaFormat"] ?? {};
   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
-    }
+    streamId: start["streamId"] ?? "",
+    callId: start["callId"] ?? "",
+    accountId: start["accountId"] ?? "",
+    sampleRate: fmt["sampleRate"] ?? 8e3
   };
 }
 function parseMediaEvent(data) {
   const media = data["media"];
   return {
-    track: media["track"] ?? "inbound",
-    chunk: media["chunk"] ?? media["payload"] ?? "",
-    timestamp: media["timestamp"] ?? ""
+    audio: Buffer.from(media["payload"] ?? "", "base64"),
+    timestamp: parseInt(media["timestamp"] ?? "0", 10) || 0
   };
 }
-function buildMediaResponse(streamSid, payload) {
+function buildMediaResponse(audioBase64) {
   return JSON.stringify({
     event: "media",
-    streamSid,
     media: {
-      payload
+      payload: audioBase64
     }
   });
 }
 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;
@@ -577,11 +575,16 @@ var MediaWebSocket = class {
   onClose(handler) {
     this._onClose = handler;
   }
-  /** Connect to a media WebSocket URL. */
-  async connect(url) {
+  /** Connect to a media WebSocket URL with Bearer authentication. */
+  async connect(url, apiKey) {
     const { WebSocket } = await import('ws');
     return new Promise((resolve, reject) => {
-      const ws = new WebSocket(url);
+      const ws = new WebSocket(url, {
+        followRedirects: true,
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
       this._ws = ws;
       this._closed = false;
       ws.on("open", () => {
@@ -616,31 +619,21 @@ var MediaWebSocket = class {
   /** Clear all queued outbound audio. */
   sendClear() {
     this._audioQueue.length = 0;
-    if (this._ws && this._streamSid && this._ws.readyState === 1) {
+    if (this._ws && this._ws.readyState === 1) {
+      this._ws.send(JSON.stringify({ event: "clear" }));
+    }
+  }
+  /** Send a mark event. */
+  sendMark(name) {
+    if (this._ws && this._ws.readyState === 1) {
       this._ws.send(
         JSON.stringify({
-          event: "clear",
-          streamSid: this._streamSid
+          event: "mark",
+          mark: { name }
         })
       );
     }
   }
-  /** 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;
@@ -648,17 +641,12 @@ var MediaWebSocket = class {
       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);
         }
@@ -666,18 +654,8 @@ var MediaWebSocket = class {
       }
       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);
+        if (this._onAudio) {
+          this._onAudio(mediaEvt.audio, mediaEvt.timestamp);
         }
         break;
       }
@@ -697,98 +675,162 @@ var MediaWebSocket = class {
       }
       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));
-        }
+        this._ws.send(buildMediaResponse(payload));
       }
       setTimeout(loop, 20);
     };
     loop();
   }
 };
-var WAV_SAMPLE_RATE = 8e3;
-var WAV_CHANNELS = 1;
-var WAV_BITS_PER_SAMPLE = 16;
-function makeWavHeader(dataSize) {
+var SAMPLE_RATE = 8e3;
+var CHANNELS = 1;
+var BITS_PER_SAMPLE = 16;
+var BYTES_PER_SECOND = SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8);
+function makeWavHeader(dataSize = 0) {
   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.write("RIFF", 0, "ascii");
   header.writeUInt32LE(36 + dataSize, 4);
-  header.write("WAVE", 8);
-  header.write("fmt ", 12);
+  header.write("WAVE", 8, "ascii");
+  header.write("fmt ", 12, "ascii");
   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.writeUInt16LE(CHANNELS, 22);
+  header.writeUInt32LE(SAMPLE_RATE, 24);
+  header.writeUInt32LE(SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8), 28);
+  header.writeUInt16LE(CHANNELS * (BITS_PER_SAMPLE / 8), 32);
+  header.writeUInt16LE(BITS_PER_SAMPLE, 34);
+  header.write("data", 36, "ascii");
   header.writeUInt32LE(dataSize, 40);
   return header;
 }
+function mixSamples(a, b) {
+  const n = Math.min(a.length, b.length) >> 1;
+  const result = Buffer.alloc(n * 2);
+  for (let i = 0; i < n; i++) {
+    const sa = a.readInt16LE(i * 2);
+    const sb = b.readInt16LE(i * 2);
+    result.writeInt16LE(Math.max(-32768, Math.min(32767, sa + sb)), i * 2);
+  }
+  return result;
+}
 var AudioRecorder = class {
-  _outputDir;
-  _sampleRate;
-  _inboundChunks = [];
-  _outboundChunks = [];
-  _callId = null;
+  _dir;
+  _fdIn = null;
+  _fdOut = null;
+  _fdMix = null;
+  _inWritten = 0;
+  _outWritten = 0;
+  _mixWritten = 0;
+  _startTime = 0;
   _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 = [];
+  constructor(recordingPath, callId) {
+    this._dir = path.join(recordingPath, callId);
+  }
+  start() {
+    fs.mkdirSync(this._dir, { recursive: true });
+    const header = makeWavHeader();
+    this._fdIn = fs.openSync(path.join(this._dir, "in.wav"), "w");
+    this._fdOut = fs.openSync(path.join(this._dir, "out.wav"), "w");
+    this._fdMix = fs.openSync(path.join(this._dir, "mix.wav"), "w+");
+    fs.writeSync(this._fdIn, header);
+    fs.writeSync(this._fdOut, header);
+    fs.writeSync(this._fdMix, header);
+    this._startTime = performance.now();
     this._started = true;
-    if (!fs.existsSync(this._outputDir)) {
-      fs.mkdirSync(this._outputDir, { recursive: true });
+  }
+  _expectedBytes() {
+    const elapsed = (performance.now() - this._startTime) / 1e3;
+    return Math.floor(elapsed * BYTES_PER_SECOND);
+  }
+  _padSilence(fd, written) {
+    const expected = this._expectedBytes();
+    let gap = expected - written;
+    if (gap <= 0) return 0;
+    gap = gap - gap % 2;
+    if (gap > 0) {
+      fs.writeSync(fd, Buffer.alloc(gap));
+    }
+    return gap;
+  }
+  _writeToMix(data, trackPos) {
+    if (this._fdMix === null) return;
+    const filePos = 44 + trackPos;
+    if (trackPos < this._mixWritten) {
+      const overlap = Math.min(data.length, this._mixWritten - trackPos);
+      const existing = Buffer.alloc(overlap);
+      fs.readSync(this._fdMix, existing, 0, overlap, filePos);
+      const mixed = mixSamples(existing, data.subarray(0, overlap));
+      fs.writeSync(this._fdMix, mixed, 0, mixed.length, filePos);
+      if (data.length > overlap) {
+        fs.writeSync(this._fdMix, data, overlap, data.length - overlap, filePos + overlap);
+        this._mixWritten = trackPos + data.length;
+      }
+    } else {
+      if (trackPos > this._mixWritten) {
+        let gap = trackPos - this._mixWritten;
+        gap = gap - gap % 2;
+        if (gap > 0) {
+          const silence = Buffer.alloc(gap);
+          fs.writeSync(this._fdMix, silence, 0, silence.length, 44 + this._mixWritten);
+          this._mixWritten += gap;
+        }
+      }
+      fs.writeSync(this._fdMix, data, 0, data.length, 44 + this._mixWritten);
+      this._mixWritten += data.length;
     }
   }
-  /** Write inbound (caller) PCM16 audio. */
-  writeInbound(pcm) {
-    if (this._started) {
-      this._inboundChunks.push(Buffer.from(pcm));
+  writeInbound(pcm16_8k) {
+    if (!this._started || this._fdIn === null) return;
+    try {
+      const gap = this._padSilence(this._fdIn, this._inWritten);
+      this._inWritten += gap;
+      const posBefore = this._inWritten;
+      fs.writeSync(this._fdIn, pcm16_8k);
+      this._inWritten += pcm16_8k.length;
+      this._writeToMix(pcm16_8k, posBefore);
+    } catch (err) {
+      console.error("Error writing inbound audio:", err);
     }
   }
-  /** Write raw outbound (agent) PCM16 audio. */
-  writeRawOutbound(pcm) {
-    if (this._started) {
-      this._outboundChunks.push(Buffer.from(pcm));
+  writeOutbound(pcm16_8k) {
+    if (!this._started || this._fdOut === null) return;
+    try {
+      const gap = this._padSilence(this._fdOut, this._outWritten);
+      this._outWritten += gap;
+      const posBefore = this._outWritten;
+      fs.writeSync(this._fdOut, pcm16_8k);
+      this._outWritten += pcm16_8k.length;
+      this._writeToMix(pcm16_8k, posBefore);
+    } catch (err) {
+      console.error("Error writing outbound audio:", err);
     }
   }
-  /** 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.join(this._outputDir, `${this._callId}_inbound.wav`);
-      this._writeWav(inboundPath, this._inboundChunks);
-      result.inbound = inboundPath;
-    }
-    if (this._outboundChunks.length > 0) {
-      const outboundPath = path.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.openSync(filePath, "w");
-    fs.writeSync(fd, header);
-    fs.writeSync(fd, pcmData);
-    fs.closeSync(fd);
+    if (!this._started) return;
+    try {
+      let maxWritten = Math.max(this._inWritten, this._outWritten, this._mixWritten);
+      maxWritten = maxWritten & ~1;
+      for (const [fd, written] of [
+        [this._fdIn, this._inWritten],
+        [this._fdOut, this._outWritten],
+        [this._fdMix, this._mixWritten]
+      ]) {
+        if (fd === null) continue;
+        const pad = maxWritten - written;
+        if (pad > 0) {
+          fs.writeSync(fd, Buffer.alloc(pad), 0, pad, 44 + written);
+        }
+        fs.writeSync(fd, makeWavHeader(maxWritten), 0, 44, 0);
+        fs.closeSync(fd);
+      }
+    } catch (err) {
+      console.error("Error stopping recorder:", err);
+    } finally {
+      this._fdIn = null;
+      this._fdOut = null;
+      this._fdMix = null;
+      this._started = false;
+    }
   }
 };
 
@@ -868,23 +910,23 @@ var CallSession = class {
   /** 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);
+  /** Emit an event to registered handlers. Matches Python SDK: _emit(event, ...args) */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  _emit(event, ...args) {
+    const handlers = this._handlers.get(event);
     if (handlers) {
       for (const handler of handlers) {
         try {
-          const result = handler(event);
+          const result = handler(this, ...args);
           if (result && typeof result.catch === "function") {
             result.catch((err) => {
-              console.error(`[CallSession] Error in ${event.type} handler:`, err);
+              console.error(`[CallSession] Error in ${event} handler:`, err);
             });
           }
         } catch (err) {
-          console.error(`[CallSession] Error in ${event.type} handler:`, err);
+          console.error(`[CallSession] Error in ${event} handler:`, err);
         }
       }
     }
@@ -1088,44 +1130,61 @@ var ATTR_AGENT_ID = "clawops.agent.id";
 // src/agent/agent.ts
 var ClawOpsAgent = class {
   _apiKey;
-  _agentId;
+  _accountId;
   _baseUrl;
-  _sessionFactory = null;
+  _fromNumber;
+  _session;
   _tools = new ToolRegistry();
   _handlers = /* @__PURE__ */ new Map();
   _controlWs = null;
-  _mcpClient = null;
-  _recordingDir;
+  _mcpServers;
+  _recording;
+  _recordingPath;
   _activeSessions = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
+  constructor(options) {
     this._apiKey = options.apiKey ?? process.env["CLAWOPS_API_KEY"] ?? "";
-    this._agentId = options.agentId ?? process.env["CLAWOPS_AGENT_ID"] ?? "";
+    this._accountId = options.accountId ?? process.env["CLAWOPS_ACCOUNT_ID"] ?? "";
     this._baseUrl = options.baseUrl ?? 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);
-      }
-    }
+    this._fromNumber = options.from;
+    this._session = options.session;
+    this._recording = options.recording ?? false;
+    this._recordingPath = options.recordingPath ?? "./recordings";
+    this._mcpServers = options.mcpServers ?? [];
     if (options.tracing) {
       setTracingConfig(options.tracing);
     }
   }
-  /** Register a function tool. */
-  tool(tool) {
-    this._tools.register(tool);
+  /**
+   * Register a function tool.
+   *
+   * Supports two signatures (matching Python SDK):
+   *   agent.tool(name, description, parameters, handler)
+   *   agent.tool(functionToolObject)
+   */
+  tool(nameOrTool, description, parameters, handler) {
+    if (typeof nameOrTool === "string") {
+      if (!description || !parameters || !handler) {
+        throw new AgentError("tool(name, description, parameters, handler) requires all arguments.");
+      }
+      this._tools.register({
+        name: nameOrTool,
+        description,
+        parameters,
+        required: Object.keys(parameters),
+        handler
+      });
+    } else {
+      this._tools.register(nameOrTool);
+    }
     return this;
   }
-  /** Register an event handler. */
+  /**
+   * Register an event handler.
+   *
+   * Matches Python SDK decorator style:
+   *   agent.on("call_start", (call) => { ... })
+   *   agent.on("transcript", (call, role, text) => { ... })
+   */
   on(event, handler) {
     let list = this._handlers.get(event);
     if (!list) {
@@ -1140,21 +1199,14 @@ var ClawOpsAgent = class {
     if (!this._apiKey) {
       throw new AgentError("API key is required. Set CLAWOPS_API_KEY or pass apiKey option.");
     }
-    if (!this._agentId) {
-      throw new 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);
-      }
+    if (!this._accountId) {
+      throw new AgentError("Account ID is required. Set CLAWOPS_ACCOUNT_ID or pass accountId option.");
     }
     this._controlWs = new ControlWebSocket({
       baseUrl: this._baseUrl,
       apiKey: this._apiKey,
-      agentId: this._agentId
+      accountId: this._accountId,
+      number: this._fromNumber
     });
     this._controlWs.on("call.incoming", (event) => this._handleIncoming(event));
     this._controlWs.on("call.ended", (event) => this._handleEnded(event));
@@ -1169,6 +1221,7 @@ var ClawOpsAgent = class {
         `Failed to connect to ClawOps: ${err instanceof Error ? err.message : String(err)}`
       );
     }
+    console.log(`[ClawOpsAgent] Connected on ${this._fromNumber}`);
   }
   /**
    * Connect and block until disconnected.
@@ -1194,83 +1247,118 @@ var ClawOpsAgent = class {
       session._markEnded();
     }
     this._activeSessions.clear();
-    if (this._mcpClient) {
-      await this._mcpClient.disconnect();
-      this._tools.clearMcpTools();
-    }
+    console.log("[ClawOpsAgent] Disconnected");
   }
   /**
    * Initiate an outbound call.
+   * Matches Python SDK: agent.call(to, { timeout })
    */
-  call(options) {
-    if (!this._controlWs) {
-      throw new 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
-      }
+  async call(to, options) {
+    await this.connect();
+    const url = `${this._baseUrl}/v1/accounts/${this._accountId}/calls`;
+    const body = { To: to, From: this._fromNumber, Timeout: options?.timeout ?? 60 };
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this._apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (resp.status !== 201) {
+      const error = await resp.json();
+      throw new AgentError(`\uBC1C\uC2E0 \uC2E4\uD328 (${resp.status}): ${error["error"] ?? ""}`);
+    }
+    const data = await resp.json();
+    const callSession = new CallSession({
+      callId: data["callId"],
+      fromNumber: this._fromNumber,
+      toNumber: to,
+      accountId: this._accountId,
+      direction: "outbound"
     });
+    for (const [evt, handlers] of this._handlers) {
+      for (const handler of handlers) {
+        callSession.on(evt, handler);
+      }
+    }
+    this._activeSessions.set(callSession.callId, callSession);
+    console.log(`[ClawOpsAgent] Outbound call initiated: ${this._fromNumber} -> ${to} (${callSession.callId})`);
+    return callSession;
   }
   _handleIncoming(event) {
-    const data = event.data;
+    const callId = event["callId"];
+    const fromNumber = event["from"] ?? "";
+    const mediaUrl = event["mediaUrl"] ?? "";
     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
+      callId,
+      fromNumber,
+      toNumber: this._fromNumber,
+      accountId: this._accountId,
+      direction: "inbound"
     });
-    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);
+    for (const [evt, handlers] of this._handlers) {
+      for (const handler of handlers) {
+        session.on(evt, handler);
+      }
+    }
+    this._activeSessions.set(callId, session);
+    if (this._controlWs) {
+      this._controlWs.send({ event: "call.accept", callId });
+    }
+    if (mediaUrl) {
+      this._startCallSession(session, mediaUrl).catch((err) => {
+        console.error(`[ClawOpsAgent] Error in call session ${callId}:`, err);
       });
     }
   }
   _handleEnded(event) {
-    const session = this._activeSessions.get(event.data.call_id);
+    const callId = event["callId"];
+    const session = this._activeSessions.get(callId);
     if (session) {
       session._markEnded();
-      this._activeSessions.delete(event.data.call_id);
-      this._emitEvent("call.ended", session);
+      this._activeSessions.delete(callId);
     }
   }
   _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);
+    const callId = event["callId"];
+    const mediaUrl = event["mediaUrl"] ?? "";
+    let session = this._activeSessions.get(callId);
+    if (!session) {
+      session = new CallSession({
+        callId,
+        fromNumber: this._fromNumber,
+        toNumber: event["to"] ?? "",
+        accountId: this._accountId,
+        direction: "outbound"
+      });
+      for (const [evt, handlers] of this._handlers) {
+        for (const handler of handlers) {
+          session.on(evt, handler);
+        }
+      }
+      this._activeSessions.set(callId, session);
+    }
+    if (mediaUrl) {
+      this._startCallSession(session, mediaUrl).catch((err) => {
+        console.error(`[ClawOpsAgent] Error in call session ${callId}:`, err);
       });
     }
   }
   _handleRinging(event) {
-    const session = this._activeSessions.get(event.data.call_id);
+    const callId = event["callId"];
+    const session = this._activeSessions.get(callId);
     if (session) {
-      this._emitEvent("call.ringing", session);
+      console.log(`[ClawOpsAgent] Outbound call ringing: ${callId}`);
     }
   }
   _handleFailed(event) {
-    const session = this._activeSessions.get(event.data.call_id);
+    const callId = event["callId"];
+    const session = this._activeSessions.get(callId);
     if (session) {
+      session._emit("call_failed", event["reason"] ?? "failed");
       session._markEnded();
-      this._activeSessions.delete(event.data.call_id);
-      this._emitEvent("call.failed", session);
+      this._activeSessions.delete(callId);
     }
   }
   async _startCallSession(session, mediaWsUrl) {
@@ -1279,23 +1367,33 @@ var ClawOpsAgent = class {
       {
         [ATTR_CALL_ID]: session.callId,
         [ATTR_CALL_DIRECTION]: session.direction,
-        [ATTR_AGENT_ID]: this._agentId
+        [ATTR_AGENT_ID]: this._accountId
       },
       async () => {
         const sessionTools = this._tools.fork();
+        const mcpClients = [];
+        if (this._mcpServers.length > 0) {
+          for (const serverConfig of this._mcpServers) {
+            const client = new MCPClient();
+            client.addServer("mcp", serverConfig);
+            try {
+              const tools = await client.connect();
+              sessionTools.registerMcpTools(tools);
+              mcpClients.push(client);
+            } catch (err) {
+              console.error("[ClawOpsAgent] MCP connection error:", err);
+            }
+          }
+        }
         let recorder = null;
-        if (this._recordingDir) {
-          recorder = new AudioRecorder({ outputDir: this._recordingDir });
-          recorder.start(session.callId);
+        if (this._recording) {
+          recorder = new AudioRecorder(this._recordingPath, session.callId);
+          recorder.start();
         }
         const mediaWs = new MediaWebSocket();
         session._bindTransport(
           (audio) => {
-            const ulaw = pcm16ToUlaw(audio);
-            mediaWs.sendAudio(ulaw.toString("base64"));
-            if (recorder) {
-              recorder.writeRawOutbound(audio);
-            }
+            mediaWs.sendAudio(audio.toString("base64"));
           },
           () => {
             mediaWs.sendClear();
@@ -1304,15 +1402,19 @@ var ClawOpsAgent = class {
             mediaWs.close();
           }
         );
-        const sessionHandler = this._sessionFactory ? this._sessionFactory() : null;
-        mediaWs.onAudio((ulawAudio) => {
-          const pcm = ulawToPcm16(ulawAudio);
-          if (recorder) {
-            recorder.writeInbound(pcm);
-          }
+        const sessionHandler = this._session;
+        if ("setToolRegistry" in sessionHandler && typeof sessionHandler.setToolRegistry === "function") {
+          sessionHandler.setToolRegistry(sessionTools);
+        }
+        if (recorder && "setRecorder" in sessionHandler && typeof sessionHandler.setRecorder === "function") {
+          sessionHandler.setRecorder(recorder);
+        }
+        mediaWs.onAudio((ulawAudio, _timestamp) => {
           if (sessionHandler) {
-            const resampled = resamplePcm16(pcm, 8e3, 16e3);
-            sessionHandler.feedAudio(resampled);
+            sessionHandler.feedAudio(ulawAudio);
+          }
+          if (recorder) {
+            recorder.writeInbound(ulawToPcm16(ulawAudio));
           }
         });
         mediaWs.onClose(() => {
@@ -1321,74 +1423,93 @@ var ClawOpsAgent = class {
           }
           session._markEnded();
         });
+        session._emit("call_start");
         try {
-          await mediaWs.connect(mediaWsUrl);
-          if (sessionHandler) {
-            await sessionHandler.start(session, sessionTools);
-          }
+          await mediaWs.connect(mediaWsUrl, this._apiKey);
+          await sessionHandler.start(session, sessionTools);
           await session.wait();
-          if (sessionHandler) {
-            await sessionHandler.stop();
-          }
+          await sessionHandler.stop();
         } catch (err) {
           console.error(`[ClawOpsAgent] Call session error:`, err);
         } finally {
+          if (mcpClients.length > 0) {
+            sessionTools.clearMcpTools();
+            for (const c of mcpClients) {
+              await c.disconnect();
+            }
+          }
           mediaWs.close();
           if (recorder) {
             recorder.stop();
           }
+          session._emit("call_end");
+          session._markEnded();
+          this._activeSessions.delete(session.callId);
         }
       }
     );
   }
-  _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 OPENAI_REALTIME_URL = "wss://api.openai.com/v1/realtime?model=";
+var HANG_UP_TOOL = {
+  type: "function",
+  name: "hang_up",
+  description: "End the phone call. Use when the conversation is finished or the caller says goodbye.",
+  parameters: { type: "object", properties: {}, required: [] }
+};
 var OpenAIRealtime = class {
-  _options;
+  _apiKey;
+  _systemPrompt;
+  _model;
+  _voice;
+  _language;
+  _eagerness;
+  _greeting;
   _ws = null;
-  _callSession = null;
+  _call = null;
   _tools = null;
+  _recorder = null;
   _closed = false;
+  // Truncation / barge-in tracking (matching Python SDK)
+  _lastAssistantItem = null;
+  _responseStartTs = null;
+  _sentAudioChunks = 0;
+  _audioRemainder = Buffer.alloc(0);
   constructor(options = {}) {
-    this._options = {
-      model: "gpt-4o-realtime-preview",
-      voice: "alloy",
-      inputAudioFormat: "pcm16",
-      outputAudioFormat: "pcm16",
-      ...options
-    };
+    this._apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"] ?? "";
+    this._systemPrompt = options.systemPrompt ?? "";
+    this._model = options.model ?? "gpt-realtime-1.5";
+    this._voice = options.voice ?? "marin";
+    this._language = options.language ?? "ko";
+    this._eagerness = options.eagerness ?? "high";
+    this._greeting = options.greeting ?? true;
+  }
+  /** Inject per-call ToolRegistry. */
+  setToolRegistry(registry) {
+    this._tools = registry;
+  }
+  /** Inject per-call AudioRecorder. */
+  setRecorder(recorder) {
+    this._recorder = recorder;
   }
   async start(callSession, tools) {
-    this._callSession = callSession;
-    this._tools = tools ?? null;
+    this._call = callSession;
+    if (tools) this._tools = tools;
     this._closed = false;
-    const apiKey = this._options.apiKey ?? process.env["OPENAI_API_KEY"];
-    if (!apiKey) {
-      throw new Error("OpenAI API key is required");
+    this._lastAssistantItem = null;
+    this._responseStartTs = null;
+    this._sentAudioChunks = 0;
+    this._audioRemainder = Buffer.alloc(0);
+    if (!this._apiKey) {
+      throw new Error("OpenAI API key is required. Set OPENAI_API_KEY or pass apiKey option.");
     }
     const { WebSocket } = await import('ws');
-    const url = `wss://api.openai.com/v1/realtime?model=${this._options.model}`;
+    const url = `${OPENAI_REALTIME_URL}${this._model}`;
     this._ws = new WebSocket(url, {
       headers: {
-        Authorization: `Bearer ${apiKey}`,
+        Authorization: `Bearer ${this._apiKey}`,
         "OpenAI-Beta": "realtime=v1"
       }
     });
@@ -1396,6 +1517,9 @@ var OpenAIRealtime = class {
       const ws = this._ws;
       ws.on("open", () => {
         this._sendSessionUpdate();
+        if (this._greeting) {
+          this._send({ type: "response.create" });
+        }
         resolve();
       });
       ws.on("message", (data) => {
@@ -1418,12 +1542,10 @@ var OpenAIRealtime = class {
   }
   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")
-        })
-      );
+      this._send({
+        type: "input_audio_buffer.append",
+        audio: audio.toString("base64")
+      });
     }
   }
   async stop() {
@@ -1435,52 +1557,71 @@ var OpenAIRealtime = class {
   }
   _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
-      })
-    );
+    const toolSchemas = this._tools ? this._tools.toOpenAITools().map((t) => ({ type: "function", ...t.function })) : [];
+    toolSchemas.push(HANG_UP_TOOL);
+    this._send({
+      type: "session.update",
+      session: {
+        modalities: ["text", "audio"],
+        voice: this._voice,
+        instructions: this._systemPrompt,
+        input_audio_format: "g711_ulaw",
+        output_audio_format: "g711_ulaw",
+        input_audio_transcription: {
+          model: "gpt-4o-mini-transcribe",
+          language: this._language
+        },
+        input_audio_noise_reduction: { type: "far_field" },
+        turn_detection: {
+          type: "semantic_vad",
+          interrupt_response: true,
+          eagerness: this._eagerness
+        },
+        tools: toolSchemas
+      }
+    });
   }
   _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);
-        }
+        this._handleAudioDelta(msg);
         break;
       }
       case "response.audio.done": {
+        if (this._audioRemainder.length > 0) {
+          const padded = Buffer.concat([
+            this._audioRemainder,
+            Buffer.alloc(160 - this._audioRemainder.length, 255)
+          ]);
+          if (this._call) {
+            this._call.sendAudio(padded);
+          }
+          this._sentAudioChunks++;
+          this._audioRemainder = Buffer.alloc(0);
+        }
         break;
       }
-      case "response.function_call_arguments.done": {
-        this._handleFunctionCall(msg);
+      case "input_audio_buffer.speech_started": {
+        this._handleTruncation();
         break;
       }
-      case "input_audio_buffer.speech_started": {
-        if (this._callSession) {
-          this._callSession.clearAudio();
+      case "response.output_item.done": {
+        const item = msg["item"];
+        if (item && item["type"] === "function_call") {
+          this._handleToolCall(item);
+        }
+        break;
+      }
+      case "conversation.item.input_audio_transcription.completed": {
+        if (this._call) {
+          this._call._emit("transcript", "user", msg["transcript"] ?? "");
+        }
+        break;
+      }
+      case "response.audio_transcript.done": {
+        if (this._call) {
+          this._call._emit("transcript", "assistant", msg["transcript"] ?? "");
         }
         break;
       }
@@ -1490,73 +1631,147 @@ var OpenAIRealtime = class {
       }
     }
   }
-  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}`);
+  _handleAudioDelta(msg) {
+    if (this._responseStartTs === null) {
+      this._responseStartTs = Date.now();
+      this._sentAudioChunks = 0;
+    }
+    if (msg["item_id"]) {
+      this._lastAssistantItem = msg["item_id"];
+    }
+    const ulaw = Buffer.from(msg["delta"], "base64");
+    if (this._recorder) {
+      this._recorder.writeOutbound(ulawToPcm16(ulaw));
+    }
+    const combined = Buffer.concat([this._audioRemainder, ulaw]);
+    const chunkSize = 160;
+    const fullEnd = Math.floor(combined.length / chunkSize) * chunkSize;
+    for (let off = 0; off < fullEnd; off += chunkSize) {
+      if (this._call) {
+        this._call.sendAudio(combined.subarray(off, off + chunkSize));
+      }
+      this._sentAudioChunks++;
+    }
+    this._audioRemainder = combined.subarray(fullEnd);
+  }
+  _handleTruncation() {
+    if (!this._lastAssistantItem || this._responseStartTs === null) {
       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" }));
+    const audioEndMs = Math.max(0, this._sentAudioChunks * 20);
+    this._send({
+      type: "conversation.item.truncate",
+      item_id: this._lastAssistantItem,
+      content_index: 0,
+      audio_end_ms: audioEndMs
+    });
+    if (this._call) {
+      this._call.clearAudio();
+    }
+    this._lastAssistantItem = null;
+    this._responseStartTs = null;
+    this._sentAudioChunks = 0;
+    this._audioRemainder = Buffer.alloc(0);
+  }
+  async _handleToolCall(item) {
+    const funcName = item["name"];
+    const callId = item["call_id"];
+    if (funcName === "hang_up") {
+      if (this._call) {
+        this._call.hangup();
       }
+      return;
+    }
+    if (!this._tools || !this._tools.has(funcName)) {
+      console.error(`[OpenAIRealtime] Unknown tool: ${funcName}`);
+      return;
+    }
+    let result;
+    try {
+      const args = JSON.parse(item["arguments"] ?? "{}");
+      result = await this._tools.call(funcName, args);
     } catch (err) {
-      console.error(`[OpenAIRealtime] Tool call error for ${name}:`, err);
+      console.error(`[OpenAIRealtime] Tool call failed: ${funcName}:`, err);
+      result = `Error: ${err}`;
+    }
+    this._send({
+      type: "conversation.item.create",
+      item: {
+        type: "function_call_output",
+        call_id: callId,
+        output: typeof result === "string" ? result : JSON.stringify(result)
+      }
+    });
+    this._send({ type: "response.create" });
+  }
+  _send(data) {
+    if (this._ws && this._ws.readyState === 1 && !this._closed) {
+      this._ws.send(JSON.stringify(data));
     }
   }
 };
 
 // src/agent/pipeline/gemini-realtime.ts
+var HANG_UP_TOOL2 = {
+  name: "hang_up",
+  description: "End the phone call. Use when the conversation is finished or the caller says goodbye.",
+  parameters: { type: "object", properties: {} }
+};
 var GeminiRealtime = class {
-  _options;
+  _apiKey;
+  _systemPrompt;
+  _model;
+  _voice;
+  _language;
+  _greeting;
+  _generationConfig;
   _ws = null;
-  _callSession = null;
+  _call = null;
   _tools = null;
+  _recorder = null;
   _closed = false;
+  _sentAudioChunks = 0;
+  _audioRemainder = Buffer.alloc(0);
   constructor(options = {}) {
-    this._options = {
-      model: "gemini-2.0-flash-exp",
-      ...options
-    };
+    this._apiKey = options.apiKey ?? process.env["GOOGLE_API_KEY"] ?? "";
+    this._systemPrompt = options.systemPrompt ?? "";
+    this._model = options.model ?? "gemini-2.5-flash-native-audio-preview-12-2025";
+    this._voice = options.voice ?? "Kore";
+    this._language = options.language ?? "ko";
+    this._greeting = options.greeting ?? true;
+    this._generationConfig = options.generationConfig;
+  }
+  /** Inject per-call ToolRegistry. */
+  setToolRegistry(registry) {
+    this._tools = registry;
+  }
+  /** Inject per-call AudioRecorder. */
+  setRecorder(recorder) {
+    this._recorder = recorder;
   }
   async start(callSession, tools) {
-    this._callSession = callSession;
-    this._tools = tools ?? null;
+    this._call = callSession;
+    if (tools) this._tools = tools;
     this._closed = false;
-    const apiKey = this._options.apiKey ?? process.env["GOOGLE_API_KEY"];
-    if (!apiKey) {
-      throw new Error("Google API key is required");
+    this._sentAudioChunks = 0;
+    this._audioRemainder = Buffer.alloc(0);
+    if (!this._apiKey) {
+      throw new Error("Google API key is required. Set GOOGLE_API_KEY or pass apiKey option.");
     }
     const { WebSocket } = await import('ws');
-    this._options.model;
-    const url = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent?key=${apiKey}`;
+    const url = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent?key=${this._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 {
-        }
+        this._waitSetupComplete().then(() => {
+          if (this._greeting) {
+            this._sendGreeting();
+          }
+          this._receiveLoop();
+          resolve();
+        }).catch(reject);
       });
       ws.on("close", () => {
         this._closed = true;
@@ -1571,13 +1786,15 @@ var GeminiRealtime = class {
   }
   feedAudio(audio) {
     if (this._ws && this._ws.readyState === 1 && !this._closed) {
+      const pcm8k = ulawToPcm16(audio);
+      const pcm16k = resamplePcm16(pcm8k, 8e3, 16e3);
       this._ws.send(
         JSON.stringify({
           realtimeInput: {
             mediaChunks: [
               {
                 mimeType: "audio/pcm;rate=16000",
-                data: audio.toString("base64")
+                data: pcm16k.toString("base64")
               }
             ]
           }
@@ -1595,35 +1812,85 @@ var GeminiRealtime = class {
   _sendSetup() {
     if (!this._ws || this._ws.readyState !== 1) return;
     const setupConfig = {
-      model: `models/${this._options.model}`,
+      model: `models/${this._model}`,
       generationConfig: {
         responseModalities: ["AUDIO"],
         speechConfig: {
           voiceConfig: {
             prebuiltVoiceConfig: {
-              voiceName: this._options.voice ?? "Aoede"
+              voiceName: this._voice
             }
           }
         },
-        ...this._options.generationConfig
+        ...this._generationConfig
+      },
+      realtimeInputConfig: {
+        automaticActivityDetection: {
+          disabled: false
+        }
       }
     };
-    if (this._options.systemInstruction) {
+    if (this._systemPrompt) {
       setupConfig["systemInstruction"] = {
-        parts: [{ text: this._options.systemInstruction }]
+        parts: [{ text: this._systemPrompt }]
       };
     }
-    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 }];
-    }
+    const toolDefs = this._tools ? this._tools.toOpenAITools().map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
+    })) : [];
+    toolDefs.push(HANG_UP_TOOL2);
+    setupConfig["tools"] = [{ functionDeclarations: toolDefs }];
     this._ws.send(JSON.stringify({ setup: setupConfig }));
   }
+  _waitSetupComplete() {
+    return new Promise((resolve, reject) => {
+      if (!this._ws) {
+        reject(new Error("WebSocket not connected"));
+        return;
+      }
+      const onMessage = (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if ("setupComplete" in msg) {
+            this._ws?.removeListener("message", onMessage);
+            resolve();
+          }
+        } catch {
+        }
+      };
+      this._ws.on("message", onMessage);
+    });
+  }
+  _sendGreeting() {
+    if (!this._ws || this._ws.readyState !== 1) return;
+    this._ws.send(
+      JSON.stringify({
+        clientContent: {
+          turns: [
+            {
+              role: "user",
+              parts: [{ text: "\uC778\uC0AC\uD574 \uC8FC\uC138\uC694." }]
+            }
+          ],
+          turnComplete: true
+        }
+      })
+    );
+  }
+  _receiveLoop() {
+    if (!this._ws) return;
+    this._ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        this._handleMessage(msg);
+      } catch {
+      }
+    });
+  }
   _handleMessage(msg) {
+    if (!this._call) return;
     const serverContent = msg["serverContent"];
     if (serverContent) {
       const modelTurn = serverContent["modelTurn"];
@@ -1632,35 +1899,108 @@ var GeminiRealtime = class {
         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);
+            if (inlineData && inlineData["data"]) {
+              const mimeType = inlineData["mimeType"] ?? "";
+              if (mimeType.includes("audio")) {
+                this._handleAudioData(inlineData["data"]);
+              }
+            }
+            const text = part["text"];
+            if (text && this._call) {
+              this._call._emit("transcript", "assistant", text);
             }
           }
         }
       }
+      if (serverContent["turnComplete"]) {
+        this._flushAudioRemainder();
+      }
+      if (serverContent["interrupted"]) {
+        if (this._call) {
+          this._call.clearAudio();
+        }
+        this._sentAudioChunks = 0;
+        this._audioRemainder = Buffer.alloc(0);
+      }
+    }
+    const inputTranscription = msg["inputTranscription"];
+    if (inputTranscription) {
+      const text = inputTranscription["text"];
+      if (text && this._call) {
+        this._call._emit("transcript", "user", text);
+      }
+    }
+    const outputTranscription = msg["outputTranscription"];
+    if (outputTranscription) {
+      const text = outputTranscription["text"];
+      if (text && this._call) {
+        this._call._emit("transcript", "assistant", text);
+      }
     }
     const toolCall = msg["toolCall"];
     if (toolCall) {
       this._handleToolCall(toolCall);
     }
+    if (msg["toolCallCancellation"]) ;
+  }
+  _handleAudioData(b64Data) {
+    if (!this._call) return;
+    const pcm24k = Buffer.from(b64Data, "base64");
+    if (this._recorder) {
+      this._recorder.writeOutbound(resamplePcm16(pcm24k, 24e3, 8e3));
+    }
+    const pcm8k = resamplePcm16(pcm24k, 24e3, 8e3);
+    const ulaw = pcm16ToUlaw(pcm8k);
+    const combined = Buffer.concat([this._audioRemainder, ulaw]);
+    const chunkSize = 160;
+    const fullEnd = Math.floor(combined.length / chunkSize) * chunkSize;
+    for (let off = 0; off < fullEnd; off += chunkSize) {
+      this._call.sendAudio(combined.subarray(off, off + chunkSize));
+      this._sentAudioChunks++;
+    }
+    this._audioRemainder = combined.subarray(fullEnd);
+  }
+  _flushAudioRemainder() {
+    if (this._audioRemainder.length > 0 && this._call) {
+      const padded = Buffer.concat([
+        this._audioRemainder,
+        Buffer.alloc(160 - this._audioRemainder.length, 255)
+      ]);
+      this._call.sendAudio(padded);
+      this._sentAudioChunks++;
+      this._audioRemainder = Buffer.alloc(0);
+    }
   }
   async _handleToolCall(toolCall) {
     const functionCalls = toolCall["functionCalls"];
-    if (!functionCalls || !this._tools) return;
+    if (!functionCalls) return;
     const responses = [];
     for (const fc of functionCalls) {
       const name = fc["name"];
+      const fcId = fc["id"] ?? "";
       const args = fc["args"] ?? {};
+      if (name === "hang_up") {
+        if (this._call) {
+          this._call.hangup();
+        }
+        return;
+      }
+      if (!this._tools || !this._tools.has(name)) {
+        console.error(`[GeminiRealtime] Unknown tool: ${name}`);
+        responses.push({ id: fcId, name, response: { error: `Unknown tool: ${name}` } });
+        continue;
+      }
       try {
         const result = await this._tools.call(name, args);
         responses.push({
+          id: fcId,
           name,
           response: { result: typeof result === "string" ? result : JSON.stringify(result) }
         });
       } catch (err) {
         console.error(`[GeminiRealtime] Tool call error for ${name}:`, err);
         responses.push({
+          id: fcId,
           name,
           response: { error: String(err) }
         });
@@ -1684,12 +2024,15 @@ var PipelineSession = class {
   _llm;
   _tts;
   _systemPrompt;
+  _greeting;
+  _language;
   _temperature;
   _maxTokens;
   _sampleRate;
   _interruptOnSpeech;
   _callSession = null;
   _tools = null;
+  _recorder = null;
   _conversation = [];
   _audioBuffer = [];
   _running = false;
@@ -1699,10 +2042,20 @@ var PipelineSession = class {
     this._llm = options.llm;
     this._tts = options.tts;
     this._systemPrompt = options.systemPrompt;
+    this._greeting = options.greeting ?? true;
+    this._language = options.language ?? "ko";
     this._temperature = options.temperature;
     this._maxTokens = options.maxTokens;
     this._sampleRate = options.sampleRate ?? 8e3;
     this._interruptOnSpeech = options.interruptOnSpeech ?? true;
+    if (options.toolRegistry) this._tools = options.toolRegistry;
+    if (options.recorder) this._recorder = options.recorder;
+  }
+  setToolRegistry(registry) {
+    this._tools = registry;
+  }
+  setRecorder(recorder) {
+    this._recorder = recorder;
   }
   async start(callSession, tools) {
     this._callSession = callSession;
@@ -1715,6 +2068,11 @@ var PipelineSession = class {
         content: this._systemPrompt
       });
     }
+    if (this._greeting) {
+      this._generateGreeting().catch((err) => {
+        console.error("[PipelineSession] Greeting error:", err);
+      });
+    }
     this._runSttLoop().catch((err) => {
       console.error("[PipelineSession] STT loop error:", err);
     });
@@ -1748,14 +2106,24 @@ var PipelineSession = class {
   async *_createAudioStream() {
     while (this._running) {
       if (this._audioBuffer.length > 0) {
-        yield this._audioBuffer.shift();
+        const ulaw = this._audioBuffer.shift();
+        const pcm8k = ulawToPcm16(ulaw);
+        const pcm16k = resamplePcm16(pcm8k, 8e3, 16e3);
+        yield pcm16k;
       } else {
         await new Promise((resolve) => setTimeout(resolve, 20));
       }
     }
   }
+  async _generateGreeting() {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    await this._respond();
+  }
   async _handleUserSpeech(transcript) {
     this._conversation.push({ role: "user", content: transcript });
+    await this._respond();
+  }
+  async _respond() {
     let fullResponse = "";
     const textChunks = [];
     const llmStream = this._llm.generate(this._conversation, {
@@ -1822,7 +2190,19 @@ var PipelineSession = class {
         sampleRate: this._sampleRate
       })) {
         if (!this._running || !this._speaking) break;
-        this._callSession.sendAudio(audioChunk);
+        if (this._recorder) {
+          const pcm8k2 = this._sampleRate !== 8e3 ? resamplePcm16(audioChunk, this._sampleRate, 8e3) : audioChunk;
+          this._recorder.writeOutbound(pcm8k2);
+        }
+        const pcm8k = resamplePcm16(audioChunk, this._sampleRate, 8e3);
+        const ulaw = pcm16ToUlaw(pcm8k);
+        for (let off = 0; off < ulaw.length; off += 160) {
+          let chunk = ulaw.subarray(off, off + 160);
+          if (chunk.length < 160) {
+            chunk = Buffer.concat([chunk, Buffer.alloc(160 - chunk.length, 255)]);
+          }
+          this._callSession.sendAudio(chunk);
+        }
       }
     } catch (err) {
       console.error("[PipelineSession] TTS error:", err);
@@ -1837,14 +2217,14 @@ var DeepgramSTT = class {
   _options;
   constructor(options = {}) {
     this._options = {
-      model: "nova-2",
+      model: "nova-3",
       language: "ko",
-      interimResults: true,
-      punctuate: true,
-      smartFormat: true,
+      sampleRate: 16e3,
       encoding: "linear16",
-      sampleRate: 8e3,
-      channels: 1,
+      punctuate: true,
+      interimResults: true,
+      endpointing: 300,
+      utteranceEndMs: 1e3,
       ...options
     };
   }
@@ -1861,10 +2241,10 @@ var DeepgramSTT = class {
       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)
+      endpointing: String(this._options.endpointing),
+      utterance_end_ms: String(this._options.utteranceEndMs)
     });
     const url = `wss://api.deepgram.com/v1/listen?${params.toString()}`;
     const ws = new WebSocket(url, {
@@ -1953,13 +2333,12 @@ var ElevenLabsTTS = class {
   _options;
   constructor(options = {}) {
     this._options = {
-      voiceId: "21m00Tcm4TlvDq8ikWAM",
-      modelId: "eleven_multilingual_v2",
-      outputFormat: "pcm_16000",
+      voiceId: "EXAVITQu4vr4xnSDxMaL",
+      model: "eleven_flash_v2_5",
+      outputFormat: "pcm_24000",
       stability: 0.5,
       similarityBoost: 0.75,
-      style: 0,
-      useSpeakerBoost: true,
+      languageCode: "ko",
       ...options
     };
   }
@@ -1985,12 +2364,10 @@ var ElevenLabsTTS = class {
       },
       body: JSON.stringify({
         text,
-        model_id: this._options.modelId,
+        model_id: this._options.model,
         voice_settings: {
           stability: this._options.stability,
-          similarity_boost: this._options.similarityBoost,
-          style: this._options.style,
-          use_speaker_boost: this._options.useSpeakerBoost
+          similarity_boost: this._options.similarityBoost
         }
       })
     });
@@ -2014,7 +2391,7 @@ var ElevenLabsTTS = class {
   }
   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 url = `wss://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream-input?model_id=${this._options.model}&output_format=${this._options.outputFormat}`;
     const ws = new WebSocket(url);
     const audioQueue = [];
     let resolveWait = null;
@@ -2025,9 +2402,7 @@ var ElevenLabsTTS = class {
           text: " ",
           voice_settings: {
             stability: this._options.stability,
-            similarity_boost: this._options.similarityBoost,
-            style: this._options.style,
-            use_speaker_boost: this._options.useSpeakerBoost
+            similarity_boost: this._options.similarityBoost
           },
           xi_api_key: apiKey
         })
@@ -2104,7 +2479,9 @@ var OpenAILLM = class {
   _options;
   constructor(options = {}) {
     this._options = {
-      model: "gpt-4o",
+      model: "gpt-4o-mini",
+      temperature: 0.8,
+      maxTokens: 4096,
       ...options
     };
   }
@@ -2188,8 +2565,9 @@ var AnthropicLLM = class {
   _options;
   constructor(options = {}) {
     this._options = {
-      model: "claude-sonnet-4-20250514",
-      maxTokens: 1024,
+      model: "claude-sonnet-4-6",
+      temperature: 0.8,
+      maxTokens: 4096,
       ...options
     };
   }
@@ -2292,7 +2670,9 @@ var GeminiLLM = class {
   _options;
   constructor(options = {}) {
     this._options = {
-      model: "gemini-2.0-flash",
+      model: "gemini-2.5-flash",
+      temperature: 0.8,
+      maxTokens: 4096,
       ...options
     };
   }
@@ -2456,13 +2836,13 @@ var OpenAICompatLLM = class {
 var OllamaLLM = class {
   _inner;
   constructor(options = {}) {
-    const baseUrl = (options.baseUrl ?? "http://localhost:11434").replace(/\/$/, "");
+    const baseUrl = options.baseUrl ?? process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434/v1";
     this._inner = new OpenAICompatLLM({
-      baseUrl: `${baseUrl}/v1`,
-      model: options.model ?? "llama3.1",
+      baseUrl: baseUrl.replace(/\/$/, ""),
+      model: options.model ?? "llama3.2",
       apiKey: "ollama",
-      temperature: options.temperature,
-      maxTokens: options.maxTokens
+      temperature: options.temperature ?? 0.8,
+      maxTokens: options.maxTokens ?? 4096
     });
   }
   async *generate(messages, options) {