/**
 * @file message-handler.ts
 * @description WebSocket 消息处理器
 *
 * 负责处理从 AGP 服务端收到的下行消息，核心流程：
 *   1. 收到 session.prompt → 调用 OpenClaw Agent 处理用户指令
 *   2. 通过 runtime.events.onAgentEvent 监听 Agent 的流式输出
 *   3. 将流式输出实时通过 WebSocket 推送给服务端（session.update）
 *   4. Agent 处理完成后发送最终结果（session.promptResponse）
 *   5. 收到 session.cancel → 中断正在处理的 Turn
 */

import type {
  PromptMessage,
  CancelMessage,
  ContentBlock,
  ToolCall,
} from "./types.js";
import { onAgentEvent, type AgentEventPayload } from "../common/agent-events.js";
import type { WechatAccessWebSocketClient } from "./websocket-client.js";

/** 内容安全审核拦截标记，由 content-security 插件的 fetch 拦截器嵌入伪 SSE 响应中 */
const SECURITY_BLOCK_MARKER = "<!--CONTENT_SECURITY_BLOCK-->";

/** 安全拦截后返回给微信用户的通用提示文本（不暴露具体拦截原因） */
const SECURITY_BLOCK_USER_MESSAGE = "抱歉，我无法处理该任务，让我们换个任务试试看？";

/**
 * `getWecomRuntime` 返回 OpenClaw 框架注入的运行时实例（PluginRuntime）。
 * 运行时提供了访问框架核心功能的统一入口，包括：
 *   - runtime.config.loadConfig()：读取 openclaw 配置文件（~/.openclaw/config.json）
 *   - runtime.events.onAgentEvent()：订阅 Agent 运行时事件（流式输出、工具调用等）
 *   - runtime.channel.session：会话元数据管理（记录用户会话信息）
 *   - runtime.channel.activity：渠道活动统计（记录收发消息次数）
 *   - runtime.channel.reply：消息回复调度（调用 Agent 并分发回复）
 */
import { getWecomRuntime } from "../common/runtime.js";
import {
  extractTextFromContent,
  buildWebSocketMessageContext,
} from "./message-adapter.js";

// ============================================
// WebSocket 消息处理器
// ============================================
// 接收 AGP 下行消息 → 调用 OpenClaw Agent → 发送 AGP 上行消息

/**
 * 活跃的 Prompt Turn 追踪器
 * @description
 * 每个正在处理中的用户请求（Turn）都会在 activeTurns Map 中注册一条记录。
 * 用于支持取消操作：收到 session.cancel 时，通过 promptId 找到对应的 Turn，
 * 将其标记为已取消，并取消 Agent 事件订阅。
 */
interface ActiveTurn {
  sessionId: string;
  promptId: string;
  /** 是否已被取消（标志位，Agent 事件回调中检查此值决定是否继续处理） */
  cancelled: boolean;
  /**
   * Agent 事件取消订阅函数。
   * `runtime.events.onAgentEvent()` 返回一个函数，调用该函数可以取消订阅，
   * 停止接收后续的 Agent 事件（类似 EventEmitter 的 removeListener）。
   */
  unsubscribe?: () => void;
}

/**
 * 当前活跃的 Turn 映射（promptId → ActiveTurn）
 * @description
 * 使用 Map 而非对象，因为 Map 的 key 可以是任意类型，且有更好的增删性能。
 * promptId 是服务端分配的唯一 Turn ID，用于关联 prompt 和 cancel 消息。
 */
const activeTurns = new Map<string, ActiveTurn>();

/**
 * 处理 session.prompt 消息 — 接收用户指令并调用 Agent
 * @param message - AGP session.prompt 消息（包含用户指令内容）
 * @param client - WebSocket 客户端实例（用于发送上行消息回服务端）
 * @description
 * 完整处理流程：
 *
 * ```
 * 服务端 → session.prompt
 *   ↓
 * 1. 注册 ActiveTurn（支持后续取消）
 *   ↓
 * 2. getWecomRuntime() 获取运行时
 *   ↓
 * 3. runtime.config.loadConfig() 读取配置
 *   ↓
 * 4. buildWebSocketMessageContext() 构建消息上下文（路由、会话路径等）
 *   ↓
 * 5. runtime.channel.session.recordSessionMetaFromInbound() 记录会话元数据
 *   ↓
 * 6. runtime.channel.activity.record() 记录入站活动统计
 *   ↓
 * 7. runtime.events.onAgentEvent() 订阅 Agent 流式事件
 *   ↓
 * 8. runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher() 调用 Agent
 *   ↓ （Agent 运行期间，步骤 7 的回调持续触发）
 *   ├── assistant 流 → client.sendMessageChunk() → session.update(message_chunk)
 *   └── tool 流 → client.sendToolCall/sendToolCallUpdate() → session.update(tool_call)
 *   ↓
 * 9. client.sendPromptResponse() → session.promptResponse（最终结果）
 * ```
 */
