#从输入到 LLM 循环：智能体的心脏

async run(): Promise<void> {
  await this.init();

  // ... 异步后台任务、初始消息处理 ...

  // ★ 主循环
  while (true) {
    const userInput = await this.getUserInput();  // ← 挂起在这里等输入
    try {
      await this.session.prompt(userInput);        // ← 输入到达
    } catch (error: unknown) {
      const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
      this.showError(errorMessage);
    }
  }
}

async getUserInput(): Promise<string> {
  return new Promise((resolve) => {
    this.onInputCallback = (text: string) => {
      this.onInputCallback = undefined;
      resolve(text);
    };
  });
}

if (expandPromptTemplates && text.startsWith('/')) {
  const handled = await this._tryExecuteExtensionCommand(text);
  if (handled) {
    return; // 扩展命令已处理，不再发送 LLM
  }
}

if (this._extensionRunner.hasHandlers('input')) {
  const inputResult = await this._extensionRunner.emitInput(
    currentText,
    currentImages,
    options?.source ?? 'interactive',
    this.isStreaming ? options?.streamingBehavior : undefined,
  );
  if (inputResult.action === 'handled') return; // 扩展处理了
  if (inputResult.action === 'transform') {
    // 扩展修改了输入
    currentText = inputResult.text;
    currentImages = inputResult.images ?? currentImages;
  }
}

if (expandPromptTemplates) {
  expandedText = this._expandSkillCommand(expandedText);
  expandedText = expandPromptTemplate(expandedText, [...this.promptTemplates]);
}

if (this.isStreaming) {
  // Agent 正在工作中，输入作为 steer 或 follow-up 排队
  if (options.streamingBehavior === 'followUp') {
    await this._queueFollowUp(expandedText, currentImages);
  } else {
    await this._queueSteer(expandedText, currentImages);
  }
  return;
}

// 检查是否需要压缩上下文
const lastAssistant = this._findLastAssistantMessage();
if (lastAssistant && (await this._checkCompaction(lastAssistant, false))) {
  await this.agent.continue();
  while (await this._handlePostAgentRun()) {
    await this.agent.continue();
  }
}

messages = [];

// 添加用户消息
const userContent: (TextContent | ImageContent)[] = [{ type: 'text', text: expandedText }];
if (currentImages) {
  userContent.push(...currentImages);
}
messages.push({
  role: 'user',
  content: userContent,
  timestamp: Date.now(),
});

// ... 扩展事件、自定义消息 ...

// 最终发送
await this._runAgentPrompt(messages);

private async _runAgentPrompt(messages: AgentMessage[]): Promise<void> {
  try {
    await this.agent.prompt(messages);          // → Agent.prompt()
    while (await this._handlePostAgentRun()) {  // 后处理
      await this.agent.continue();
    }
  } finally {
    this._flushPendingBashMessages();
  }
}

async prompt(input: string | AgentMessage | AgentMessage[], images?: ImageContent[]): Promise<void> {
  if (this.activeRun) {
    throw new Error("Agent is already processing...");
  }
  const messages = this.normalizePromptInput(input, images);
  await this.runPromptMessages(messages);
}

private async runPromptMessages(
  messages: AgentMessage[],
  options: { skipInitialSteeringPoll?: boolean } = {},
): Promise<void> {
  await this.runWithLifecycle(async (signal) => {
    await runAgentLoop(
      messages,                    // 新消息
      this.createContextSnapshot(),// 当前上下文（历史消息 + 系统提示 + 工具）
      this.createLoopConfig(),     // 循环配置（API key、模型、工具执行器等）
      (event) => this.processEvents(event), // 事件回调（用于 TUI 更新）
      signal,                      // 中止信号
      this.streamFn,              // LLM 流式函数
    );
  });
}

async function runLoop(
  initialContext: AgentContext,
  newMessages: AgentMessage[],
  initialConfig: AgentLoopConfig,
  signal: AbortSignal | undefined,
  emit: AgentEventSink,
  streamFn?: StreamFn,
): Promise<void> {
  let currentContext = initialContext;
  let config = initialConfig;
  let firstTurn = true;

  // 启动时检查是否有转向消息（用户可能在等待时输入了）
  let pendingMessages: AgentMessage[] = (await config.getSteeringMessages?.()) || [];

  // ★ 外层循环：有新 follow-up 消息时继续
  while (true) {
    let hasMoreToolCalls = true;

    // ★ 内层循环：处理工具调用
    while (hasMoreToolCalls || pendingMessages.length > 0) {
      if (!firstTurn) {
        await emit({ type: 'turn_start' });
      } else {
        firstTurn = false;
      }

      // ① 注入 pending messages（steer/follow-up）
      if (pendingMessages.length > 0) {
        for (const message of pendingMessages) {
          currentContext.messages.push(message);
          newMessages.push(message);
        }
        pendingMessages = [];
      }

      // ② 调用 LLM，stream 回复
      const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFn);
      newMessages.push(message);

      // ③ 检查是否出错
      if (message.stopReason === 'error' || message.stopReason === 'aborted') {
        return;
      }

      // ④ 提取 tool calls
      const toolCalls = message.content.filter((c) => c.type === 'toolCall');
      hasMoreToolCalls = false;

      if (toolCalls.length > 0) {
        // ⑤ 执行工具
        const executedToolBatch = await executeToolCalls(currentContext, message, config, signal, emit);
        hasMoreToolCalls = !executedToolBatch.terminate;

        // 工具结果写入上下文
        for (const result of executedToolBatch.messages) {
          currentContext.messages.push(result);
          newMessages.push(result);
        }
      }

      await emit({ type: 'turn_end', message, toolResults: executedToolBatch.messages });
    }

    // ⑥ 检查 follow-up 消息
    const followUpMessages = (await config.getFollowUpMessages?.()) || [];
    if (followUpMessages.length > 0) {
      pendingMessages = followUpMessages;
      continue; // 继续外层循环
    }

    break; // 所有完成，退出
  }

  await emit({ type: 'agent_end', messages: newMessages });
}

async function streamAssistantResponse(
  context: AgentContext,
  config: AgentLoopConfig,
  signal: AbortSignal | undefined,
  emit: AgentEventSink,
  streamFn?: StreamFn,
): Promise<AssistantMessage> {
  // ① AgentMessage → LLM Message（格式转换）
  const llmMessages = await config.convertToLlm(messages);

  // ② 构建 LLM Context
  const llmContext: Context = {
    systemPrompt: context.systemPrompt,
    messages: llmMessages,
    tools: context.tools,
  };

  // ③ 解析 API key（处理过期 token）
  const resolvedApiKey =
    (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;

  // ④ 调用 LLM（streaming）
  const response = await streamFunction(config.model, llmContext, {
    ...config,
    apiKey: resolvedApiKey,
    signal,
  });

  // ⑤ 处理流式事件
  for await (const event of response) {
    switch (event.type) {
      case 'start':
        partialMessage = event.partial;
        context.messages.push(partialMessage);
        break;

      case 'text_delta':
      case 'thinking_delta':
      case 'toolcall_delta':
        partialMessage = event.partial;
        context.messages[context.messages.length - 1] = partialMessage;
        await emit({ type: 'message_update', assistantMessageEvent: event, message: { ...partialMessage } });
        break;

      case 'done':
        // 流结束
        break;

      case 'error':
        // 错误处理
        break;
    }
  }

  return partialMessage!;
}