@teamlearners/clawops 0.8.1 → 0.12.0

package/dist/agent/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_BASE_URL, AgentError, AgentConnectionError, VERSION } from '../chunk-RUVY7MYW.js';
+import { DEFAULT_BASE_URL, AgentError, AgentConnectionError, VERSION } from '../chunk-KK3OXQT6.js';
 import pino from 'pino';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -357,6 +357,7 @@ var ControlWebSocket = class {
   _url;
   _ws = null;
   _handlers = /* @__PURE__ */ new Map();
+  _transferResolvers = /* @__PURE__ */ new Map();
   _reconnectDelay = INITIAL_RECONNECT_DELAY;
   _closed = false;
   _connectedResolve = null;
@@ -384,6 +385,31 @@ var ControlWebSocket = class {
   async waitConnected() {
     return this._connectedPromise;
   }
+  /** Request a call transfer and wait for the result. */
+  async requestTransfer(callId, params) {
+    return new Promise((resolve, reject) => {
+      const timeout = (params.timeout || 30) + 10;
+      const timer = setTimeout(() => {
+        this._transferResolvers.delete(callId);
+        reject(new Error("transfer timeout"));
+      }, timeout * 1e3);
+      this._transferResolvers.set(callId, {
+        resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        },
+        reject: (reason) => {
+          clearTimeout(timer);
+          reject(reason);
+        }
+      });
+      this.send({
+        event: "call.transfer",
+        callId,
+        transfer: params
+      });
+    });
+  }
   /** Send a JSON message over the control WebSocket. */
   send(message) {
     if (this._ws && this._ws.readyState === 1) {
@@ -394,6 +420,10 @@ var ControlWebSocket = class {
   close() {
     this._closed = true;
     this._clearPingTimer();
+    for (const [, resolver] of this._transferResolvers) {
+      resolver.reject(new Error("connection closed"));
+    }
+    this._transferResolvers.clear();
     if (this._ws) {
       this._ws.close();
       this._ws = null;
@@ -439,6 +469,14 @@ var ControlWebSocket = class {
     });
   }
   _dispatchEvent(event) {
+    if (["call.transfer.completed", "call.transfer.failed"].includes(event.event)) {
+      const callId = event.callId;
+      const resolver = this._transferResolvers.get(callId);
+      if (resolver) {
+        this._transferResolvers.delete(callId);
+        resolver.resolve(event.transfer || {});
+      }
+    }
     const handlers = this._handlers.get(event.event);
     if (handlers) {
       for (const handler of handlers) {
@@ -908,8 +946,8 @@ var AudioRecorder = class {
         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);
+          const silence2 = Buffer.alloc(gap);
+          fs.writeSync(this._fdMix, silence2, 0, silence2.length, 44 + this._mixWritten);
           this._mixWritten += gap;
         }
       }
@@ -1020,6 +1058,8 @@ var CallSession = class {
   /** @internal */
   _sendDtmfFn = null;
   /** @internal */
+  _transferFn = null;
+  /** @internal */
   _isTransportConnected = null;
   _dtmfCollectorActive = false;
   _dtmfResolvers = [];
@@ -1171,6 +1211,22 @@ var CallSession = class {
       }
     }
   }
+  /** Transfer the call to another destination. */
+  async transfer(to, options) {
+    if (!this._transferFn) {
+      throw new Error("transfer not available");
+    }
+    return this._transferFn({
+      to,
+      mode: options?.mode ?? "blind",
+      afterTransfer: options?.afterTransfer ?? "terminate",
+      holdMedia: options?.holdMedia ?? "ringback",
+      whisper: options?.whisper ?? null,
+      context: options?.context ?? null,
+      callerId: options?.callerId ?? null,
+      timeout: options?.timeout ?? 30
+    });
+  }
   /** Register an event handler. */
   on(event, handler) {
     let list = this._handlers.get(event);
@@ -1215,6 +1271,7 @@ var BuiltinTool = /* @__PURE__ */ ((BuiltinTool2) => {
   BuiltinTool2["HANG_UP"] = "hang_up";
   BuiltinTool2["COLLECT_DTMF"] = "collect_dtmf";
   BuiltinTool2["SEND_DTMF"] = "send_dtmf";
+  BuiltinTool2["TRANSFER_CALL"] = "transfer_call";
   BuiltinTool2["ALL"] = "all";
   BuiltinTool2["NONE"] = "none";
   return BuiltinTool2;
@@ -1222,7 +1279,8 @@ var BuiltinTool = /* @__PURE__ */ ((BuiltinTool2) => {
 var INDIVIDUAL_TOOLS = /* @__PURE__ */ new Set([
   "hang_up" /* HANG_UP */,
   "collect_dtmf" /* COLLECT_DTMF */,
-  "send_dtmf" /* SEND_DTMF */
+  "send_dtmf" /* SEND_DTMF */,
+  "transfer_call" /* TRANSFER_CALL */
 ]);
 function resolveBuiltinTools(value) {
   if (typeof value === "string") {
@@ -1236,6 +1294,187 @@ function resolveBuiltinTools(value) {
   }
   return new Set(value.filter((t) => INDIVIDUAL_TOOLS.has(t)));
 }
+var CHUNK_SIZE = 160;
+var SAMPLE_RATE2 = 8e3;
+var BELL_PARTIALS = [
+  { freqRatio: 1, amplitude: 1, decayRate: 1.2 },
+  { freqRatio: 2.76, amplitude: 0.5, decayRate: 2.5 },
+  { freqRatio: 5.4, amplitude: 0.25, decayRate: 4 }
+];
+function bellNote(freq, durationMs, volume) {
+  const n = SAMPLE_RATE2 * durationMs / 1e3 | 0;
+  const attackSamples = 3e-3 * SAMPLE_RATE2 | 0;
+  const samples = new Int16Array(n);
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE2;
+    let val = 0;
+    for (const p of BELL_PARTIALS) {
+      const f = freq * p.freqRatio;
+      if (f >= SAMPLE_RATE2 / 2) continue;
+      const env = p.amplitude * Math.exp(-p.decayRate * t * (1e3 / durationMs));
+      val += env * Math.sin(2 * Math.PI * f * t);
+    }
+    if (i < attackSamples) {
+      val *= i / attackSamples;
+    }
+    samples[i] = Math.max(-32768, Math.min(32767, volume * 32767 * val | 0));
+  }
+  return samples;
+}
+function silence(durationMs) {
+  return new Int16Array(SAMPLE_RATE2 * durationMs / 1e3 | 0);
+}
+function int16ArrayToBuffer(samples) {
+  const buf = Buffer.alloc(samples.length * 2);
+  for (let i = 0; i < samples.length; i++) {
+    buf.writeInt16LE(samples[i], i * 2);
+  }
+  return buf;
+}
+function concatInt16Arrays(...arrays) {
+  let total = 0;
+  for (const a of arrays) total += a.length;
+  const result = new Int16Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+var PENTATONIC_C5 = {
+  C5: 523.25,
+  D5: 587.33,
+  E5: 659.25,
+  G5: 783.99,
+  A5: 880,
+  C6: 1046.5
+};
+function generateComfortTone(volume = 0.12) {
+  const p = PENTATONIC_C5;
+  const melody = [
+    [p.E5, 450],
+    [p.G5, 450],
+    [p.A5, 450],
+    [p.C6, 600],
+    [0, 800],
+    [p.A5, 400],
+    [p.G5, 400],
+    [p.E5, 400],
+    [p.D5, 600],
+    [0, 2500],
+    [p.C5, 500],
+    [p.E5, 500],
+    [p.C6, 700],
+    [0, 2500]
+  ];
+  const parts = [];
+  for (const [freq, durMs] of melody) {
+    if (freq === 0) {
+      parts.push(silence(durMs));
+    } else {
+      parts.push(bellNote(freq, durMs, volume));
+      parts.push(silence(150));
+    }
+  }
+  const pcm = int16ArrayToBuffer(concatInt16Arrays(...parts));
+  const ulaw = pcm16ToUlaw(pcm);
+  const chunks = [];
+  for (let i = 0; i < ulaw.length; i += CHUNK_SIZE) {
+    chunks.push(ulaw.subarray(i, i + CHUNK_SIZE));
+  }
+  return chunks;
+}
+function loadHoldAudio(source) {
+  if (source === true) {
+    return generateComfortTone();
+  }
+  if (Buffer.isBuffer(source)) {
+    const chunks = [];
+    for (let i = 0; i < source.length; i += CHUNK_SIZE) {
+      chunks.push(source.subarray(i, i + CHUNK_SIZE));
+    }
+    return chunks;
+  }
+  if (typeof source === "string") {
+    const data = fs.readFileSync(source);
+    const riff = data.toString("ascii", 0, 4);
+    if (riff !== "RIFF") {
+      throw new Error(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4: ${source}`);
+    }
+    let offset = 12;
+    let channels = 1;
+    let sampleRate = 8e3;
+    let bitsPerSample = 16;
+    let pcmData = null;
+    while (offset < data.length - 8) {
+      const chunkId = data.toString("ascii", offset, offset + 4);
+      const chunkSize = data.readUInt32LE(offset + 4);
+      if (chunkId === "fmt ") {
+        channels = data.readUInt16LE(offset + 10);
+        sampleRate = data.readUInt32LE(offset + 12);
+        bitsPerSample = data.readUInt16LE(offset + 22);
+      } else if (chunkId === "data") {
+        pcmData = data.subarray(offset + 8, offset + 8 + chunkSize);
+      }
+      offset += 8 + chunkSize;
+      if (chunkSize % 2 !== 0) offset++;
+    }
+    if (!pcmData) {
+      throw new Error(`WAV data chunk\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${source}`);
+    }
+    if (bitsPerSample !== 16) {
+      throw new Error(`16-bit PCM wav\uB9CC \uC9C0\uC6D0\uD569\uB2C8\uB2E4 (\uD604\uC7AC: ${bitsPerSample}-bit)`);
+    }
+    if (channels === 2) {
+      const monoLen = pcmData.length / 2;
+      const mono = Buffer.alloc(monoLen);
+      for (let i = 0; i < monoLen / 2; i++) {
+        mono.writeInt16LE(pcmData.readInt16LE(i * 4), i * 2);
+      }
+      pcmData = mono;
+    }
+    if (sampleRate !== SAMPLE_RATE2) {
+      pcmData = resamplePcm16(pcmData, sampleRate, SAMPLE_RATE2);
+    }
+    const ulaw = pcm16ToUlaw(pcmData);
+    const chunks = [];
+    for (let i = 0; i < ulaw.length; i += CHUNK_SIZE) {
+      chunks.push(ulaw.subarray(i, i + CHUNK_SIZE));
+    }
+    return chunks;
+  }
+  throw new TypeError(`\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 holdAudio \uD0C0\uC785: ${typeof source}`);
+}
+var HoldAudioPlayer = class {
+  _call;
+  _chunks;
+  _timer = null;
+  _index = 0;
+  constructor(call, chunks) {
+    this._call = call;
+    this._chunks = chunks;
+  }
+  start() {
+    if (this._timer !== null) return;
+    this._index = 0;
+    this._timer = setInterval(() => {
+      if (this._index >= this._chunks.length) {
+        this._index = 0;
+      }
+      const chunk = this._chunks[this._index++];
+      if (chunk) {
+        this._call.sendAudio(chunk);
+      }
+    }, 20);
+  }
+  stop() {
+    if (this._timer === null) return;
+    clearInterval(this._timer);
+    this._timer = null;
+    this._call.clearAudio();
+  }
+};
 
 // src/agent/tool.ts
 function functionTool(fn) {
@@ -1454,6 +1693,7 @@ var ClawOpsAgent = class {
   _log;
   _pipelineLog;
   _isPipelineSession = false;
+  _holdAudioChunks = null;
   constructor(options) {
     this._apiKey = options.apiKey ?? process.env["CLAWOPS_API_KEY"] ?? "";
     this._accountId = options.accountId ?? process.env["CLAWOPS_ACCOUNT_ID"] ?? "";
@@ -1471,6 +1711,9 @@ var ClawOpsAgent = class {
     this._log = createAgentLogger(options.logger);
     this._pipelineLog = createPipelineLogger(this._log);
     this._isPipelineSession = "_stt" in this._session && "_llm" in this._session;
+    if (options.toolConfig?.holdAudio) {
+      this._holdAudioChunks = loadHoldAudio(options.toolConfig.holdAudio);
+    }
   }
   /**
    * Register a function tool.
@@ -1775,6 +2018,7 @@ var ClawOpsAgent = class {
           },
           () => mediaWs.isConnected
         );
+        session._transferFn = (params) => this._controlWs.requestTransfer(session.callId, params);
         const sessionHandler = this._session;
         if ("setToolRegistry" in sessionHandler && typeof sessionHandler.setToolRegistry === "function") {
           sessionHandler.setToolRegistry(sessionTools);
@@ -1788,6 +2032,9 @@ var ClawOpsAgent = class {
         if ("setLogger" in sessionHandler && typeof sessionHandler.setLogger === "function") {
           sessionHandler.setLogger(this._isPipelineSession ? this._pipelineLog : this._log);
         }
+        if (this._holdAudioChunks && "setHoldAudio" in sessionHandler && typeof sessionHandler.setHoldAudio === "function") {
+          sessionHandler.setHoldAudio(this._holdAudioChunks);
+        }
         this._callSessions.set(session.callId, sessionHandler);
         mediaWs.onAudio((ulawAudio, _timestamp) => {
           if (sessionHandler) {
@@ -1889,10 +2136,27 @@ var SEND_DTMF = {
     required: ["digits"]
   }
 };
+var TRANSFER_CALL = {
+  name: "transfer_call",
+  description: "Transfer the current call to another phone number. Use for blind transfer (direct handoff) or warm transfer (with whisper message to the target).",
+  parameters: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: "Phone number to transfer to" },
+      mode: { type: "string", enum: ["blind", "warm"], description: "blind: direct transfer (default), warm: play whisper to target first" },
+      after_transfer: { type: "string", enum: ["terminate", "return"], description: "terminate: end AI session (default), return: AI resumes after transfer ends" },
+      whisper: { type: "string", description: "Message to speak to transfer target before connecting customer (warm mode only)" },
+      caller_id: { type: "string", description: "Override caller ID for the transfer leg" },
+      timeout: { type: "integer", description: "Seconds to wait for transfer target to answer (default 30)" }
+    },
+    required: ["to"]
+  }
+};
 var TOOL_MAP = /* @__PURE__ */ new Map([
   ["hang_up" /* HANG_UP */, HANG_UP],
   ["collect_dtmf" /* COLLECT_DTMF */, COLLECT_DTMF],
-  ["send_dtmf" /* SEND_DTMF */, SEND_DTMF]
+  ["send_dtmf" /* SEND_DTMF */, SEND_DTMF],
+  ["transfer_call" /* TRANSFER_CALL */, TRANSFER_CALL]
 ]);
 var BUILTIN_TOOL_NAMES = new Set(
   Array.from(TOOL_MAP.values()).map((s) => s.name)
@@ -1965,6 +2229,21 @@ async function executeBuiltinTool(funcName, args, call) {
       return `Error: ${e}`;
     }
   }
+  if (funcName === "transfer_call") {
+    try {
+      call.transfer(args["to"], {
+        mode: args["mode"] ?? void 0,
+        afterTransfer: args["after_transfer"] ?? void 0,
+        whisper: args["whisper"] ?? void 0,
+        callerId: args["caller_id"] ?? void 0,
+        timeout: args["timeout"] ?? void 0
+      }).catch(() => {
+      });
+      return JSON.stringify({ status: "transfer_initiated" });
+    } catch (e) {
+      return `Error: ${e}`;
+    }
+  }
   return null;
 }
 
@@ -1988,6 +2267,7 @@ var PipelineSession = class {
   _running = false;
   _speaking = false;
   _builtinTools = null;
+  _holdAudioChunks = null;
   _log = NOOP_LOGGER;
   constructor(options) {
     this._stt = options.stt;
@@ -2012,6 +2292,10 @@ var PipelineSession = class {
   setBuiltinTools(tools) {
     this._builtinTools = tools;
   }
+  /** Tool 실행 중 재생할 hold audio 청크를 설정한다. */
+  setHoldAudio(chunks) {
+    this._holdAudioChunks = chunks;
+  }
   getTelemetry() {
     const llm = this._llm;
     const stt = this._stt;
@@ -2177,7 +2461,14 @@ var PipelineSession = class {
       }
       if (!this._tools) return;
       this._callSession?.recordToolCall();
-      const result = await this._tools.call(name, args);
+      const player = this._holdAudioChunks && this._callSession ? new HoldAudioPlayer(this._callSession, this._holdAudioChunks) : null;
+      player?.start();
+      let result;
+      try {
+        result = await this._tools.call(name, args);
+      } finally {
+        player?.stop();
+      }
       this._conversation.push({
         role: "assistant",
         content: ""
@@ -2289,6 +2580,8 @@ var OpenAIRealtime = class {
   // Response state tracking — prevent sending response.create while one is active
   _responseInProgress = false;
   _onResponseDone = null;
+  // Hold audio — tool 실행 중 대기음
+  _holdAudioChunks = null;
   constructor(options = {}) {
     this._apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"] ?? "";
     this._systemPrompt = options.systemPrompt ?? "";
@@ -2306,6 +2599,10 @@ var OpenAIRealtime = class {
   setRecorder(recorder) {
     this._recorder = recorder;
   }
+  /** Tool 실행 중 재생할 hold audio 청크를 설정한다. */
+  setHoldAudio(chunks) {
+    this._holdAudioChunks = chunks;
+  }
   async start(callSession, tools) {
     this._call = callSession;
     if (tools) this._tools = tools;
@@ -2561,6 +2858,8 @@ var OpenAIRealtime = class {
         return;
       }
       let result;
+      const player = this._holdAudioChunks && this._call ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
+      player?.start();
       try {
         const args = JSON.parse(item["arguments"] ?? "{}");
         this._call?.recordToolCall();
@@ -2571,6 +2870,8 @@ var OpenAIRealtime = class {
           this._call?.recordToolError(err);
         }
         result = `Error: ${err}`;
+      } finally {
+        player?.stop();
       }
       if (controller.signal.aborted) {
         this._log.info("Tool call cancelled (user interrupted): %s", funcName);
@@ -2678,7 +2979,7 @@ function sanitizeSchemaForGemini(schema, defs, depth = 0) {
   if (result["type"] === "object" && !result["properties"]) result["properties"] = {};
   return result;
 }
-var GeminiRealtime = class {
+var GeminiRealtime = class _GeminiRealtime {
   _apiKey;
   _systemPrompt;
   _model;
@@ -2694,12 +2995,15 @@ var GeminiRealtime = class {
   _sentAudioChunks = 0;
   _audioRemainder = Buffer.alloc(0);
   _builtinTools = null;
-  _toolCallInProgress = false;
+  _pendingToolCall = null;
+  _toolDrainTimer = null;
+  _lastAudioTime = 0;
+  _holdAudioChunks = null;
   _log = NOOP_LOGGER;
   constructor(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._model = options.model ?? "gemini-3.1-flash-live-preview";
     this._voice = options.voice ?? "Kore";
     this._language = options.language ?? "ko";
     this._greeting = options.greeting ?? true;
@@ -2715,6 +3019,10 @@ var GeminiRealtime = class {
   setBuiltinTools(tools) {
     this._builtinTools = tools;
   }
+  /** Tool 실행 중 재생할 hold audio 청크를 설정한다. */
+  setHoldAudio(chunks) {
+    this._holdAudioChunks = chunks;
+  }
   setLogger(logger) {
     this._log = logger;
   }
@@ -2739,11 +3047,8 @@ var GeminiRealtime = class {
     this._closed = false;
     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 { GoogleGenAI } = await import('@google/genai/node');
-    const client = new GoogleGenAI({ apiKey: this._apiKey });
+    const client = this._apiKey ? new GoogleGenAI({ apiKey: this._apiKey }) : new GoogleGenAI({});
     const config = {
       responseModalities: ["AUDIO"],
       speechConfig: {
@@ -2757,7 +3062,9 @@ var GeminiRealtime = class {
       outputAudioTranscription: {}
     };
     if (this._systemPrompt) {
-      config["systemInstruction"] = this._systemPrompt;
+      config["systemInstruction"] = {
+        parts: [{ text: this._systemPrompt }]
+      };
     }
     const toolSchemas = this._buildToolSchemas();
     if (toolSchemas.length > 0) {
@@ -2772,25 +3079,20 @@ var GeminiRealtime = class {
           this._log.error({ err }, "Gemini SDK error");
         },
         onclose: (ev) => {
-          this._log.info({ code: ev?.code ?? "unknown" }, "Gemini connection closed");
+          this._log.info(
+            { code: ev?.code ?? "unknown" },
+            "Gemini connection closed"
+          );
           this._closed = true;
         }
       }
     });
     if (this._greeting) {
-      this._session.sendClientContent({
-        turns: [
-          {
-            role: "user",
-            parts: [{ text: "\uC778\uC0AC\uD574 \uC8FC\uC138\uC694." }]
-          }
-        ],
-        turnComplete: true
-      });
+      this._session.sendRealtimeInput({ text: "\uC778\uC0AC\uD574 \uC8FC\uC138\uC694." });
     }
   }
   feedAudio(audio) {
-    if (this._session && !this._closed && !this._toolCallInProgress) {
+    if (this._session && !this._closed) {
       const pcm8k = ulawToPcm16(audio);
       if (this._recorder) {
         this._recorder.writeInbound(pcm8k);
@@ -2806,14 +3108,16 @@ var GeminiRealtime = class {
   }
   async feedDtmf(digits) {
     if (this._session) {
-      this._session.sendClientContent({
-        turns: [{ role: "user", parts: [{ text: `[DTMF \uC785\uB825: ${digits}]` }] }],
-        turnComplete: true
-      });
+      this._session.sendRealtimeInput({ text: `[DTMF \uC785\uB825: ${digits}]` });
     }
   }
   async stop() {
     this._closed = true;
+    if (this._toolDrainTimer) {
+      clearTimeout(this._toolDrainTimer);
+      this._toolDrainTimer = null;
+    }
+    this._pendingToolCall = null;
     if (this._session) {
       try {
         this._session.close();
@@ -2845,6 +3149,7 @@ var GeminiRealtime = class {
             const mimeType = inlineData.mimeType ?? "";
             if (mimeType.includes("audio")) {
               this._handleAudioData(inlineData.data);
+              if (this._pendingToolCall) this._lastAudioTime = Date.now();
             }
           }
         }
@@ -2873,11 +3178,17 @@ var GeminiRealtime = class {
       }
     }
     if (msg.toolCall) {
-      this._handleToolCall(msg.toolCall);
+      this._pendingToolCall = msg.toolCall;
+      this._scheduleToolExecution();
     }
     const toolCancellation = msg["toolCallCancellation"];
     if (toolCancellation) {
       this._log.info({ ids: toolCancellation.ids }, "Tool call cancelled");
+      this._pendingToolCall = null;
+      if (this._toolDrainTimer) {
+        clearTimeout(this._toolDrainTimer);
+        this._toolDrainTimer = null;
+      }
     }
   }
   _handleAudioData(b64Data) {
@@ -2908,54 +3219,81 @@ var GeminiRealtime = class {
       this._audioRemainder = Buffer.alloc(0);
     }
   }
+  // Gemini는 tool_call 후에도 오디오를 계속 보내므로, 이 시간 내 응답이 없으면 drain 완료로 간주
+  static TOOL_DRAIN_TIMEOUT = 300;
+  _scheduleToolExecution() {
+    if (this._toolDrainTimer) return;
+    this._lastAudioTime = Date.now();
+    this._toolDrainTimer = setTimeout(() => {
+      this._toolDrainTimer = null;
+      if (Date.now() - this._lastAudioTime < _GeminiRealtime.TOOL_DRAIN_TIMEOUT) {
+        this._scheduleToolExecution();
+        return;
+      }
+      if (this._pendingToolCall) {
+        const tc = this._pendingToolCall;
+        this._pendingToolCall = null;
+        this._handleToolCall(tc);
+      }
+    }, _GeminiRealtime.TOOL_DRAIN_TIMEOUT);
+  }
   async _handleToolCall(toolCall) {
     const functionCalls = toolCall.functionCalls;
     if (!functionCalls) return;
-    this._toolCallInProgress = true;
     const responses = [];
-    for (const fc of functionCalls) {
-      const name = fc.name ?? "";
-      const fcId = fc.id ?? "";
-      const args = fc.args ?? {};
-      this._log.info({ tool: name, args }, "Tool call: %s", name);
-      if (BUILTIN_TOOL_NAMES.has(name) && this._call) {
-        const result = await executeBuiltinTool(name, args, this._call);
-        if (result !== null) {
-          if (name === "hang_up") {
-            this._log.info("hang_up: ending call");
-            return;
+    const player = this._holdAudioChunks && this._call ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
+    player?.start();
+    try {
+      for (const fc of functionCalls) {
+        const name = fc.name ?? "";
+        const fcId = fc.id ?? "";
+        const args = fc.args ?? {};
+        this._log.info({ tool: name, args }, "Tool call: %s", name);
+        if (BUILTIN_TOOL_NAMES.has(name) && this._call) {
+          const result = await executeBuiltinTool(
+            name,
+            args,
+            this._call
+          );
+          if (result !== null) {
+            if (name === "hang_up") {
+              this._log.info("hang_up: ending call");
+              return;
+            }
+            this._log.info("Builtin tool result: %s -> %s", name, result);
+            responses.push({ id: fcId, name, response: { result } });
+            continue;
           }
-          this._log.info("Builtin tool result: %s -> %s", name, result);
-          responses.push({ id: fcId, name, response: { result } });
+        }
+        if (!this._tools || !this._tools.has(name)) {
+          this._log.error("Unknown tool: %s", name);
+          responses.push({ id: fcId, name, response: { error: `Unknown tool: ${name}` } });
           continue;
         }
-      }
-      if (!this._tools || !this._tools.has(name)) {
-        this._log.error("Unknown tool: %s", name);
-        responses.push({ id: fcId, name, response: { error: `Unknown tool: ${name}` } });
-        continue;
-      }
-      try {
-        this._call?.recordToolCall();
-        const result = await this._tools.call(name, args);
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result);
-        this._log.info("Tool result: %s -> %s", name, resultStr.substring(0, 200));
-        responses.push({
-          id: fcId,
-          name,
-          response: { result: resultStr }
-        });
-      } catch (err) {
-        this._log.error({ err }, "Tool call failed: %s", name);
-        if (err instanceof Error) {
-          this._call?.recordToolError(err);
+        try {
+          this._call?.recordToolCall();
+          const result = await this._tools.call(name, args);
+          const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+          this._log.info("Tool result: %s -> %s", name, resultStr.substring(0, 200));
+          responses.push({
+            id: fcId,
+            name,
+            response: { result: resultStr }
+          });
+        } catch (err) {
+          this._log.error({ err }, "Tool call failed: %s", name);
+          if (err instanceof Error) {
+            this._call?.recordToolError(err);
+          }
+          responses.push({
+            id: fcId,
+            name,
+            response: { error: String(err) }
+          });
         }
-        responses.push({
-          id: fcId,
-          name,
-          response: { error: String(err) }
-        });
       }
+    } finally {
+      player?.stop();
     }
     if (responses.length > 0 && this._session) {
       this._log.debug("Sending %d tool response(s)", responses.length);
@@ -2963,7 +3301,6 @@ var GeminiRealtime = class {
         functionResponses: responses
       });
     }
-    this._toolCallInProgress = false;
   }
 };
 
@@ -3478,9 +3815,8 @@ var GeminiLLM = class {
   }
   async *generate(messages, options) {
     const { GoogleGenAI } = await import('@google/genai');
-    const client = new GoogleGenAI({
-      apiKey: this._options.apiKey ?? process.env["GOOGLE_API_KEY"]
-    });
+    const apiKey = this._options.apiKey ?? process.env["GOOGLE_API_KEY"];
+    const client = apiKey ? new GoogleGenAI({ apiKey }) : new GoogleGenAI();
     let systemInstruction;
     const contents = [];
     for (const msg of messages) {