export const handlePrompt = async (
  message: PromptMessage,
  client: WechatAccessWebSocketClient
): Promise<void> => {
  const { payload } = message;
  const { session_id: sessionId, prompt_id: promptId } = payload;
  const userId = message.user_id ?? "";
  const guid = message.guid ?? "";
  //message {
  //   msg_id: '9b842a47-c07d-4307-974f-42a4f8eeecb4',
  //       guid: '0ef9cc5e5dcb7ca068b0fb9982352c33',
  //       user_id: '3730000',
  //       method: 'session.prompt',
  //       payload: {
  //     session_id: '384f885b-4387-4f2b-9233-89a5fe6f94ee',
  //         prompt_id: 'ca694ac8-35e3-4e8b-9ecc-88efd4324515',
  //         agent_app: 'agent_demo',
  //         content: [ [Object] ]
  //   }
  // }
  const textContent = extractTextFromContent(payload.content);
  console.log("[wechat-access-ws] 收到 prompt:", payload);

  // ============================================
  // 1. 注册活跃 Turn
  // ============================================
  // 在 activeTurns Map 中注册此次请求，以便 handleCancel 能找到并取消它
  const turn: ActiveTurn = {
    sessionId,
    promptId,
    cancelled: false,
  };
  activeTurns.set(promptId, turn);

  try {
    /**
     * getWecomRuntime() 返回 OpenClaw 框架的运行时实例（PluginRuntime）。
     * 这是一个单例，在插件初始化时由 setWecomRuntime(api.runtime) 注入。
     * 如果未初始化就调用会抛出错误。
     */
    const runtime = getWecomRuntime();

    /**
     * runtime.config.loadConfig() 同步读取 OpenClaw 配置文件。
     * 配置文件通常位于 ~/.openclaw/config.json，包含：
     *   - Agent 配置（模型、系统提示词等）
     *   - 渠道配置（各渠道的账号信息）
     *   - 会话存储路径等
     * 返回的 cfg 对象在后续的 dispatchReplyWithBufferedBlockDispatcher 中使用。
     */
    const cfg = runtime.config.loadConfig();

    // ============================================
    // 2. 构建消息上下文
    // ============================================
    /**
     * buildWebSocketMessageContext() 将 AGP 消息转换为 OpenClaw 内部的消息上下文格式。
     * 返回值包含：
     *   - ctx: MsgContext — 消息上下文（包含 From、To、SessionKey、AgentId 等字段）
     *   - route: 路由信息（agentId、accountId、sessionKey 等）
     *   - storePath: 会话存储文件路径（如 ~/.openclaw/sessions/agent-xxx.json）
     *
     * 这样可以复用 HTTP 通道的路由和会话管理逻辑，保持一致性。
     */
    const { ctx, route, storePath } = buildWebSocketMessageContext(payload, userId);

    console.log("[wechat-access-ws] 路由信息:", {
      sessionKey: route.sessionKey,
      agentId: route.agentId,
      accountId: route.accountId,
    });

    // ============================================
    // 3. 记录会话元数据
    // ============================================
    /**
     * runtime.channel.session.recordSessionMetaFromInbound() 将本次消息的元数据
     * 写入会话存储文件（storePath 指向的 JSON 文件）。
     * 元数据包括：用户 ID、渠道类型、最后活跃时间等。
     * 这些数据用于会话管理、上下文恢复等功能。
     *
     * 使用 void + .catch() 的原因：
     *   - void: 明确表示不等待此 Promise（不阻塞主流程）
     *   - .catch(): 捕获错误并打印日志，避免未处理的 Promise rejection
     * 会话元数据写入失败不影响消息处理，所以不需要 await。
     */
    void runtime.channel.session
      .recordSessionMetaFromInbound({
        storePath,
        sessionKey: (ctx.SessionKey as string) ?? route.sessionKey,
        ctx,
      })
      .catch((err: unknown) => {
        console.log(`[wechat-access-ws] 记录会话元数据失败: ${String(err)}`);
      });

    // ============================================
    // 4. 记录入站活动
    // ============================================
    /**
     * runtime.channel.activity.record() 记录渠道活动统计数据。
     * direction: "inbound" 表示这是一条收到的消息（用户 → 系统）。
     * 这些统计数据用于 OpenClaw 控制台的活动监控面板。
     */
    runtime.channel.activity.record({
      channel: "wechat-access-unqclawed",
      accountId: route.accountId ?? "default",
      direction: "inbound",
    });

    // ============================================
    // 5. 订阅 Agent 事件（流式输出）
    // ============================================
    /**
     * runtime.events.onAgentEvent() 注册一个全局 Agent 事件监听器。
     * 当 Agent 运行时，会通过事件总线（EventEmitter）广播各种事件。
     *
     * AgentEventPayload 结构：
     * {
     *   runId: string;      // Agent 运行实例 ID
     *   seq: number;        // 事件序号（严格递增，用于检测丢失事件）
     *   stream: string;     // 事件流类型（见下方说明）
     *   ts: number;         // 时间戳（毫秒）
     *   data: Record<string, unknown>; // 事件数据（不同 stream 有不同结构）
     *   sessionKey?: string; // 关联的会话 key
     * }
     *
     * stream 类型说明：
     *   - "assistant": AI 助手的文本输出流
     *     data.delta: 增量文本（本次新增的部分）
     *     data.text: 累积文本（从开始到现在的完整文本）
     *   - "tool": 工具调用流
     *     data.phase: 阶段（"start" | "update" | "result"）
     *     data.name: 工具名称（如 "read_file"、"write"）
     *     data.toolCallId: 工具调用唯一 ID
     *     data.args: 工具参数（phase=start 时）
     *     data.result: 工具执行结果（phase=result 时）
     *     data.isError: 是否执行失败（phase=result 时）
     *   - "lifecycle": 生命周期事件（start/end/error）
     *   - "compaction": 上下文压缩事件
     *
     * 返回值是取消订阅函数，调用后停止接收事件。
     * 注意：这是全局事件总线，所有 Agent 运行的事件都会触发此回调，
     * 但目前没有按 runId 过滤（因为同一时间通常只有一个 Agent 在运行）。
     */
    let lastEmittedText = ""; // 记录已发送的累积文本，用于计算增量
    let toolCallCounter = 0;  // 工具调用计数器，用于生成备用 toolCallId

    // await 确保 SDK 加载完成、监听器真正挂载后，再调用 dispatchReply
    // 否则 Agent 产生事件时监听器还未注册，导致所有事件丢失
    const unsubscribe = await onAgentEvent((evt: AgentEventPayload) => {
      // 如果 Turn 已被取消，忽略后续事件（不再向服务端推送）
      if (turn.cancelled) return;
      // 过滤非本 Turn 的事件，避免并发多个 prompt 时事件串流
      if (evt.sessionKey && evt.sessionKey !== route.sessionKey) return;

      const data = evt.data as Record<string, unknown>;

      // --- 处理流式文本（assistant 流）---
      if (evt.stream === "assistant") {
        /**
         * Agent 生成文本时，事件总线会持续触发 assistant 流事件。
         * 每个事件包含：
         *   - data.delta: 本次新增的文本片段（增量）
         *   - data.text: 从开始到现在的完整文本（累积）
         *
         * 优先使用 delta（增量），因为它直接就是需要发送的内容。
         * 如果没有 delta（某些 AI 提供商只提供累积文本），
         * 则通过 text.slice(lastEmittedText.length) 手动计算增量。
         */
      const delta = data.delta as string | undefined;
        const text = data.text as string | undefined;

        let textToSend = delta;
        if (!textToSend && text && text !== lastEmittedText) {
          // 手动计算增量：新的累积文本 - 已发送的累积文本 = 本次增量
          textToSend = text.slice(lastEmittedText.length);
          lastEmittedText = text;
        } else if (delta) {
          lastEmittedText += delta;
        }

        // 检测安全审核拦截标记：如果流式文本中包含拦截标记，停止向用户推送
        // 拦截标记由 content-security 插件的 fetch 拦截器注入伪 SSE 响应
        if (textToSend && textToSend.includes(SECURITY_BLOCK_MARKER)) {
          console.warn("[wechat-access-ws] 流式文本中检测到安全审核拦截标记，停止推送");
          turn.cancelled = true; // 标记为已取消，阻止后续流式事件继续推送
          return;
        }
        if (lastEmittedText.includes(SECURITY_BLOCK_MARKER)) {
          console.warn("[wechat-access-ws] 累积文本中检测到安全审核拦截标记，停止推送");
          turn.cancelled = true;
          return;
        }

        if (textToSend) {
          // 将增量文本作为 session.update(message_chunk) 发送给服务端
          client.sendMessageChunk(sessionId, promptId, {
            type: "text",
            text: textToSend,
          }, guid, userId);
        }
        return;
      }

      // --- 处理工具调用事件（tool 流）---
      if (evt.stream === "tool") {
        /**
         * 工具调用有三个阶段（phase）：
         *   - "start": 工具开始执行（发送 tool_call，status=in_progress）
         *   - "update": 工具执行中有中间结果（发送 tool_call_update，status=in_progress）
         *   - "result": 工具执行完成（发送 tool_call_update，status=completed/failed）
         *
         * toolCallId 是工具调用的唯一标识，用于关联同一次工具调用的多个事件。
         * 如果 Agent 没有提供 toolCallId，则用计数器生成一个备用 ID。
         */
        const phase = data.phase as string | undefined;
        const toolName = data.name as string | undefined;
        const toolCallId = (data.toolCallId as string) || `tc-${++toolCallCounter}`;

        if (phase === "start") {
          // 工具开始执行：通知服务端展示工具调用状态（进行中）
          const toolCall: ToolCall = {
            tool_call_id: toolCallId,
            title: toolName,
            kind: mapToolKind(toolName), // 根据工具名推断工具类型（read/edit/search 等）
            status: "in_progress",
          };
          client.sendToolCall(sessionId, promptId, toolCall, guid, userId);
        } else if (phase === "update") {
          // 工具执行中有中间结果（如读取文件的部分内容）
          const toolCall: ToolCall = {
            tool_call_id: toolCallId,
            title: toolName,
            status: "in_progress",
            content: data.text
              ? [{ type: "text" as const, text: data.text as string }]
              : undefined,
          };
          client.sendToolCallUpdate(sessionId, promptId, toolCall, guid, userId);
        } else if (phase === "result") {
          // 工具执行完成：更新状态为 completed 或 failed
          const isError = data.isError as boolean | undefined;
          const toolCall: ToolCall = {
            tool_call_id: toolCallId,
            title: toolName,
            status: isError ? "failed" : "completed",
            // 将工具执行结果作为内容块附加（可选，用于展示）
            content: data.result
              ? [{ type: "text" as const, text: data.result as string }]
              : undefined,
          };
          client.sendToolCallUpdate(sessionId, promptId, toolCall, guid, userId);
        }
        return;
      }
    });

    // 将取消订阅函数保存到 Turn 记录中，以便 handleCancel 调用
    turn.unsubscribe = unsubscribe;

    // ============================================
    // 6. 调用 Agent 处理消息
    // ============================================
    /**
     * runtime.channel.reply.resolveEffectiveMessagesConfig() 解析当前 Agent 的消息配置。
     * 返回值包含：
     *   - responsePrefix: 回复前缀（如果配置了的话）
     *   - 其他消息格式配置
     * 参数 route.agentId 指定要查询哪个 Agent 的配置。
     */
    const messagesConfig = runtime.channel.reply.resolveEffectiveMessagesConfig(
      cfg,
      route.agentId
    );

    let finalText: string | null = null;

    /**
     * runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher() 是核心调用。
     * 它完成以下工作：
     *   1. 根据 ctx（消息上下文）和 cfg（配置）确定使用哪个 Agent
     *   2. 加载该 Agent 的历史会话记录（上下文）
     *   3. 调用 AI 模型生成回复（流式）
     *   4. 在生成过程中，通过事件总线广播 assistant/tool 流事件（步骤 5 的回调会收到）
     *   5. 将生成的回复通过 dispatcherOptions.deliver 回调交付
     *   6. 保存本次对话到会话历史
     *
     * "BufferedBlockDispatcher" 的含义：
     *   - Buffered: 将流式输出缓冲后再交付（避免过于频繁的回调）
     *   - Block: 按块（段落/句子）分割回复
     *   - Dispatcher: 负责将回复分发给 deliver 回调
     *
     * 返回值 { queuedFinal } 包含最终排队的回复内容（此处未使用，通过 deliver 回调获取）。
     *
     * 注意：此函数是 async 的，会等待 Agent 完全处理完毕才 resolve。
     * 在等待期间，步骤 5 注册的 onAgentEvent 回调会持续被触发（流式推送）。
     */
    const { queuedFinal } = await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
      ctx,
      cfg,
      dispatcherOptions: {
        responsePrefix: messagesConfig.responsePrefix,
        /**
         * deliver 回调：当 Agent 生成了一个完整的回复块时调用。
         * @param payload - 回复内容（text、mediaUrl 等）
         * @param info - 回复元信息（kind: "final" | "chunk" | "error" 等）
         *
         * 这里主要用于：
         *   1. 捕获最终回复文本（finalText）
         *   2. 记录出站活动统计
         *
         * 注意：流式文本已经通过 onAgentEvent 的 assistant 流实时推送了，
         * 这里的 deliver 是最终汇总的回调，用于获取完整的最终文本。
         */
        deliver: async (
          payload: {
            text?: string;
            mediaUrl?: string;
            mediaUrls?: string[];
            isError?: boolean;
            channelData?: unknown;
          },
          info: { kind: string }
        ) => {
          if (turn.cancelled) return;

          console.log(`[wechat-access-ws] Agent ${info.kind} 回复:`, payload.text?.slice(0, 50));

          // 保存最终回复文本，用于构建 session.promptResponse 的 content
          // 不限制 kind，只要有 text 就更新（final/chunk 都可能携带完整文本）
          if (payload.text) {
            // 检测安全审核拦截标记：如果回复文本包含拦截标记，
            // 替换为通用安全提示，不向用户暴露具体拦截原因和内部标记
            if (payload.text.includes(SECURITY_BLOCK_MARKER)) {
              console.warn("[wechat-access-ws] deliver 回复中检测到安全审核拦截标记，替换为安全提示");
              finalText = SECURITY_BLOCK_USER_MESSAGE;
            } else {
              finalText = payload.text;
            }
          }

          // 记录出站活动统计（每次 deliver 都算一次出站）
          runtime.channel.activity.record({
            channel: "wechat-access-unqclawed",
            accountId: route.accountId ?? "default",
            direction: "outbound",
          });
        },
        onError: (err: unknown, info: { kind: string }) => {
          console.error(`[wechat-access-ws] Agent ${info.kind} 回复失败:`, err);
        },
      },
      replyOptions: {},
    });

    // ============================================
    // 7. 发送最终结果
    // ============================================
    // Agent 处理完成，取消事件订阅并清理 Turn 记录
    unsubscribe();
    activeTurns.delete(promptId);

    if (turn.cancelled) {
      // 如果在 Agent 处理期间收到了 cancel 消息，发送 cancelled 响应
      client.sendPromptResponse({
        session_id: sessionId,
        prompt_id: promptId,
        stop_reason: "cancelled",
      }, guid, userId);
      return;
    }

    // 构建最终内容块（如果有文本回复的话）
    // 优先用 deliver 回调收到的 finalText，兜底用流式事件累积的 lastEmittedText
    let replyText = finalText || (lastEmittedText.trim() ? lastEmittedText : null);

    // 最后一道防线：检查最终回复文本是否包含安全拦截标记
    // 正常情况下 deliver 回调和流式事件中已经处理过了，这里是兜底
    if (replyText && replyText.includes(SECURITY_BLOCK_MARKER)) {
      console.warn("[wechat-access-ws] 最终回复文本中检测到安全审核拦截标记，替换为安全提示");
      replyText = SECURITY_BLOCK_USER_MESSAGE;
    }

    const responseContent: ContentBlock[] = replyText
      ? [{ type: "text", text: replyText }]
      : [];

    // 发送 session.promptResponse，告知服务端本次 Turn 已正常完成
    client.sendPromptResponse({
      session_id: sessionId,
      prompt_id: promptId,
      stop_reason: "end_turn",
      content: responseContent,
    }, guid, userId);

    console.log("[wechat-access-ws] prompt 处理完成:", { promptId, hasReply: !!replyText, finalText: !!finalText, lastEmittedText: lastEmittedText.length });
  } catch (err) {
    // ============================================
    // 错误处理
    // ============================================
    console.error("[wechat-access-ws] prompt 处理失败:", err);

    // 清理活跃 Turn（取消事件订阅，从 Map 中移除）
    const currentTurn = activeTurns.get(promptId);
    currentTurn?.unsubscribe?.();
    activeTurns.delete(promptId);

    // 发送错误响应，告知服务端本次 Turn 因错误终止
    client.sendPromptResponse({
      session_id: sessionId,
      prompt_id: promptId,
      stop_reason: "error",
      error: err instanceof Error ? err.message : String(err),
    }, guid, userId);
  }
};

