Function runAgentLoop

packages/bot/src/run-loop.ts:40–112

(
  args: RunLoopArgs,
)

 * with `initialResume` set.
 */
export async function runAgentLoop(
  args: RunLoopArgs,
): Promise<{ iterations: number; interrupted: boolean }> {
  const {
    agent,
    renderer,
    tools,
    toolDescriptors,
    context,
    makeToolCtx,
    handleInterrupt,
    isAborted,
    initialResume,
  } = args;
  const maxIterations = args.maxIterations ?? 6;
  const executed = new Set<string>();
  let resume = initialResume;

  for (let i = 0; i < maxIterations; i++) {
    if (resume) {
      await agent.runAgent(
        { forwardedProps: { command: resume } },
        renderer.subscriber,
      );
      resume = undefined;
    } else {
      await agent.runAgent(
        { tools: toolDescriptors as never, context: context as never },
        renderer.subscriber,
      );
    }
    if (isAborted?.()) return { iterations: i + 1, interrupted: false };

    const pending = renderer.getPendingInterrupt();
    if (pending) {
      renderer.clearPendingInterrupt();
      if (handleInterrupt) await handleInterrupt(pending);
      // ack-first: picker posted; thread.resume re-enters later
      return { iterations: i + 1, interrupted: true };
    }

    const calls = renderer
      .getCapturedToolCalls()
      .filter((c) => tools.has(c.toolCallName) && !executed.has(c.toolCallId));
    if (calls.length === 0) return { iterations: i + 1, interrupted: false };

    ensureAssistantToolCallMessage(agent, calls);
    for (const call of calls) {
      const tool = tools.get(call.toolCallName)!;
      let result: string;
      const parsed = await parseToolArgs(tool.parameters, call.toolCallArgs);
      if (!parsed.ok) {
        result = JSON.stringify({
          error: `invalid arguments: ${parsed.error}`,
        });
      } else {
        try {
          result = stringifyHandlerResult(