Function runToolCallBatch

packages/agent-core/src/loop/tool-call.ts:123–170

(
  step: ToolCallStepContext,
  response: LLMChatResponse,
)

}

export async function runToolCallBatch(
  step: ToolCallStepContext,
  response: LLMChatResponse,
): Promise<ToolCallBatchResult> {
  if (response.toolCalls.length === 0) return { stopTurn: false };
  const batchStep: ToolCallBatchContext = { ...step, toolCalls: response.toolCalls };
  const calls = response.toolCalls.map((toolCall) => preflightToolCall(step, toolCall));
  const scheduler = new ToolScheduler<PendingToolResult>();
  const pendingResults: Array<Promise<PendingToolResult>> = [];
  let stopTurn = false;

  try {
    for (let index = 0; index < calls.length; index += 1) {
      const call = calls[index]!;
      const prepared = await prepareToolCall(batchStep, call);
      pendingResults.push(scheduler.add(prepared.task));

      if (prepared.stopBatchAfterThis === true) {
        stopTurn = true;
        for (const skippedCall of calls.slice(index + 1)) {
          const skippedTask = await prepareSkippedToolCall(batchStep, skippedCall);
          pendingResults.push(scheduler.add(skippedTask));
        }
        break;
      }
    }

    // Tool tasks may finish out of order; terminal results are still emitted in
    // provider order. Await all tasks so each recorded `tool.call` gets a
    // paired `tool.result`; the caller checks abort before writing `step.end`.
    for (const pendingResult of pendingResults) {
      const result = await finalizePendingToolResult(batchStep, await pendingResult);
      if (result.stopTurn === true) stopTurn = true;
      await step.dispatchEvent({
        type: 'tool.result',
        parentUuid: result.toolCall.id,
        toolCallId: result.toolCall.id,
        result: result.result,
      });
    }
  } finally {
    // Preparation or result dispatch can throw after execution has started.
    // Always settle spawned tasks before the caller continues so rejected
    // execute promises cannot surface as detached unhandled rejections.
    await Promise.allSettled(pendingResults);
  }
  return { stopTurn };
}

/**
 * Provider-order validation pass. It does not run hooks, spawn tools, or write