/**
 * 处理 session.cancel 消息 — 取消正在处理的 Prompt Turn
 * @param message - AGP session.cancel 消息
 * @param client - WebSocket 客户端实例
 * @description
 * 取消流程：
 * 1. 通过 promptId 在 activeTurns Map 中查找对应的 Turn
 * 2. 将 turn.cancelled 标记为 true（handlePrompt 中的 onAgentEvent 回调会检查此标志）
 * 3. 调用 turn.unsubscribe() 停止接收后续 Agent 事件
 * 4. 从 activeTurns 中移除此 Turn
 * 5. 发送 session.promptResponse（stop_reason: "cancelled"）
 *
 * 注意：取消操作是"尽力而为"的，Agent 可能已经处理完毕，
 * 此时 activeTurns 中找不到对应 Turn，但仍然发送 cancelled 响应。
 */
export const handleCancel = (
  message: CancelMessage,
  client: WechatAccessWebSocketClient
): void => {
  const { session_id: sessionId, prompt_id: promptId } = message.payload;

  console.log("[wechat-access-ws] 收到 cancel:", { sessionId, promptId });

  const turn = activeTurns.get(promptId);
  if (!turn) {
    console.warn(`[wechat-access-ws] 未找到活跃 Turn: ${promptId}`);
    // 即使找不到对应 Turn（可能已处理完毕），也发送 cancelled 响应
    // 确保服务端收到明确的结束信号
    client.sendPromptResponse({
      session_id: sessionId,
      prompt_id: promptId,
      stop_reason: "cancelled",
    });
    return;
  }

  // 标记为已取消：handlePrompt 中的 onAgentEvent 回调会检查此标志，
  // 一旦为 true，后续的流式事件都会被忽略，不再向服务端推送
  turn.cancelled = true;

  // 取消 Agent 事件订阅，停止接收后续事件
  // 可选链 ?.() 是因为 unsubscribe 可能还未赋值（Turn 刚注册但还未到步骤 5）
  turn.unsubscribe?.();
  activeTurns.delete(promptId);

  // 发送 cancelled 响应
  client.sendPromptResponse({
    session_id: sessionId,
    prompt_id: promptId,
    stop_reason: "cancelled",
  });

  console.log("[wechat-access-ws] Turn 已取消:", promptId);
};

