@teamlearners/clawops 0.16.6 → 0.17.1

package/README.md

@@ -45,6 +45,36 @@ agent.on('call_start', async (call) => {
 await agent.serve(); // Ctrl+C로 종료
 ```
 
+### Outbound 발신 Prewarm (낮은 첫 음성 latency)
+
+outbound 통화에서 상대 응답 직후 첫 음성까지의 지연을 줄이기 위해, `ClawOpsAgent` 는
+control WS 의 `call.outbound_ready` 이벤트 수신 즉시 LLM WebSocket 을 미리 연결하고
+첫 audio delta 를 메모리에 누적한다 (prewarm + first-audio prebuffer). media WS 가 연결되면
+누적된 chunk 를 flush 하여 사용자가 첫 음성을 빠르게 듣게 한다.
+
+```typescript
+const agent = new ClawOpsAgent({
+  from: '07012341234',
+  session: new OpenAIRealtime({ systemPrompt: '...' }),
+  prewarmEnabled: true, // default true
+});
+```
+
+비용/효과 검증 단계에서는 `prewarmEnabled: false` 로 비활성화할 수 있다. 동작 측정은
+`[PREWARM-T]` 로그 마커(`start` / `done` / `failed` / `attach` / `first-audio`)를 grep
+하여 elapsed 를 계산한다.
+
+**한계 / 비목표**
+
+- **동시 outbound 통화 1건 가정** — `ClawOpsAgent` 1 인스턴스의 `session` 객체는 prewarm 시
+  단일 `BufferingCall` 을 공유한다. 같은 인스턴스로 동시 outbound 통화를 발신하면 prewarm
+  race 가 발생할 수 있다. 다중 동시 outbound 가 필요하면 통화별로 별도 `ClawOpsAgent`
+  인스턴스를 사용하거나, session factory 패턴 도입이 필요하다 (후속 과제).
+- **Session 타입별 효과 차이** — Realtime (OpenAI / Gemini) 에서 LLM WS handshake +
+  session.update 가 prewarm 으로 숨겨지므로 latency 절감 효과가 가장 크다. 반면
+  `PipelineSession` 은 STT / LLM / TTS 가 lazy 연결되므로, prewarm 단계에서는 STT 루프
+  기동과 greeting kickoff 정도만 선행되어 latency 절감 효과가 제한적이다.
+
 ### Call Transfer (통화 전환)
 
 AI가 통화 중 다른 번호로 전환할 수 있습니다. Blind(즉시)와 Warm(안내 후) 모드를 지원합니다.

package/dist/agent/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkOLGP2XVS_cjs = require('../chunk-OLGP2XVS.cjs');
+var chunkNFKE5ZVZ_cjs = require('../chunk-NFKE5ZVZ.cjs');
 var pino = require('pino');
 var fs = require('fs');
 var path = require('path');
@@ -1079,7 +1079,7 @@ var MAX_ERROR_MESSAGE_LENGTH = 200;
 function getSdkInfo() {
   return {
     name: "clawops-node",
-    version: chunkOLGP2XVS_cjs.VERSION,
+    version: chunkNFKE5ZVZ_cjs.VERSION,
     runtime: `node/${process.versions.node}`,
     os: `${process.platform}/${os__default.default.arch()}`
   };
@@ -1759,10 +1759,15 @@ var ClawOpsAgent = class _ClawOpsAgent {
   _holdAudioChunks = null;
   _rxGain;
   _txGain;
+  _prewarmTasks = /* @__PURE__ */ new Map();
+  _prewarmFailed = /* @__PURE__ */ new Set();
+  /** prewarm 세션이 실제 CallSession 에 attach 완료된 callId. attached 이후의 stop() 은 정상 종료 경로가 책임진다. */
+  _prewarmAttached = /* @__PURE__ */ new Set();
+  _prewarmEnabled;
   constructor(options) {
     this._apiKey = options.apiKey ?? process.env["CLAWOPS_API_KEY"] ?? "";
     this._accountId = options.accountId ?? process.env["CLAWOPS_ACCOUNT_ID"] ?? "";
-    this._baseUrl = options.baseUrl ?? chunkOLGP2XVS_cjs.DEFAULT_BASE_URL;
+    this._baseUrl = options.baseUrl ?? chunkNFKE5ZVZ_cjs.DEFAULT_BASE_URL;
     this._fromNumber = options.from;
     this._session = options.session;
     this._recording = options.recording ?? false;
@@ -1772,6 +1777,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
     this._passiveDtmfDebounceMs = options.passiveDtmfDebounceMs ?? 500;
     this._rxGain = _ClawOpsAgent._validateGain("rxGain", options.rxGain ?? 1);
     this._txGain = _ClawOpsAgent._validateGain("txGain", options.txGain ?? 1);
+    this._prewarmEnabled = options.prewarmEnabled ?? true;
     if (options.tracing) {
       setTracingConfig(options.tracing);
     }
@@ -1784,7 +1790,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
   }
   static _validateGain(name, gain) {
     if (typeof gain !== "number" || !Number.isFinite(gain) || gain < 0) {
-      throw new chunkOLGP2XVS_cjs.AgentError(`${name}=${gain} must be a finite number >= 0`);
+      throw new chunkNFKE5ZVZ_cjs.AgentError(`${name}=${gain} must be a finite number >= 0`);
     }
     return gain;
   }
@@ -1798,7 +1804,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
   tool(nameOrTool, description, parameters, handler) {
     if (typeof nameOrTool === "string") {
       if (!description || !parameters || !handler) {
-        throw new chunkOLGP2XVS_cjs.AgentError(
+        throw new chunkNFKE5ZVZ_cjs.AgentError(
           "tool(name, description, parameters, handler) requires all arguments."
         );
       }
@@ -1834,10 +1840,10 @@ var ClawOpsAgent = class _ClawOpsAgent {
   async connect() {
     if (this._controlWs) return;
     if (!this._apiKey) {
-      throw new chunkOLGP2XVS_cjs.AgentError("API key is required. Set CLAWOPS_API_KEY or pass apiKey option.");
+      throw new chunkNFKE5ZVZ_cjs.AgentError("API key is required. Set CLAWOPS_API_KEY or pass apiKey option.");
     }
     if (!this._accountId) {
-      throw new chunkOLGP2XVS_cjs.AgentError(
+      throw new chunkNFKE5ZVZ_cjs.AgentError(
         "Account ID is required. Set CLAWOPS_ACCOUNT_ID or pass accountId option."
       );
     }
@@ -1861,7 +1867,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
       } catch {
       }
     } catch (err) {
-      throw new chunkOLGP2XVS_cjs.AgentConnectionError(
+      throw new chunkNFKE5ZVZ_cjs.AgentConnectionError(
         `Failed to connect to ClawOps: ${err instanceof Error ? err.message : String(err)}`
       );
     }
@@ -1912,7 +1918,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
     });
     if (resp.status !== 201) {
       const error = await resp.json();
-      throw new chunkOLGP2XVS_cjs.AgentError(`\uBC1C\uC2E0 \uC2E4\uD328 (${resp.status}): ${error["error"] ?? ""}`);
+      throw new chunkNFKE5ZVZ_cjs.AgentError(`\uBC1C\uC2E0 \uC2E4\uD328 (${resp.status}): ${error["error"] ?? ""}`);
     }
     const data = await resp.json();
     const callSession = new CallSession({
@@ -1930,6 +1936,9 @@ var ClawOpsAgent = class _ClawOpsAgent {
     callSession.setLogger(this._log);
     this._activeSessions.set(callSession.callId, callSession);
     this._log.info("Outbound call initiated: %s -> %s (%s)", this._fromNumber, to, callSession.callId);
+    if (this._prewarmEnabled) {
+      this._startPrewarm(callSession.callId);
+    }
     return callSession;
   }
   _handleIncoming(event) {
@@ -1966,6 +1975,34 @@ var ClawOpsAgent = class _ClawOpsAgent {
       session._markEnded();
       this._activeSessions.delete(callId);
     }
+    void this._cleanupPrewarm(callId);
+  }
+  /**
+   * Drop prewarm bookkeeping for a callId. Used on hangup/failure paths.
+   *
+   * prewarm 이 진행 중이거나 완료됐지만 attach 전에 호출되면 LLM WS 가 leak 되므로
+   * race 후 session.stop() 으로 정리한다. (TS 에는 Promise.cancel 이 없어 Python
+   * 의 task.cancel() 등가물은 _session.stop() 호출이다.)
+   *
+   * 이미 attach 된 callId 면 stop() 을 호출하지 않는다 — 정상 종료 경로 (call-session
+   * finally) 가 책임지기 때문이다.
+   */
+  async _cleanupPrewarm(callId) {
+    const task = this._prewarmTasks.get(callId);
+    const attached = this._prewarmAttached.has(callId);
+    this._prewarmTasks.delete(callId);
+    this._prewarmFailed.delete(callId);
+    this._prewarmAttached.delete(callId);
+    if (!task || attached) return;
+    try {
+      await task;
+    } catch {
+    }
+    try {
+      await this._session.stop();
+    } catch (err) {
+      this._log.warn({ err, callId }, "prewarm cleanup stop() failed");
+    }
   }
   _handleOutboundReady(event) {
     const callId = event["callId"];
@@ -1987,16 +2024,60 @@ var ClawOpsAgent = class _ClawOpsAgent {
       }
       this._activeSessions.set(callId, session);
     }
+    if (this._prewarmEnabled) {
+      this._startPrewarm(callId);
+    }
     if (mediaUrl) {
       this._log.info("Outbound call answered: %s -> %s (%s)", this._fromNumber, session.toNumber, callId);
       this._safeStartCallSession(session, mediaUrl, callId);
     }
   }
+  /**
+   * Start the LLM session prewarm task for the given callId. Safe to call
+   * multiple times — only the first invocation starts the task. Failures are
+   * recorded in _prewarmFailed so the call-session path can fall back to start().
+   */
+  _startPrewarm(callId) {
+    if (this._prewarmTasks.has(callId)) return;
+    const sessionHandler = this._session;
+    if (typeof sessionHandler.prewarm !== "function") return;
+    const PREWARM_TIMEOUT_MS = 1e4;
+    const t0 = Date.now();
+    this._log.info(`[PREWARM-T] start call_id=${callId} t=${(t0 / 1e3).toFixed(3)}`);
+    const task = (async () => {
+      let timer;
+      try {
+        const timeout = new Promise((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("prewarm timeout")),
+            PREWARM_TIMEOUT_MS
+          );
+        });
+        await Promise.race([sessionHandler.prewarm(), timeout]);
+        const elapsed = Date.now() - t0;
+        this._log.info(`[PREWARM-T] done call_id=${callId} elapsed_ms=${elapsed}`);
+      } catch (err) {
+        const elapsed = Date.now() - t0;
+        const reason = err instanceof Error ? err.message : String(err);
+        this._log.warn(
+          { err, callId },
+          `[PREWARM-T] failed call_id=${callId} elapsed_ms=${elapsed} reason=${reason}`
+        );
+        this._prewarmFailed.add(callId);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    })();
+    this._prewarmTasks.set(callId, task);
+  }
   _handleRinging(event) {
     const callId = event["callId"];
     const session = this._activeSessions.get(callId);
     if (session) {
       this._log.info("Outbound call ringing: %s", callId);
+      if (this._prewarmEnabled) {
+        this._startPrewarm(callId);
+      }
     }
   }
   _handleFailed(event) {
@@ -2008,6 +2089,7 @@ var ClawOpsAgent = class _ClawOpsAgent {
       session._markEnded();
       this._activeSessions.delete(callId);
     }
+    void this._cleanupPrewarm(callId);
   }
   _onDtmfEvent(callSession, digit) {
     callSession._emit("dtmf", digit);
@@ -2160,7 +2242,36 @@ var ClawOpsAgent = class _ClawOpsAgent {
         try {
           await mediaWs.connect(mediaWsUrl, this._apiKey);
           this._log.info("Media stream started: %s", session.callId);
-          await sessionHandler.start(session, sessionTools);
+          const prewarmTask = this._prewarmTasks.get(session.callId);
+          if (prewarmTask && !this._prewarmFailed.has(session.callId)) {
+            try {
+              await prewarmTask;
+              if (this._prewarmFailed.has(session.callId)) {
+                await sessionHandler.start(session, sessionTools);
+              } else {
+                this._log.info(
+                  `[PREWARM-T] attach call_id=${session.callId} t=${(Date.now() / 1e3).toFixed(3)}`
+                );
+                await sessionHandler.attach(session);
+                this._prewarmAttached.add(session.callId);
+              }
+            } catch (err) {
+              this._log.warn(
+                { err, callId: session.callId },
+                "prewarm/attach failed, falling back to start()"
+              );
+              try {
+                await sessionHandler.stop();
+              } catch {
+              }
+              await sessionHandler.start(session, sessionTools);
+            }
+          } else {
+            await sessionHandler.start(session, sessionTools);
+          }
+          this._prewarmTasks.delete(session.callId);
+          this._prewarmFailed.delete(session.callId);
+          this._prewarmAttached.delete(session.callId);
           const telemetry = sessionHandler.getTelemetry?.() ?? null;
           if (telemetry) {
             telemetry.toolCount = sessionTools?.size ?? 0;
@@ -2349,6 +2460,86 @@ async function executeBuiltinTool(funcName, args, call) {
   return null;
 }
 
+// src/agent/pipeline/buffering-call.ts
+var MetricsStub = class {
+  recordToolCall() {
+  }
+  recordInterrupt() {
+  }
+  recordToolError() {
+  }
+};
+var BufferingCall = class {
+  _buffer = [];
+  _droppedEvents = {};
+  metrics = new MetricsStub();
+  async sendAudio(chunk) {
+    this._buffer.push(chunk);
+  }
+  /** clearAudio 도 prewarm 동안엔 no-op (드물긴 하지만 안전하게). */
+  clearAudio() {
+    this._buffer = [];
+  }
+  /**
+   * transcript 등 lifecycle 이벤트는 prewarm 동안 무시한다. silent drop 은 디버깅이
+   * 어려우므로 event name 별 카운터로 누적하고 attachBuffered() 시 한 번에 로깅한다.
+   */
+  _emit(...args) {
+    this._recordDropped(args);
+  }
+  async emit(...args) {
+    this._recordDropped(args);
+  }
+  _recordDropped(args) {
+    let eventName = "?";
+    if (args.length > 0 && typeof args[0] === "string") {
+      eventName = args[0];
+    }
+    this._droppedEvents[eventName] = (this._droppedEvents[eventName] ?? 0) + 1;
+  }
+  recordToolCall() {
+  }
+  recordToolError() {
+  }
+  recordFirstResponse() {
+  }
+  recordBargeIn() {
+  }
+  drainBuffer() {
+    const out = this._buffer;
+    this._buffer = [];
+    return out;
+  }
+  drainDroppedEvents() {
+    const out = this._droppedEvents;
+    this._droppedEvents = {};
+    return out;
+  }
+};
+function attachBuffered(prev, next) {
+  if (!(prev instanceof BufferingCall)) {
+    return false;
+  }
+  const drained = prev.drainBuffer();
+  const flushed = drained.length > 0;
+  const callId = next.callId ?? "?";
+  if (flushed) {
+    console.info(
+      `[PREWARM-T] first-audio call_id=${callId} t=${(process.hrtime.bigint() / 1000000n).toString()} buffered_chunks=${drained.length} source=prebuffer`
+    );
+  }
+  for (const chunk of drained) {
+    next.sendAudio(chunk);
+  }
+  const dropped = prev.drainDroppedEvents();
+  if (Object.keys(dropped).length > 0) {
+    console.info(
+      `[PREWARM] dropped events during prewarm call_id=${callId} events=${JSON.stringify(dropped)}`
+    );
+  }
+  return flushed;
+}
+
 // src/agent/pipeline/pipeline-session.ts
 var PipelineSession = class {
   _stt;
@@ -2425,12 +2616,17 @@ var PipelineSession = class {
       this._tts.setLogger(logger);
     }
   }
-  async start(callSession, tools) {
-    this._callSession = callSession;
-    this._tools = tools ?? null;
+  /**
+   * Pre-bootstrap conversation state and (optionally) trigger greeting synthesis
+   * before a real CallSession is attached. Audio chunks are buffered into a
+   * BufferingCall until attach() flushes them.
+   */
+  async prewarm(tools) {
+    if (tools) this._tools = tools;
+    this._callSession = new BufferingCall();
     this._running = true;
-    this._log.info("PipelineSession started");
     this._conversation = [];
+    this._log.info("PipelineSession prewarmed");
     if (this._systemPrompt) {
       this._conversation.push({
         role: "system",
@@ -2446,6 +2642,17 @@ var PipelineSession = class {
       this._log.error({ err }, "STT loop error");
     });
   }
+  /** Attach a real CallSession to the prewarmed session and flush buffered audio. */
+  async attach(callSession) {
+    const prev = this._callSession;
+    this._callSession = callSession;
+    attachBuffered(prev, callSession);
+  }
+  async start(callSession, tools) {
+    this._tools = tools ?? null;
+    await this.prewarm();
+    await this.attach(callSession);
+  }
   feedAudio(audio) {
     if (this._running) {
       this._audioBuffer.push(audio);
@@ -2552,7 +2759,7 @@ var PipelineSession = class {
     const { id, name, arguments: argsStr } = chunk.toolCall;
     try {
       const args = JSON.parse(argsStr);
-      if (BUILTIN_TOOL_NAMES.has(name) && this._callSession) {
+      if (BUILTIN_TOOL_NAMES.has(name) && this._callSession && !(this._callSession instanceof BufferingCall)) {
         const result2 = await executeBuiltinTool(name, args, this._callSession);
         if (result2 !== null) {
           if (name === "hang_up") return;
@@ -2563,7 +2770,7 @@ var PipelineSession = class {
       }
       if (!this._tools) return;
       this._callSession?.recordToolCall();
-      const player = this._holdAudioChunks && this._callSession ? new HoldAudioPlayer(this._callSession, this._holdAudioChunks) : null;
+      const player = this._holdAudioChunks && this._callSession && !(this._callSession instanceof BufferingCall) ? new HoldAudioPlayer(this._callSession, this._holdAudioChunks) : null;
       player?.start();
       let result;
       try {
@@ -2706,24 +2913,23 @@ var OpenAIRealtime = class {
   setHoldAudio(chunks) {
     this._holdAudioChunks = chunks;
   }
-  async start(callSession, tools) {
-    this._call = callSession;
+  /** Open WS + session.update + (optional) response.create without a CallSession. */
+  async prewarm(tools) {
     if (tools) this._tools = tools;
+    this._call = new BufferingCall();
     this._closed = false;
     this._playback = null;
     this._latestMediaTs = 0;
     const { WebSocket } = await import('ws');
     const url = `${OPENAI_REALTIME_URL}${this._model}`;
     this._ws = new WebSocket(url, {
-      headers: {
-        Authorization: `Bearer ${this._apiKey}`
-      }
+      headers: { Authorization: `Bearer ${this._apiKey}` }
     });
     return new Promise((resolve, reject) => {
       const ws = this._ws;
       ws.on("open", () => {
         this._sendSessionUpdate();
-        this._log.info("OpenAI Realtime connected");
+        this._log.info("OpenAI Realtime connected (prewarm)");
         if (this._greeting) {
           this._send({ type: "response.create" });
         }
@@ -2747,6 +2953,17 @@ var OpenAIRealtime = class {
       });
     });
   }
+  /** Attach a real CallSession to the prewarmed session and flush buffered audio. */
+  async attach(callSession) {
+    const prev = this._call;
+    this._call = callSession;
+    attachBuffered(prev, callSession);
+  }
+  async start(callSession, tools) {
+    if (tools) this._tools = tools;
+    await this.prewarm();
+    await this.attach(callSession);
+  }
   async feedDtmf(digits) {
     await this._waitForResponseDone();
     this._send({
@@ -2775,8 +2992,27 @@ var OpenAIRealtime = class {
     }
     this._pendingToolCalls.clear();
     if (this._ws) {
-      this._ws.close();
+      const ws = this._ws;
       this._ws = null;
+      await new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          resolve();
+        };
+        const timer = setTimeout(finish, 2e3);
+        try {
+          ws.on("close", () => {
+            clearTimeout(timer);
+            finish();
+          });
+          ws.close();
+        } catch {
+          clearTimeout(timer);
+          finish();
+        }
+      });
     }
   }
   _sendSessionUpdate() {
@@ -2927,7 +3163,7 @@ var OpenAIRealtime = class {
     const controller = new AbortController();
     this._pendingToolCalls.set(callId, controller);
     try {
-      if (BUILTIN_TOOL_NAMES.has(funcName) && this._call) {
+      if (BUILTIN_TOOL_NAMES.has(funcName) && this._call && !(this._call instanceof BufferingCall)) {
         const args = JSON.parse(item["arguments"] ?? "{}");
         const result2 = await executeBuiltinTool(funcName, args, this._call);
         if (result2 !== null) {
@@ -2961,7 +3197,7 @@ var OpenAIRealtime = class {
         return;
       }
       let result;
-      const player = this._holdAudioChunks && this._call ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
+      const player = this._holdAudioChunks && this._call && !(this._call instanceof BufferingCall) ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
       player?.start();
       try {
         const args = JSON.parse(item["arguments"] ?? "{}");
@@ -3146,9 +3382,10 @@ var GeminiRealtime = class _GeminiRealtime {
       builtinTools: []
     };
   }
-  async start(callSession, tools) {
-    this._call = callSession;
+  /** Open Live session (no CallSession). Audio deltas accumulate into BufferingCall until attach(). */
+  async prewarm(tools) {
     if (tools) this._tools = tools;
+    this._call = new BufferingCall();
     this._closed = false;
     this._sentAudioChunks = 0;
     this._audioRemainder = Buffer.alloc(0);
@@ -3196,10 +3433,22 @@ var GeminiRealtime = class _GeminiRealtime {
         }
       }
     });
+    this._log.info("Gemini Live connected (prewarm)");
     if (this._greeting) {
       this._session.sendRealtimeInput({ text: "\uC778\uC0AC\uD574 \uC8FC\uC138\uC694." });
     }
   }
+  /** Attach a real CallSession to the prewarmed session and flush buffered audio. */
+  async attach(callSession) {
+    const prev = this._call;
+    this._call = callSession;
+    attachBuffered(prev, callSession);
+  }
+  async start(callSession, tools) {
+    if (tools) this._tools = tools;
+    await this.prewarm();
+    await this.attach(callSession);
+  }
   feedAudio(audio) {
     if (this._session && !this._closed) {
       const pcm8k = ulawToPcm16(audio);
@@ -3225,11 +3474,18 @@ var GeminiRealtime = class _GeminiRealtime {
     }
     this._pendingToolCall = null;
     if (this._session) {
-      try {
-        this._session.close();
-      } catch {
-      }
+      const sess = this._session;
       this._session = null;
+      await Promise.race([
+        (async () => {
+          try {
+            const ret = sess.close();
+            if (ret && typeof ret.then === "function") await ret;
+          } catch {
+          }
+        })(),
+        new Promise((resolve) => setTimeout(resolve, 2e3))
+      ]);
     }
   }
   _buildToolSchemas() {
@@ -3344,7 +3600,7 @@ var GeminiRealtime = class _GeminiRealtime {
     const functionCalls = toolCall.functionCalls;
     if (!functionCalls) return;
     const responses = [];
-    const player = this._holdAudioChunks && this._call ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
+    const player = this._holdAudioChunks && this._call && !(this._call instanceof BufferingCall) ? new HoldAudioPlayer(this._call, this._holdAudioChunks) : null;
     player?.start();
     try {
       for (const fc of functionCalls) {
@@ -3352,7 +3608,7 @@ var GeminiRealtime = class _GeminiRealtime {
         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) {
+        if (BUILTIN_TOOL_NAMES.has(name) && this._call && !(this._call instanceof BufferingCall)) {
           const result = await executeBuiltinTool(
             name,
             args,