fix(voice): don't re-issue in-flight tool calls

agents/src/voice/agent_activity.ts

@@ -115,12 +115,14 @@ import {
   type _AudioOut,
   type _TextOut,
   applyInstructionsModality,
+  injectRunningToolCalls,
   performAudioForwarding,
   performLLMInference,
   performTTSInference,
   performTextForwarding,
   performToolExecutions,
   removeInstructions,
+  stripRunningToolCalls,
   updateInstructions,
 } from './generation.js';
 import type { PlaybackFinishedEvent, TimedString } from './io.js';
@@ -2560,6 +2562,8 @@ export class AgentActivity implements RecognitionHooks {
     // apply the correct variant of the instructions for the turn's input modality
     applyInstructionsModality(chatCtx, { modality: speechHandle.inputDetails.modality });
 
+    injectRunningToolCalls(chatCtx, this.runningToolCalls());
+
     const tasks: Array<Task<void>> = [];
     const [llmTask, llmGenData] = performLLMInference(
       // preserve  `this` context in llmNode
@@ -3062,6 +3066,7 @@ export class AgentActivity implements RecognitionHooks {
       ...functionToolsExecutedEvent.functionCallOutputs,
     ] as ChatItem[];
     if (shouldGenerateToolReply) {
+      stripRunningToolCalls(chatCtx);
       chatCtx.insert(toolMessages);
 
       // Increment step count on the existing handle.
@@ -3854,6 +3859,26 @@ export class AgentActivity implements RecognitionHooks {
     this.wakeupMainTask();
   }
 
+  private runningToolCalls(): FunctionCall[] {
+    const runningCalls: FunctionCall[] = [];
+
+    for (const speech of this._backgroundSpeeches) {
+      const completedCallIds = new Set(
+        speech.chatItems
+          .filter((item) => item.type === 'function_call_output')
+          .map((item) => item.callId),
+      );
+
+      for (const item of speech.chatItems) {
+        if (item.type === 'function_call' && !completedCallIds.has(item.callId)) {
+          runningCalls.push(item);
+        }
+      }
+    }
+
+    return runningCalls;
+  }
+
   private async _pauseSchedulingTask(blockedTasks: Task<any>[]): Promise<void> {
     if (this._schedulingPaused) return;
 

agents/src/voice/generation.ts

@@ -81,6 +81,68 @@ export class _LLMGenerationData {
   }
 }
 
+const RUNNING_TOOL_PLACEHOLDER = 'The tool call is still in progress.';
+const RUNNING_PLACEHOLDER_KEY = '__lk_running_placeholder__';
+
+/** @internal */
+export function injectRunningToolCalls(
+  chatCtx: ChatContext,
+  runningCalls: Iterable<FunctionCall>,
+  placeholder: string = RUNNING_TOOL_PLACEHOLDER,
+): void {
+  const existing = new Set(
+    chatCtx.items.flatMap((item) =>
+      item.type === 'function_call' || item.type === 'function_call_output' ? [item.callId] : [],
+    ),
+  );
+
+  for (const fncCall of runningCalls) {
+    if (existing.has(fncCall.callId)) continue;
+    existing.add(fncCall.callId);
+
+    chatCtx.insert([
+      FunctionCall.create({
+        id: fncCall.id,
+        callId: fncCall.callId,
+        name: fncCall.name,
+        args: fncCall.args,
+        createdAt: fncCall.createdAt,
+        extra: { ...fncCall.extra, [RUNNING_PLACEHOLDER_KEY]: true },
+        groupId: fncCall.groupId,
+        thoughtSignature: fncCall.thoughtSignature,
+      }),
+      FunctionCallOutput.create({
+        callId: fncCall.callId,
+        name: fncCall.name,
+        output: placeholder,
+        isError: false,
+        createdAt: fncCall.createdAt,
+      }),
+    ]);
+  }
+}
+
+/** @internal */
+export function stripRunningToolCalls(chatCtx: ChatContext): void {
+  const flagged = new Set(
+    chatCtx.items.flatMap((item) =>
+      item.type === 'function_call' && item.extra[RUNNING_PLACEHOLDER_KEY] === true
+        ? [item.callId]
+        : [],
+    ),
+  );
+
+  if (flagged.size === 0) return;
+
+  chatCtx.items = chatCtx.items.filter(
+    (item) =>
+      !(
+        (item.type === 'function_call' || item.type === 'function_call_output') &&
+        flagged.has(item.callId)
+      ),
+  );
+}
+
 /**
  * TTS generation data containing audio stream and optional timed transcripts.
  * @internal