// ============================================
// 辅助函数
// ============================================

/**
 * 将工具名称映射为 AGP 协议的 ToolCallKind
 * @param toolName - 工具名称（如 "read_file"、"write"、"grep_search" 等）
 * @returns ToolCallKind 枚举值，用于服务端展示不同类型的工具调用图标
 * @description
 * 通过关键词匹配推断工具类型，映射规则：
 *   - read/get/view → "read"（读取操作）
 *   - write/edit/replace → "edit"（编辑操作）
 *   - delete/remove → "delete"（删除操作）
 *   - search/find/grep → "search"（搜索操作）
 *   - fetch/request/http → "fetch"（网络请求）
 *   - think/reason → "think"（思考/推理）
 *   - exec/run/terminal → "execute"（执行命令）
 *   - 其他 → "other"
 */
const mapToolKind = (toolName?: string): ToolCall["kind"] => {
  if (!toolName) return "other";

  const name = toolName.toLowerCase();
  if (name.includes("read") || name.includes("get") || name.includes("view")) return "read";
  if (name.includes("write") || name.includes("edit") || name.includes("replace")) return "edit";
  if (name.includes("delete") || name.includes("remove")) return "delete";
  if (name.includes("search") || name.includes("find") || name.includes("grep")) return "search";
  if (name.includes("fetch") || name.includes("request") || name.includes("http")) return "fetch";
  if (name.includes("think") || name.includes("reason")) return "think";
  if (name.includes("exec") || name.includes("run") || name.includes("terminal")) return "execute";
  return "other";
};