// Codex 智能编程助手状态管理模块
import { defineStore } from "pinia";
import { ref, computed, nextTick } from "vue";
import {
  startSession,
  addFileToSession,
  removeFileFromSession,
  listSessions,
  restartSession,
  startTurn,
  stopSession,
  listTurns,
  streamSession,
  deleteSession,
  downloadWorkspaceFile,
  submitCommandDecision,
  submitPatchDecision,
  submitFileDecision,
  type StartResult,
  type TurnResponse,
  type CodexTurn,
  type CodexSessionItem,
  type PageResponse,
  type StreamOptions,
} from "@/api/codex";
import { cancelChat } from "@/api/chat";

// 函数调用信息
interface FunctionCall {
  name: string;
  arguments: string;
  callId?: string;
  command?: string[];
  workdir?: string;
}

// Codex 会话消息接口
interface CodexMessage {
  id: string;
  turnId?: number;
  role: "user" | "assistant" | "system";
  content: string;
  createdAt: string;
  updatedAt?: string;
  status?: "pending" | "streaming" | "completed" | "error";
  // 流式输出相关
  isStreaming?: boolean;
  contentChunks?: string[];
  // 审批相关
  pendingApproval?: PendingApproval;
  // 错误信息
  error?: string;
  // 函数调用信息
  functionCall?: FunctionCall;
  /** 本轮用户消息附带的文件（重试回传 fileIds、气泡卡片展示） */
  attachedFiles?: Array<{
    id: number;
    name?: string;
    type?: string;
    /** Codex 工作区路径，有则点击走 open-codex-file */
    filePath?: string;
  }>;
}

// 待审批项
interface PendingApproval {
  approvalId: number;
  type: "command" | "patch";
  title?: string;
  description?: string;
  command?: string;
  fileChangeId?: number;
  filePath?: string;
  changes?: string;
  createdAt: string;
}

// 会话状态
interface CodexSession {
  sessionId: number;
  status: "idle" | "active" | "starting" | "queued" | "stopped";
  queuePosition?: number;
  fileIds: number[];
  messages: CodexMessage[];
  createdAt: string;
  updatedAt?: string;
  codexThreadId?: string | null; // 从 initialized 事件获取
  isInitialized?: boolean; // 是否已初始化
}

export const useCodexStore = defineStore("codex", () => {
  // ==================== State ====================
  const connected = ref(false);
  const connecting = ref(false);
  const connectionError = ref<string | null>(null);

  // 当前会话
  const currentSession = ref<CodexSession | null>(null);
  const sessionLoading = ref(false);
  const sessionError = ref<string | null>(null);

  // 消息列表
  const messages = ref<CodexMessage[]>([]);
  const messagesLoading = ref(false);
  const messagesError = ref<string | null>(null);

  // 流式输出状态
  const streaming = ref(false);
  const streamingError = ref<string | null>(null);
  const currentStream = ref<any>(null);

  // AI 状态
  const aiThinking = ref(false);
  const aiTyping = ref(false);

  // 待审批队列
  const pendingApprovals = ref<PendingApproval[]>([]);

  // 已保存的生成图片路径集
  const savedImagePaths = ref<Set<string>>(new Set());

  // 会话列表
  const sessions = ref<CodexSessionItem[]>([]);
  const sessionsLoading = ref(false);
  const sessionsError = ref<string | null>(null);
  const sessionsTotalPages = ref(0);
  const sessionsTotalElements = ref(0);
  // 会话列表请求去重：并发场景复用同一个 in-flight 请求，避免重复 /session
  const sessionsFetchInFlight = ref<Promise<{ success: boolean; error?: string }> | null>(null);

  const chatDraft = ref("");

  // 会话初始化状态管理
  const sessionInitialized = ref<Map<number, boolean>>(new Map()); // 记录每个会话是否已初始化
  const sessionInitializedPromises = ref<Map<number, {
    resolve: () => void;
    reject: (error: any) => void;
  }>>(new Map()); // 记录每个会话的初始化 Promise

  // 当前活跃的消息映射（用于将流事件路由到正确的消息）
  const activeMessages = ref<Map<number, CodexMessage>>(new Map()); // sessionId -> 当前活跃的助手消息

  // ==================== Computed ====================
  const isSessionActive = computed(() => {
    return currentSession.value?.status === "active";
  });

  const isSessionStarting = computed(() => {
    return currentSession.value?.status === "starting";
  });

  const isSessionQueued = computed(() => {
    return currentSession.value?.status === "queued";
  });

  const hasPendingApprovals = computed(() => {
    return pendingApprovals.value.length > 0;
  });

  const lastMessage = computed(() => {
    return messages.value.length > 0
      ? messages.value[messages.value.length - 1]
      : null;
  });

  // ==================== Actions - Session Management ====================

  /**
   * 开始新会话
   */
  async function createSession(fileIds: number[], title?: string): Promise<{
    success: boolean;
    sessionId?: number;
    status?: string;
    error?: string;
  }> {
    try {
      sessionLoading.value = true;
      sessionError.value = null;

      const response = await startSession({ fileIds });
      const result = response.data as StartResult;

      if (result.status === "unavailable") {
        sessionError.value = "服务暂时不可用";
        return { success: false, error: "服务暂时不可用" };
      }

      if (result.status === "forbidden") {
        sessionError.value = "您没有权限使用此功能";
        return { success: false, error: "您没有权限使用此功能" };
      }

      if (result.sessionId) {
        // 创建新的会话列表项并添加到列表开头
        const newSessionItem: CodexSessionItem = {
          id: result.sessionId,
          userId: 0, // 占位，实际 ID 会在 fetchSessions 时更新
          status: result.status as string,
          createdAt: new Date().toISOString(),
          updatedAt: new Date().toISOString(),
          title: title || `会话 ${result.sessionId}`,
        };
        sessions.value.unshift(newSessionItem);

        // 创建初始化 Promise
        let initializedResolve: (() => void) | undefined;
        let initializedReject: ((error: any) => void) | undefined;
        new Promise<void>((resolve, reject) => {
          initializedResolve = resolve;
          initializedReject = reject;
        });

        sessionInitializedPromises.value.set(result.sessionId, {
          resolve: initializedResolve!,
          reject: initializedReject!,
        });

        currentSession.value = {
          sessionId: result.sessionId,
          status: result.status as any,
          queuePosition: result.position,
          fileIds,
          messages: [],
          createdAt: new Date().toISOString(),
          codexThreadId: null,
          isInitialized: false,
        };

        // 如果是排队状态，显示排队信息
        if (result.status === "queued" && result.position) {
          console.log(`会话创建成功，当前排队位置: ${result.position}`);
        }

        // ⭐ 关键修改：在 /start 返回后立即建立 /stream 连接
        // 只要不是 unavailable 和 forbidden，就建立流式连接（包括 queued 状态）
        if (result.status === "active" || result.status === "starting" || result.status === "queued") {
          // 建立流式连接（不等待消息，用于接收所有事件包括 initialized）
          startStreamingForSession(result.sessionId);
        }

        return {
          success: true,
          sessionId: result.sessionId,
          status: result.status,
        };
      }

      return { success: false, error: "会话创建失败" };
    } catch (error: any) {
      console.error("创建会话失败:", error);
      sessionError.value = error.message || "创建会话失败";
      return { success: false, error: error.message || "创建会话失败" };
    } finally {
      sessionLoading.value = false;
    }
  }

  /**
   * 添加文件到会话
   */
  async function addFiles(
    sessionId: number,
    fileIds: number[],
  ): Promise<{
    success: boolean;
    error?: string;
  }> {
    try {
      sessionLoading.value = true;
      sessionError.value = null;

      await addFileToSession({ sessionId, fileIds });

      // 更新当前会话的文件列表
      if (
        currentSession.value &&
        currentSession.value.sessionId === sessionId
      ) {
        currentSession.value.fileIds = [
          ...Array.from(new Set([...currentSession.value.fileIds, ...fileIds])),
        ];
      }

      return { success: true };
    } catch (error: any) {
      console.error("添加文件失败:", error);
      sessionError.value = error.message || "添加文件失败";
      return { success: false, error: error.message || "添加文件失败" };
    } finally {
      sessionLoading.value = false;
    }
  }

  /**
   * 从会话中删除文件
   */
  async function removeFiles(
    sessionId: number,
    fileIds: number[],
  ): Promise<{
    success: boolean;
    error?: string;
  }> {
    try {
      sessionLoading.value = true;
      sessionError.value = null;

      await removeFileFromSession({ sessionId, fileIds });

      // 更新当前会话的文件列表
      if (
        currentSession.value &&
        currentSession.value.sessionId === sessionId
      ) {
        currentSession.value.fileIds = currentSession.value.fileIds.filter(
          (id) => !fileIds.includes(id),
        );
      }

      return { success: true };
    } catch (error: any) {
      console.error("删除文件失败:", error);
      sessionError.value = error.message || "删除文件失败";
      return { success: false, error: error.message || "删除文件失败" };
    } finally {
      sessionLoading.value = false;
    }
  }

  /**
   * 获取会话列表（分页）
   */
  async function fetchSessions(params?: {
    page?: number;
    size?: number;
  }): Promise<{
    success: boolean;
    error?: string;
  }> {
    // 如果已有进行中的获取请求，直接复用，避免重复请求
    if (sessionsFetchInFlight.value) {
      return sessionsFetchInFlight.value;
    }

    const fetchPromise = (async () => {
    try {
      sessionsLoading.value = true;
      sessionsError.value = null;

      const response = await listSessions(params);
      const pageData = response.data as PageResponse<CodexSessionItem>;

      sessions.value = (pageData.content || []).map((s) => {
        // 优先使用题目或第一个问题，如果 title 是默认生成的则使用 question
        const isDefaultTitle = !s.title || s.title.startsWith("会话 ");
        const displayTitle = (isDefaultTitle && s.question) ? s.question : (s.title || s.topic || s.question || `会话 ${s.id}`);
        
        return {
          ...s,
          title: displayTitle,
        };
      });
      sessionsTotalPages.value = pageData.totalPages || 0;
      sessionsTotalElements.value = pageData.totalElements || 0;

      return { success: true };
    } catch (error: any) {
      console.error("获取会话列表失败:", error);
      sessionsError.value = error.message || "获取会话列表失败";
      return { success: false, error: error.message || "获取会话列表失败" };
    } finally {
      sessionsLoading.value = false;
    }
    })();

    sessionsFetchInFlight.value = fetchPromise;
    try {
      return await fetchPromise;
    } finally {
      sessionsFetchInFlight.value = null;
    }
  }

  /**
   * 选择会话
   */
  async function selectSession(payload: {
    sessionId: number;
    fileIds?: number[];
    fetchTurns?: boolean;
  }): Promise<{ success: boolean; error?: string }> {
    try {
      // ⚠️ 优化：确保会话列表已加载，以便获取真实状态
      // 如果会话不在列表中，尝试刷新会话列表
      let sessionInList = sessions.value.find((s) => s.id === payload.sessionId);
      if (!sessionInList && sessions.value.length === 0) {
        console.log("会话列表为空，尝试加载会话列表");
        await fetchSessions({ page: 0, size: 50 });
        sessionInList = sessions.value.find((s) => s.id === payload.sessionId);
      }

      // ⚠️ 优化：从会话列表获取真实状态，如果不在列表中则默认为 "idle"
      // 注意：CodexSessionItem.status 是 string 类型，可能包含 "failed" 等状态
      const rawStatus = sessionInList?.status || "idle";
      const sessionStatus = rawStatus as "idle" | "active" | "starting" | "queued" | "stopped" | "failed";
      
      console.log(`选择会话 ${payload.sessionId}，当前状态: ${rawStatus}`);
      
      // 设置当前会话
      // ⚠️ 优化：使用从会话列表获取的真实状态，而不是硬编码
      // 将状态转换为 CodexSession 支持的类型（排除 "failed"）
      const normalizedStatus: "idle" | "active" | "starting" | "queued" | "stopped" = 
        (rawStatus === "failed" ? "stopped" : sessionStatus) as any;
      
      currentSession.value = {
        sessionId: payload.sessionId,
        status: normalizedStatus,
        fileIds: payload.fileIds || sessionInList?.fileIds || [],
        messages: [],
        createdAt: sessionInList?.createdAt || new Date().toISOString(),
        updatedAt: sessionInList?.updatedAt,
        codexThreadId: null,
        isInitialized: sessionInitialized.value.get(payload.sessionId) || false,
      };
      
      // ⚠️ 关键修复：如果会话未初始化，建立流式连接等待 initialized 事件
      // 这对于页面刷新后的情况很重要
      if (!currentSession.value.isInitialized) {
        console.log("会话未初始化，建立流式连接等待 initialized 事件");
        startStreamingForSession(payload.sessionId);
      } else if (!currentStream.value || currentSession.value?.sessionId !== payload.sessionId) {
        // 如果已初始化但连接未建立或连接的是其他会话，建立连接
        console.log("会话已初始化但连接未建立，建立 SSE 连接");
        startStreamingForSession(payload.sessionId);
      }

      // 如果需要加载历史消息
      if (payload.fetchTurns) {
        const result = await loadTurns(payload.sessionId);
        if (!result.success) {
          return result;
        }
      }

      return { success: true };
    } catch (error: any) {
      console.error("选择会话失败:", error);
      sessionError.value = error.message || "选择会话失败";
      return { success: false, error: error.message || "选择会话失败" };
    }
  }

  /**
   * 清除当前会话
   */
  function clearCurrentSession(): void {
    // 关闭流式连接
    if (currentStream.value) {
      currentStream.value.close();
      currentStream.value = null;
    }
    
    // 清理当前会话的初始化状态
    if (currentSession.value) {
      const sessionId = currentSession.value.sessionId;
      sessionInitialized.value.delete(sessionId);
      sessionInitializedPromises.value.delete(sessionId);
      activeMessages.value.delete(sessionId);
    }
    
    currentSession.value = null;
    messages.value = [];
    clearErrors();
  }


  /**
   * 停止会话
   */
  async function stop(): Promise<{ success: boolean; error?: string }> {
    try {
      sessionLoading.value = true;
      sessionError.value = null;

      // 关键修复：如果当前有正在进行的流式连接，通知后端终止
      if (currentStream.value && currentSession.value) {
        console.log("通知后端终止流式请求:", currentSession.value.sessionId);
        cancelChat(currentSession.value.sessionId).catch((err) => {
          console.warn("通知后端终止流式请求失败:", err);
        });
      }

      await stopSession();

      // 关闭流式连接
      if (currentStream.value) {
        currentStream.value.close();
        currentStream.value = null;
      }

      // 更新会话状态
      if (currentSession.value) {
        currentSession.value.status = "stopped";
        currentSession.value.updatedAt = new Date().toISOString();
      }

      streaming.value = false;
      aiThinking.value = false;
      aiTyping.value = false;

      // UI 状态闭环：将最后一条助手消息标记为完成
      if (messages.value.length > 0) {
        const lastMsg = messages.value[messages.value.length - 1];
        if (lastMsg && lastMsg.role === 'assistant') {
          if (lastMsg.status === 'pending' || lastMsg.status === 'streaming') {
            lastMsg.status = 'completed';
            lastMsg.isStreaming = false;
          }
        }
      }

      return { success: true };
    } catch (error: any) {
      console.error("停止会话失败:", error);
      sessionError.value = error.message || "停止会话失败";
      return { success: false, error: error.message || "停止会话失败" };
    } finally {
      sessionLoading.value = false;
    }
  }

  /**
   * 删除会话
   */
  async function deleteSessionAction(
    sessionId: number | string,
  ): Promise<{ success: boolean; error?: string }> {
    try {
      await deleteSession(sessionId);

      // 从列表中移除
      sessions.value = sessions.value.filter(
        (s) => String(s.id) !== String(sessionId),
      );

      // 如果删除的是当前会话，清空当前会话
      if (
        currentSession.value &&
        String(currentSession.value.sessionId) === String(sessionId)
      ) {
        clearCurrentSession();
      }

      return { success: true };
    } catch (error: any) {
      console.error("删除会话失败:", error);
      return { success: false, error: error.message || "删除会话失败" };
    }
  }

  /**
   * 清空所有会话
   */
  async function clearAllSessions(): Promise<{
    success: boolean;
    error?: string;
  }> {
    try {
      // 循环删除所有会话
      const sessionIds = sessions.value.map((s) => s.id);
      for (const id of sessionIds) {
        await deleteSession(id);
      }

      sessions.value = [];
      clearCurrentSession();

      return { success: true };
    } catch (error: any) {
      console.error("清空会话失败:", error);
      return { success: false, error: error.message || "清空会话失败" };
    }
  }

  /**
   * 加载会话历史
   */
  async function loadTurns(sessionId: number): Promise<{
    success: boolean;
    error?: string;
  }> {
    try {
      messagesLoading.value = true;
      messagesError.value = null;

      const response = await listTurns(sessionId);
      const turns = response.data as CodexTurn[];

      //   console.log("turns", turns);

      // 将 turns 转换为消息格式
      messages.value = [];
      // attached_files turn 在 user message turn 之前：暂存，绑定到下一条 user message
      let pendingAttachedFiles:
        | Array<{ id: number; name?: string; type?: string; filePath?: string }>
        | null = null;
      for (const turn of turns) {
        try {
          // reply 字段包含多行 JSON，每行是一个事件
          if (turn.reply) {
            const replyLines = turn.reply.split("\n");

            for (const line of replyLines) {
              try {
                if (line.trim()) {
                  const replyData = JSON.parse(line);

                  // 用户附件引用（历史回放）
                  // 约定：attached_files turn 在对应 user message turn 之前出现
                  if (replyData.type === "attached_files") {
                    const fileIds = Array.isArray(replyData.fileIds)
                      ? replyData.fileIds
                      : [];
                    const fileNames = Array.isArray(replyData.fileNames)
                      ? replyData.fileNames
                      : [];
                    const attached = fileIds
                      .map((rawId: any, idx: number) => {
                        const id =
                          typeof rawId === "string"
                            ? parseInt(rawId, 10)
                            : Number(rawId);
                        if (!Number.isFinite(id)) return null;
                        const name = fileNames[idx] || `file-${id}`;
                        return { id, name };
                      })
                      .filter(Boolean) as Array<{
                      id: number;
                      name?: string;
                      type?: string;
                      filePath?: string;
                    }>;

                    pendingAttachedFiles = attached.length > 0 ? attached : null;
                  }

                  // 处理消息类型的事件
                  if (replyData.type === "message") {
                    const role = replyData.role; // "user" 或 "assistant"
                    let content = "";

                    // 提取内容
                    if (Array.isArray(replyData.content)) {
                      replyData.content.forEach((item: any) => {
                        if (item.type === "input_text" && item.text) {
                          content += item.text;
                        } else if (item.type === "output_text" && item.text) {
                          content += item.text;
                        }
                      });
                    }

                    // 如果有内容，添加到消息列表
                    if (content && role) {
                      // 检查是否已经存在相同角色的消息（避免重复）
                      const existingMessage = messages.value.find(
                        (m) => m.turnId === turn.id && m.role === role,
                      );

                      if (!existingMessage) {
                        const attachedFilesToApply =
                          role === "user" && pendingAttachedFiles
                            ? pendingAttachedFiles
                            : undefined;
                        messages.value.push({
                          id: `${role}_${turn.id}`,
                          turnId: turn.id,
                          role: role as "user" | "assistant",
                          content: content,
                          contentChunks: [content],
                          createdAt: turn.createdAt,
                          status: "completed",
                          ...(attachedFilesToApply
                            ? { attachedFiles: attachedFilesToApply }
                            : {}),
                        });
                        if (role === "user" && pendingAttachedFiles) {
                          pendingAttachedFiles = null;
                        }
                      } else {
                        // 如果已存在，追加内容
                        existingMessage.contentChunks = existingMessage.contentChunks || [];
                        if (existingMessage.contentChunks.length === 0 && existingMessage.content) {
                          existingMessage.contentChunks.push(existingMessage.content);
                        }
                        existingMessage.contentChunks.push(content);
                        existingMessage.content = existingMessage.contentChunks.join("");
                        if (
                          role === "user" &&
                          pendingAttachedFiles &&
                          !(existingMessage as any).attachedFiles
                        ) {
                          (existingMessage as any).attachedFiles = pendingAttachedFiles;
                          pendingAttachedFiles = null;
                        }
                      }
                    }
                  }

                  // 处理图片生成事件
                  if (replyData.type === "file_generated") {
                    // 找到对应的 assistant 消息，如果不存在则创建一个
                    let assistantMessage = messages.value.find(
                      (m) => m.turnId === turn.id && m.role === "assistant"
                    );

                    if (!assistantMessage) {
                      assistantMessage = {
                        id: `assistant_${turn.id}`,
                        turnId: turn.id,
                        role: "assistant",
                        content: "",
                        createdAt: turn.createdAt,
                        status: "completed",
                      };
                      messages.value.push(assistantMessage);
                    }

                    // 调用文件处理逻辑，显式传入当前会话的 sessionId
                    await handleFileGenerated({ ...replyData, sessionId }, assistantMessage);
                  }
                }
              } catch (parseError) {
                // 单行解析失败，继续下一行
              }
            }
          }
        } catch (error) {
          console.error("解析 turn 失败:", turn, error);
        }
      }

      return { success: true };
    } catch (error: any) {
      console.error("加载会话历史失败:", error);
      messagesError.value = error.message || "加载会话历史失败";
      return { success: false, error: error.message || "加载会话历史失败" };
    } finally {
      messagesLoading.value = false;
    }
  }

  // ==================== Actions - Message Handling ====================

  /**
   * 发送用户消息
   */
  async function sendMessage(
    input: string,
    sessionId?: number, // 设为可选
    fileIds?: number[] | null,
    attachedFiles?: CodexMessage["attachedFiles"],
  ): Promise<{
    success: boolean;
    status?: string;
    error?: string;
  }> {
    let currentSessionId = sessionId;
    let isNewSession = false; // 标记是否是新创建的会话

    // 1. 确定或创建 sessionId
    if (!currentSessionId && !currentSession.value) {
      // 如果没有 sessionId 且没有当前会话，创建一个新会话
      isNewSession = true;
      // 使用问题的简短描述作为初始标题
      const initialTitle = input.substring(0, 20) + (input.length > 20 ? "..." : "");
      const createResult = await createSession([], initialTitle);
      
      if (!createResult.success || !createResult.sessionId) {
        return { success: false, error: createResult.error || "创建会话失败" };
      }
      
      currentSessionId = createResult.sessionId;
      // 选择新创建的会话，不获取历史消息
      await selectSession({ sessionId: currentSessionId, fetchTurns: false });
    } else {
      // 使用传入的 sessionId 或当前会话的 sessionId
      currentSessionId = currentSessionId || currentSession.value?.sessionId;
    }

    if (!currentSessionId) {
      return { success: false, error: "会话不存在或已过期" };
    }

    // 2. ⭐ 关键修改：根据会话类型处理
    if (isNewSession) {
      // 新会话：软等待 initialized（最多 3s），期间若收到则更好；否则直接发送 /turn
      const SOFT_WAIT_MS = 3000;
      try {
        await Promise.race([
          // 等待真正的 initialized（若先到则更优）
          waitForInitialized(currentSessionId).catch(() => {
            // 防止内部超时 reject 造成未捕获异常
          }),
          // 软超时，先到即继续
          new Promise<void>((resolve) => setTimeout(resolve, SOFT_WAIT_MS)),
        ]);
        console.log("初始化软等待结束（可能已初始化，也可能超时继续）");
      } catch (error: any) {
        // 即便有异常也不阻塞发送 turn
        console.warn("初始化软等待异常，继续发送 /turn：", error);
      }
    } else {
      // 已存在会话：检查状态并确保连接建立
      // ⚠️ 关键修复：检查会话状态，判断是否需要重启
      
      // ⚠️ 优化：确保会话列表已加载，以便获取真实状态
      // 如果会话不在列表中，尝试刷新会话列表
      let sessionInList = sessions.value.find((s) => s.id === currentSessionId);
      if (!sessionInList && sessions.value.length === 0) {
        console.log("会话列表为空，尝试加载会话列表");
        await fetchSessions({ page: 0, size: 50 });
        sessionInList = sessions.value.find((s) => s.id === currentSessionId);
      }
      
      // ⚠️ 关键修复：优先使用会话列表中的真实状态，不要回退到 currentSession.value?.status
      // 因为 currentSession.value?.status 可能是过期的缓存值
      const rawStatus = sessionInList?.status;
      
      console.log(`发送消息前检查会话 ${currentSessionId} 状态: ${rawStatus || "未找到（使用默认值 idle）"}`);
      
      // 🆕 如果会话已停止（stopped / failed），先重启
      if (rawStatus === "stopped" || rawStatus === "failed") {
        console.log(`会话 ${currentSessionId} 已停止，尝试重启...`);
        try {
          // 1. 调用重启接口
          const restartResponse = await restartSession(currentSessionId);
          const restartResult = restartResponse.data as StartResult;
          console.log("重启会话结果:", restartResult);

          // 2. 清除旧的初始化状态，让后续等待新的 initialized 事件
          sessionInitialized.value.delete(currentSessionId);
          sessionInitializedPromises.value.delete(currentSessionId);

          // 3. 更新本地会话状态为 starting
          if (currentSession.value) {
            currentSession.value.status = "starting";
            currentSession.value.isInitialized = false;
          }
          if (sessionInList) {
            sessionInList.status = "starting";
          }

          // 4. 关闭旧连接，重建 SSE 连接
          if (currentStream.value) {
            currentStream.value.close();
            currentStream.value = null;
          }
          startStreamingForSession(currentSessionId);

          // 5. 软等待 initialized（避免 initialized 比 SSE 建链更快导致盲等）
          const SOFT_WAIT_MS = 3000;
          await Promise.race([
            // 若先收到 initialized 则更优，先完成
            waitForInitialized(currentSessionId).catch(() => {
              // 防止内部超时 reject 造成未处理异常
            }),
            // 若在软超时时间内没收到 initialized，超时后继续发送 /turn
            new Promise<void>((resolve) => setTimeout(resolve, SOFT_WAIT_MS)),
          ]);
          console.log("重启的会话初始化软等待结束，可以发送消息（可能已 initialized，也可能超时继续）");
        } catch (error: any) {
          console.error("重启会话失败:", error);
          return { success: false, error: error.message || "重启会话失败" };
        }
      } else {
        // 会话状态正常，只确保 SSE 连接已建立
        if (!currentStream.value || currentSession.value?.sessionId !== currentSessionId) {
          console.log("已存在会话，确保 SSE 连接已建立");
          startStreamingForSession(currentSessionId);
          // 等待一小段时间让连接建立（不等待 initialized 事件）
          await new Promise(resolve => setTimeout(resolve, 500));
        }
        // 标记为已初始化（因为后端会话已存在）
        sessionInitialized.value.set(currentSessionId, true);
        if (currentSession.value) {
          currentSession.value.isInitialized = true;
        }
      }
    }

    // 3. 更新会话标题（如果当前是默认标题）
    const sessionInList = sessions.value.find((s) => s.id === currentSessionId);
    if (
      sessionInList &&
      (!sessionInList.title || sessionInList.title.startsWith("会话 "))
    ) {
      sessionInList.title = input.substring(0, 20) + (input.length > 20 ? "..." : "");
    }

    // 4. 添加用户消息
    const userMessageId = `user_${Date.now()}`;
    const userMessage: CodexMessage = {
      id: userMessageId,
      role: "user",
      content: input,
      createdAt: new Date().toISOString(),
      status: "completed",
      ...(attachedFiles && attachedFiles.length > 0
        ? { attachedFiles: [...attachedFiles] }
        : {}),
    };
    messages.value.push(userMessage);
    console.log(
      "[codex] userMessage 入列（含 attachedFiles）:",
      JSON.stringify(userMessage, null, 0),
    );

    // 5. 添加一个等待中的助手消息
    const assistantMessageId = `assistant_${Date.now()}`;
    const assistantMessageIndex = messages.value.length; // 记录索引位置
    messages.value.push({
      id: assistantMessageId,
      role: "assistant",
      content: "",
      createdAt: new Date().toISOString(),
      status: "pending",
      isStreaming: false,
      contentChunks: [],
    });
    console.log("发送消息后的消息列表：", messages.value);

    // 等待 Vue 的下一次 DOM 更新，确保 pending 状态能被渲染
    await nextTick();

    try {
      messagesLoading.value = true;
      messagesError.value = null;
      aiThinking.value = true;

      // 6. 调用 /turn
      // null: 沿用会话范围；[]: 清空；[...]: 覆盖本轮文件范围
      const turnFileIds = fileIds === undefined ? null : fileIds;
      const response = await startTurn({
        sessionId: currentSessionId,
        input,
        fileIds: turnFileIds,
      });
      // 与后端会话视图同步：null 表示沿用，不覆盖本地 fileIds
      if (
        turnFileIds !== null &&
        response.status >= 200 &&
        response.status < 300 &&
        currentSession.value?.sessionId === currentSessionId
      ) {
        currentSession.value.fileIds = [...turnFileIds];
      }
      const result = response.data as TurnResponse;

      const assistantMessage = messages.value[assistantMessageIndex];
      if (!assistantMessage) {
        return { success: false, error: "助手消息创建失败" };
      }

      // 7. 处理 /turn 的响应状态
      if (result.status === "starting") {
        // 如果返回 starting，等待并重试
        console.log("会话正在启动，等待后重试...");
        assistantMessage.status = "pending";
        assistantMessage.content = "会话正在启动，请稍候...";
        
        // 等待一段时间后重试
        await new Promise((resolve) => setTimeout(resolve, 2000));
        
        const retryResponse = await startTurn({
          sessionId: currentSessionId,
          input,
          fileIds: turnFileIds,
        });
        if (
          turnFileIds !== null &&
          retryResponse.status >= 200 &&
          retryResponse.status < 300 &&
          currentSession.value?.sessionId === currentSessionId
        ) {
          currentSession.value.fileIds = [...turnFileIds];
        }
        const retryResult = retryResponse.data as TurnResponse;
        
        if (retryResult.status === "failed") {
          assistantMessage.status = "error";
          assistantMessage.error = "重试后仍然失败";
          return { success: false, status: retryResult.status, error: "重试后仍然失败" };
        }
        
        if (retryResult.status === "queue" && retryResult.pos !== undefined) {
          if (currentSession.value) {
            currentSession.value.status = "queued";
            currentSession.value.queuePosition = retryResult.pos;
          }
          assistantMessage.status = "pending";
          assistantMessage.content = `排队中，当前位置: ${retryResult.pos}`;
          return { success: true, status: retryResult.status };
        }
        
        if (retryResult.status === "started" || retryResult.status === "starting") {
          aiThinking.value = false;
          // 流式连接应该已经建立，只需要绑定消息
          bindMessageToStream(currentSessionId, assistantMessage);
          return { success: true, status: retryResult.status };
        }
      }

      if (result.status === "queue" && result.pos !== undefined) {
        if (currentSession.value) {
          currentSession.value.status = "queued";
          currentSession.value.queuePosition = result.pos;
        }
        assistantMessage.status = "pending";
        assistantMessage.content = `排队中，当前位置: ${result.pos}`;
        return { success: true, status: result.status };
      }

      if (result.status === "failed") {
        assistantMessage.status = "error";
        assistantMessage.error = "发送消息失败";
        return { success: false, status: result.status, error: "发送消息失败" };
      }

      // 如果返回 started，流式连接应该已经建立，只需要绑定消息
      if (result.status === "started") {
        aiThinking.value = false;
        bindMessageToStream(currentSessionId, assistantMessage);
        return { success: true, status: result.status };
      }

      return { success: true, status: result.status };
    } catch (error: any) {
      console.error("发送消息失败:", error);
      messagesError.value = error.message || "发送消息失败";

      // 更新助手消息的错误状态
      const assistantMessage = messages.value[assistantMessageIndex];
      if (assistantMessage) {
        assistantMessage.status = "error";
        assistantMessage.error = error.message || "发送消息失败";
      }

      aiThinking.value = false;
      return { success: false, error: error.message || "发送消息失败" };
    } finally {
      messagesLoading.value = false;
    }
  }

  /**
   * 为会话建立流式连接（不绑定特定消息，用于接收所有事件）
   */
  function startStreamingForSession(sessionId: number): void {
    // 如果已有流式连接且是同一个会话，不重复建立
    if (currentStream.value && currentSession.value?.sessionId === sessionId) {
      console.log("流式连接已存在，跳过建立");
      return;
    }

    // 如果已有流式连接，先关闭
    if (currentStream.value) {
      currentStream.value.close();
    }

    streaming.value = true;
    streamingError.value = null;

    const streamOptions: StreamOptions = {
      sessionId,
      onOpen: () => {
        console.log("Codex SSE 连接已建立，等待 initialized 事件");
      },
      onMessage: async (data: string | object) => {
        try {
          const event = typeof data === "string" ? JSON.parse(data) : data;
          // 查找当前活跃的消息，如果没有则传入 null（会话级别事件）
          const activeMessage = activeMessages.value.get(sessionId) || null;
          await handleStreamEvent(event, activeMessage);
        } catch (error) {
          console.error("解析 SSE 消息失败:", error, data);
        }
      },
      onError: (error: any) => {
        console.error("Codex SSE 错误:", error);
        streamingError.value = "接收消息失败";
        streaming.value = false;
        
        // 拒绝初始化 Promise
        const promise = sessionInitializedPromises.value.get(sessionId);
        if (promise) {
          promise.reject(error);
          sessionInitializedPromises.value.delete(sessionId);
        }
        
        // ⚠️ 关键修改：错误时不立即关闭连接，标记为需要重连
        // 如果当前会话仍然活跃，标记为需要重连
        if (currentSession.value?.sessionId === sessionId) {
          console.log("会话仍然活跃，连接错误，标记为需要重连");
          currentStream.value = null; // 标记为需要重连
        } else {
          // 会话已切换或停止，正常关闭
          if (currentStream.value) {
            currentStream.value.close();
            currentStream.value = null;
          }
        }
      },
      onEnd: () => {
        console.log("Codex SSE 连接已关闭（后端主动关闭）");
        
        // ⚠️ 关键修改：不立即清空连接，而是检查是否需要重连
        streaming.value = false;
        
        // 如果当前会话仍然活跃，可能需要重连
        if (currentSession.value?.sessionId === sessionId) {
          console.log("会话仍然活跃，连接被后端关闭，标记为需要重连");
          // 标记为需要重连，但不立即清空，等待下次 turn 时检查
          currentStream.value = null; // 标记为需要重连
        } else {
          // 会话已切换或停止，正常关闭
          console.log("会话已切换或停止，正常关闭连接");
          currentStream.value = null;
        }
      },
    };

    currentStream.value = streamSession(streamOptions);
  }

  /**
   * 等待会话初始化完成（仅用于新创建的会话）
   */
  async function waitForInitialized(sessionId: number, timeout: number = 30000): Promise<void> {
    // 如果已经初始化，直接返回
    if (sessionInitialized.value.get(sessionId)) {
      return;
    }

    // ⚠️ 关键修复：判断是否是新会话
    // 如果是已存在的会话（有 currentSession 但 isInitialized 为 false），
    // 可能是页面刷新后的情况，不需要等待 initialized 事件
    const isExistingSession = currentSession.value?.sessionId === sessionId && 
                            !currentSession.value?.isInitialized &&
                            currentSession.value?.status !== "starting";
    
    if (isExistingSession) {
      // 已存在会话：只确保连接建立，不等待 initialized
      if (!currentStream.value) {
        console.log("已存在会话，建立 SSE 连接（不等待 initialized）");
        startStreamingForSession(sessionId);
        // 等待连接建立
        await new Promise(resolve => setTimeout(resolve, 500));
      }
      // 直接标记为已初始化（因为后端会话已存在）
      sessionInitialized.value.set(sessionId, true);
      if (currentSession.value) {
        currentSession.value.isInitialized = true;
      }
      return;
    }

    // 新会话：等待 initialized 事件
    // 获取或创建 Promise
    let promise = sessionInitializedPromises.value.get(sessionId);
    if (!promise) {
      // 如果没有 Promise，创建一个新的
      let initializedResolve: (() => void) | undefined;
      let initializedReject: ((error: any) => void) | undefined;
      new Promise<void>((resolve, reject) => {
        initializedResolve = resolve;
        initializedReject = reject;
      });

      promise = {
        resolve: initializedResolve!,
        reject: initializedReject!,
      };
      sessionInitializedPromises.value.set(sessionId, promise);
    }

    // 设置超时
    const timeoutPromise = new Promise<void>((_, reject) => {
      setTimeout(() => {
        reject(new Error("等待初始化超时"));
      }, timeout);
    });

    // 等待初始化完成或超时
    return Promise.race([
      new Promise<void>((resolve, reject) => {
        // 检查是否已经初始化
        if (sessionInitialized.value.get(sessionId)) {
          resolve();
          return;
        }
        
        // 等待 promise resolve
        const originalResolve = promise!.resolve;
        const originalReject = promise!.reject;
        
        promise!.resolve = () => {
          originalResolve();
          resolve();
        };
        
        promise!.reject = (err) => {
          originalReject(err);
          sessionInitializedPromises.value.delete(sessionId);
          reject(err);
        };
      }),
      timeoutPromise,
    ]);
  }

  /**
   * 将消息绑定到现有的流式连接（不重新建立连接）
   */
  function bindMessageToStream(sessionId: number, message: CodexMessage): void {
    // 将消息标记为活跃消息
    activeMessages.value.set(sessionId, message);
    
    // 确保流式连接存在
    if (!currentStream.value || currentSession.value?.sessionId !== sessionId) {
      console.log("流式连接不存在或会话不匹配，建立新连接");
      startStreamingForSession(sessionId);
      // 等待连接建立后再绑定消息（通过 activeMessages 已经设置，连接建立后会自动路由）
      // 连接建立后，onOpen 回调会触发，此时消息已经通过 activeMessages 绑定
      // 但为了确保状态正确，我们在这里也设置一下
      message.isStreaming = true;
      message.status = "streaming";
      aiTyping.value = true;
    } else {
      // 连接已存在，直接绑定消息
      console.log("绑定消息到现有流式连接");
      message.isStreaming = true;
      message.status = "streaming";
      aiTyping.value = true;
    }
  }

  /**
   * 处理流式事件
   */
  async function handleStreamEvent(event: any, message: CodexMessage | null): Promise<void> {
    console.log("收到 SSE 事件:", event);

    // SSE 事件的外层结构: { type, sessionId, data }
    const eventType = event.type;
    const sessionId = event.sessionId || currentSession.value?.sessionId;

    switch (eventType) {
      case "connected":
        // 连接已建立
        console.log("Codex 会话已连接:", sessionId);
        break;

      case "initialized": // ⭐ 新增：处理初始化事件
        if (sessionId) {
          // ⚠️ 关键修复：从 event.data.threadId 提取 threadId
          const eventData = event.data || {};
          const threadId = eventData.threadId || 
                           event.threadId || 
                           event.codexThreadId || 
                           null;
          
          // 更新会话状态
          if (currentSession.value && currentSession.value.sessionId === sessionId) {
            currentSession.value.codexThreadId = threadId;
            currentSession.value.isInitialized = true;
          }
          
          // 标记为已初始化
          sessionInitialized.value.set(sessionId, true);
          
          // 解析初始化 Promise
          const promise = sessionInitializedPromises.value.get(sessionId);
          if (promise) {
            promise.resolve();
            sessionInitializedPromises.value.delete(sessionId);
          }
        }
        break;

      case "message":
        // 消息事件，需要解析 data 字段
        if (message) {
          if (event.data && typeof event.data === "string") {
            try {
              const messageData = JSON.parse(event.data);
              handleMessageData(messageData, message);
            } catch (error) {
              console.error("解析消息数据失败:", error, event.data);
            }
          }
        }
        break;

      case "task_complete":
        // 任务完成事件 - 无论 message 是否存在，都要重置 loading 状态
        // 修复：turn_complete 可能已经从 activeMessages 中删除了消息，
        // 导致 message 为 null，但 aiThinking 仍然为 true，按钮无法还原
        aiThinking.value = false;
        aiTyping.value = false;
        if (message) {
          handleTaskComplete(event, message);
          // ⚠️ 关键修改：任务完成时不清空连接，只更新消息状态
          // 从活跃消息中移除，但保持连接
          activeMessages.value.delete(sessionId);
        }
        break;

      case "approval_request":
        // 审批请求（可能直接在 event.data 中）
        if (message) {
          handleApprovalRequest(event, message);
        }
        break;

      case "command_approval":
        // 命令审批请求
        if (message) {
          handleCommandApproval(event, message);
        }
        break;

      case "patch_approval":
        // 补丁审批请求
        if (message) {
          handlePatchApproval(event, message);
        }
        break;

      case "approval_resolved":
        // 审批已处理
        handleApprovalResolved(event);
        break;

      case "file_generated":
        // 文件已生成（支持图片和非图片文件）
        if (message) {
          await handleFileGenerated(event, message);
        }
        break;

      case "turn_complete":
      case "complete":
        // 回合完成
        if (message) {
          handleTurnComplete(message);
          // ⚠️ 关键修改：回合完成时不清空连接，只更新消息状态
          // 从活跃消息中移除，但保持连接
          activeMessages.value.delete(sessionId);
        }
        break;

      case "error":
        // 错误
        if (message) {
          handleStreamError(event, message);
        }
        break;

      default:
        console.log("未处理的事件类型:", eventType, event);
    }
  }

  /**
   * 处理消息数据（从 message 事件的 data 字段解析出来的）
   */
  function handleMessageData(messageData: any, message: CodexMessage): void {
    // 处理 function_call 类型 - 前端不再渲染，仅用于内部逻辑同步状态
    if (messageData.type === "function_call") {
      console.log("收到函数调用，但不进行渲染：", messageData);

      // 如果是第一次接收到内容，将状态从 pending 改为 streaming
      if (message.status === "pending") {
        message.status = "streaming";
        message.isStreaming = true;
        aiTyping.value = true;
      }

      return;
    }

    const role = messageData.role; // "user" | "assistant"

    if (role === "assistant") {
      // 助手消息 - 提取输出文本
      console.log("收到助手信息：", messageData);
      if (Array.isArray(messageData.content)) {
        let textChunk = "";
        messageData.content.forEach((item: any) => {
          if (item.type === "output_text" && item.text) {
            textChunk += item.text;
          }
        });

        if (textChunk) {
          handleTextChunk({ chunk: textChunk }, message);
        }
      }
    } else if (role === "user") {
      // 用户消息 - 通常不需要处理，因为用户消息已经在发送时添加了
      console.log("收到用户消息回显（通常可忽略）:", messageData);
    }
  }

  /**
   * 处理文本块
   */
  function handleTextChunk(event: any, message: CodexMessage): void {
    const chunk = event.chunk || event.content || event.text || "";
    if (chunk) {
      // 如果是第一次接收到内容，将状态从 pending 改为 streaming
      if (message.status === "pending") {
        message.status = "streaming";
        message.isStreaming = true;
        aiTyping.value = true;
        console.log("收到第一条内容，状态从 pending 改为 streaming");
      }

      message.contentChunks = message.contentChunks || [];
      message.contentChunks.push(chunk);
      message.content = message.contentChunks.join("");
      message.status = "streaming";
    }
    console.log("消息累计：", message.content);
  }

  /**
   * 处理文件生成事件（支持图片和非图片文件）
   */
  async function handleFileGenerated(event: any, message: CodexMessage): Promise<void> {
    console.log("收到文件生成事件:", event);
    
    // 兼容处理：历史记录中数据可能直接平铺，实时流中在 data 字段下
    const fileData = event.data || event;
    if (!fileData) return;

    // 优先从事件中获取 sessionId，如果没有则使用当前会话的 ID
    const sessionId = event.sessionId || currentSession.value?.sessionId;

    // 从新的事件数据结构中提取字段
    const fileName = fileData.fileName || "";
    const fileType = fileData.fileType || "";
    const extension = fileData.extension || "";
    const path = fileData.path || "";
    const url = fileData.url || "";
    const createdAt = fileData.createdAt || new Date().toISOString();
    const size = fileData.size || "";

    // 如果既没有 path 也没有 url，说明不是有效的文件数据
    if (!path && !url) return;

    // 如果是第一次接收到内容，将状态从 pending 改为 streaming
    if (message.status === "pending") {
      message.status = "streaming";
      message.isStreaming = true;
      aiTyping.value = true;
    }

    // 关键修复：确保不丢失已有内容，并同步 contentChunks
    message.contentChunks = message.contentChunks || [];
    if (message.contentChunks.length === 0 && message.content) {
      message.contentChunks.push(message.content);
    }

    // 判断文件类型：如果是图片，使用原有的图片渲染逻辑
    if (fileType === "image") {
      const imageUrl = url || path;
      const imagePath = path;
      
      let finalImageUrl = "";

      try {
        if (imagePath) {
          // 1. 通过带认证的请求预下载图片为 Blob
          const response = await downloadWorkspaceFile(imagePath);
          const blob = response.data;
          
          // 2. 创建本地 Blob URL (这样 img 标签加载时就不再需要认证了)
          finalImageUrl = URL.createObjectURL(blob);
          console.log("图片已生成并转换为 Blob URL:", finalImageUrl);
        } else {
          finalImageUrl = imageUrl;
        }
      } catch (error) {
        console.error("处理生成图片失败，尝试使用带 token 的 URL 降级:", error);
        
        // 降级处理：如果 Blob 下载失败，尝试在 URL 后追加 token
        const token = localStorage.getItem("auth_token") || localStorage.getItem("token");
        const baseAppUrl = imageUrl || `/api/codex/workspace/download?path=${encodeURIComponent(imagePath)}`;
        
        if (token) {
          finalImageUrl = `${baseAppUrl}${baseAppUrl.includes('?') ? '&' : '?'}token=${encodeURIComponent(token)}`;
        } else {
          finalImageUrl = baseAppUrl;
        }
      }

      // 将图片以 Markdown 格式追加到消息中
      const imageMarkdown = `\n\n![生成的图片](${finalImageUrl}){data-tmp-path="${imagePath}" data-session-id="${sessionId || ''}"}`;
      message.contentChunks.push(imageMarkdown);
      console.log("图片已处理并添加到消息内容中", { turnId: message.turnId, url: finalImageUrl });
    } else {
      // 非图片文件，生成卡片HTML结构
      // 转义HTML特殊字符，防止XSS
      const escapeHtml = (str: string) => {
        const div = document.createElement('div');
        div.textContent = str;
        return div.innerHTML;
      };

      const escapedFileName = escapeHtml(fileName);
      const escapedPath = escapeHtml(path);
      const escapedUrl = escapeHtml(url || '');
      const escapedFileType = escapeHtml(fileType);
      const escapedExtension = escapeHtml(extension);
      const escapedCreatedAt = escapeHtml(createdAt);
      const escapedSize = escapeHtml(size ? String(size) : '');

      // 格式化创建时间：从 ISO 8601 格式转换为 "MM-DD HH:mm"
      let formattedTime = "";
      try {
        const date = new Date(createdAt);
        if (!isNaN(date.getTime())) {
          const month = String(date.getMonth() + 1).padStart(2, '0');
          const day = String(date.getDate()).padStart(2, '0');
          const hours = String(date.getHours()).padStart(2, '0');
          const minutes = String(date.getMinutes()).padStart(2, '0');
          formattedTime = `${month}-${day} ${hours}:${minutes}`;
        }
      } catch (e) {
        console.warn("时间格式化失败:", e);
        formattedTime = createdAt;
      }

      // 根据扩展名获取图标路径
      const getIconPath = (ext: string): string => {
        const iconMap: Record<string, string> = {
          ppt: "/PPT_icon.svg",
          pptx: "/PPT_icon.svg",
          doc: "/word_icon.svg",
          docx: "/word_icon.svg",
          xls: "/excel_icon.svg",
          xlsx: "/excel_icon.svg",
          pdf: "/pdf_icon.svg",
          md: "/md_icon.svg",
          txt: "/TXT_icon.svg",
        };
        return iconMap[ext.toLowerCase()] || "/TXT_icon.svg";
      };

      const iconPath = getIconPath(extension);

      // 检查文件是否已保存（使用 savedImagePaths）
      const isSaved = savedImagePaths.value.has(path);
      const escapedSessionId = escapeHtml(String(sessionId || ''));

      // 生成卡片HTML（复用图片展示的结构）
      // 注意：HTML 块前后必须有足够的空行，且 HTML 标签必须在独立行上，才能被 MarkdownIt 正确识别
      const cardHtml = `<div class="generated-image-wrapper has-file-card">
<div class="file-generated-card" data-file-path="${escapedPath}" data-file-url="${escapedUrl}" data-file-name="${escapedFileName}" data-file-type="${escapedFileType}" data-extension="${escapedExtension}" data-created-at="${escapedCreatedAt}" data-size="${escapedSize}">
  <div class="file-card-content">
    <div class="file-card-icon">
      <img src="${iconPath}" alt="${escapedExtension}" onerror="this.src='/TXT_icon.svg'" />
    </div>
    <div class="file-card-info">
      <div class="file-card-name">${escapedFileName}</div>
      <div class="file-card-time">创建时间: ${formattedTime}</div>
    </div>
  </div>
</div>
<button class="image-save-btn ${isSaved ? 'is-saved' : ''}" ${isSaved ? 'disabled' : ''} data-tmp-path="${escapedPath}" data-session-id="${escapedSessionId}">
  <i class="fas ${isSaved ? 'fa-check' : 'fa-save'}"></i> 
  ${isSaved ? '已保存' : '保存'}
</button>
</div>`;

      // 确保 HTML 块前后有足够的空行，让 MarkdownIt 识别为 HTML 块而不是普通文本
      message.contentChunks.push(`\n\n\n${cardHtml}\n\n\n`);
      console.log("非图片文件卡片已添加到消息内容中", { turnId: message.turnId, fileName, fileType });
    }

    message.content = message.contentChunks.join("");
  }

  /**
   * 处理任务完成事件
   */
  function handleTaskComplete(event: any, message: CodexMessage): void {
    console.log("收到任务完成事件:", event);

    const lastAgentMessage = event.data?.last_agent_message || "";

    if (lastAgentMessage) {
      // 检查当前消息内容中是否已经包含这条消息
      const currentContent = message.content || "";

      if (!currentContent.includes(lastAgentMessage)) {
        // 如果还没有这条消息，追加到内容中
        console.log("追加最后一条助手消息:", lastAgentMessage);
        message.contentChunks = message.contentChunks || [];
        message.contentChunks.push(lastAgentMessage);
        message.content = message.contentChunks.join("");
      } else {
        console.log("最后一条助手消息已存在，跳过追加");
      }
    }

    // 标记任务完成
    message.status = "completed";
    message.isStreaming = false;
    aiThinking.value = false;
    aiTyping.value = false;

    console.log("任务正常完成，保持流式连接（不清空）");

    // ⚠️ 关键修改：不清空连接，保持连接以便下次 turn 使用
    // 连接会在以下情况关闭：
    // 1. 用户主动停止会话
    // 2. 切换到其他会话
    // 3. 会话被删除
    // 4. 发生错误需要重连
  }

  /**
   * 处理命令审批请求
   */
  function handleCommandApproval(event: any, message: CodexMessage): void {
    console.log("收到命令审批请求:", event);

    const approvalData = event.data;
    const approval: PendingApproval = {
      approvalId: approvalData.id || approvalData.approvalId,
      type: "command",
      title: approvalData.title,
      description: approvalData.reason,
      command: approvalData.cmd || approvalData.command,
      createdAt: new Date().toISOString(),
    };

    // 添加到待审批队列
    pendingApprovals.value.push(approval);

    // 在消息中标记
    message.pendingApproval = approval;
    message.status = "pending";
    message.isStreaming = false;

    // 暂停流式输出
    aiTyping.value = false;
  }

  /**
   * 处理补丁审批请求
   */
  function handlePatchApproval(event: any, message: CodexMessage): void {
    console.log("收到补丁审批请求:", event);

    const approvalData = event.data;
    const fileChanges = approvalData.fileChanges || [];

    // 为每个文件变更创建一个审批项
    fileChanges.forEach((fileChange: any) => {
      const approval: PendingApproval = {
        approvalId: approvalData.id || approvalData.approvalId,
        type: "patch",
        title: `文件变更: ${fileChange.fileName}`,
        fileChangeId: fileChange.id,
        filePath: fileChange.filePath || fileChange.fileName,
        changes: fileChange.diffExcerpt || fileChange.excerpt,
        createdAt: new Date().toISOString(),
      };

      // 添加到待审批队列
      pendingApprovals.value.push(approval);

      // 在消息中标记（使用第一个审批）
      if (!message.pendingApproval) {
        message.pendingApproval = approval;
        message.status = "pending";
        message.isStreaming = false;
      }
    });

    // 暂停流式输出
    aiTyping.value = false;
  }

  /**
   * 处理审批请求（兼容旧格式）
   */
  function handleApprovalRequest(event: any, message: CodexMessage): void {
    const approval: PendingApproval = {
      approvalId: event.approval_id || event.approvalId,
      type:
        event.approval_type || event.type === "command_approval"
          ? "command"
          : "patch",
      title: event.title,
      description: event.description,
      command: event.command,
      fileChangeId: event.file_change_id || event.fileChangeId,
      filePath: event.file_path || event.filePath,
      changes: event.changes || event.diff,
      createdAt: new Date().toISOString(),
    };

    // 添加到待审批队列
    pendingApprovals.value.push(approval);

    // 在消息中标记
    message.pendingApproval = approval;
    message.status = "pending";
    message.isStreaming = false;

    // 暂停流式输出
    aiTyping.value = false;
  }

  /**
   * 处理审批已处理
   */
  function handleApprovalResolved(event: any): void {
    const approvalId = event.approval_id || event.approvalId;
    const decision = event.decision;

    // 从待审批队列中移除
    const index = pendingApprovals.value.findIndex(
      (a) => a.approvalId === approvalId,
    );
    if (index !== -1) {
      pendingApprovals.value.splice(index, 1);
    }

    // 找到对应的消息，更新状态
    const msg = messages.value.find(
      (m) => m.pendingApproval?.approvalId === approvalId,
    );
    if (msg) {
      msg.pendingApproval = undefined;
      msg.status = "streaming";
      msg.isStreaming = true;
    }

    // 恢复流式输出
    if (decision === "approved" || decision === "approved_for_session") {
      aiTyping.value = true;
    }
  }

  /**
   * 处理回合完成
   */
  function handleTurnComplete(message: CodexMessage): void {
    message.status = "completed";
    message.isStreaming = false;
    aiTyping.value = false;

    console.log("回合完成，保持流式连接（不清空）");

    // ⚠️ 关键修改：不清空连接，保持连接以便下次 turn 使用
    // 连接会在以下情况关闭：
    // 1. 用户主动停止会话
    // 2. 切换到其他会话
    // 3. 会话被删除
    // 4. 发生错误需要重连
  }

  /**
   * 处理流错误
   */
  function handleStreamError(event: any, message: CodexMessage): void {
    const errorMessage = event.message || event.error || "发生未知错误";
    message.status = "error";
    message.error = errorMessage;
    message.isStreaming = false;
    streamingError.value = errorMessage;
    aiTyping.value = false;
  }

  // ==================== Actions - Approval Handling ====================

  /**
   * 提交命令决策
   */
  async function approveCommand(
    approvalId: number,
    decision: "approved" | "approved_for_session" | "denied" | "abort",
  ): Promise<{ success: boolean; error?: string }> {
    try {
      await submitCommandDecision({ approvalId, decision });

      // 从待审批队列中移除
      const index = pendingApprovals.value.findIndex(
        (a) => a.approvalId === approvalId,
      );
      if (index !== -1) {
        pendingApprovals.value.splice(index, 1);
      }

      // 更新消息状态
      const msg = messages.value.find(
        (m) => m.pendingApproval?.approvalId === approvalId,
      );
      if (msg) {
        msg.pendingApproval = undefined;
        if (decision === "approved" || decision === "approved_for_session") {
          msg.status = "streaming";
          msg.isStreaming = true;
          aiTyping.value = true;
        } else {
          msg.status = "completed";
          msg.content += "\n\n[命令已被拒绝]";
        }
      }

      return { success: true };
    } catch (error: any) {
      console.error("提交命令决策失败:", error);
      return { success: false, error: error.message || "提交命令决策失败" };
    }
  }

  /**
   * 提交补丁决策
   */
  async function approvePatch(
    approvalId: number,
    decision: "approved" | "denied",
    fileChangeId?: number,
  ): Promise<{ success: boolean; error?: string }> {
    try {
      await submitPatchDecision({ approvalId, decision, fileChangeId });

      // 从待审批队列中移除
      const index = pendingApprovals.value.findIndex(
        (a) => a.approvalId === approvalId,
      );
      if (index !== -1) {
        pendingApprovals.value.splice(index, 1);
      }

      // 更新消息状态
      const msg = messages.value.find(
        (m) => m.pendingApproval?.approvalId === approvalId,
      );
      if (msg) {
        msg.pendingApproval = undefined;
        if (decision === "approved") {
          msg.status = "streaming";
          msg.isStreaming = true;
          aiTyping.value = true;
        } else {
          msg.status = "completed";
          msg.content += "\n\n[代码变更已被拒绝]";
        }
      }

      return { success: true };
    } catch (error: any) {
      console.error("提交补丁决策失败:", error);
      return { success: false, error: error.message || "提交补丁决策失败" };
    }
  }

  /**
   * 提交文件决策 (保存生成文件)
   */
  async function submitFileDecisionAction(
    sessionId: number,
    tmpPath: string,
    parentId?: number | null,
  ): Promise<{ success: boolean; error?: string }> {
    try {
      await submitFileDecision({ sessionId, tmpPath, parentId });
      // 成功保存后，将该临时路径标记为已保存，便于前端更新按钮状态
      const newSet = new Set(savedImagePaths.value);
      newSet.add(tmpPath);
      savedImagePaths.value = newSet;
      return { success: true };
    } catch (error: any) {
      console.error("提交文件决策失败:", error);
      return { success: false, error: error.message || "提交文件决策失败" };
    }
  }

  /**
   * 检查图片是否已保存
   */
  function isImageSaved(tmpPath: string): boolean {
    return savedImagePaths.value.has(tmpPath);
  }

  // ==================== Actions - Utility ====================

  /**
   * 清空消息
   */
  function clearMessages(): void {
    messages.value = [];
    savedImagePaths.value = new Set();
  }

  /**
   * 清空错误
   */
  function clearErrors(): void {
    sessionError.value = null;
    messagesError.value = null;
    streamingError.value = null;
    connectionError.value = null;
  }

  /**
   * 重置状态
   */
  function reset(): void {
    // 关闭流式连接
    if (currentStream.value) {
      currentStream.value.close();
      currentStream.value = null;
    }

    currentSession.value = null;
    messages.value = [];
    pendingApprovals.value = [];
    savedImagePaths.value = new Set();
    streaming.value = false;
    aiThinking.value = false;
    aiTyping.value = false;
    
    // 清理初始化状态
    sessionInitialized.value.clear();
    sessionInitializedPromises.value.clear();
    activeMessages.value.clear();
    
    clearErrors();
  }

  // ==================== Return ====================

  return {
    // State
    connected,
    connecting,
    connectionError,
    currentSession,
    sessionLoading,
    sessionError,
    messages,
    messagesLoading,
    messagesError,
    streaming,
    streamingError,
    aiThinking,
    aiTyping,
    pendingApprovals,
    savedImagePaths,
    sessions,
    sessionsLoading,
    sessionsError,
    sessionsTotalPages,
    sessionsTotalElements,
    chatDraft,

    // Computed
    isSessionActive,
    isSessionStarting,
    isSessionQueued,
    hasPendingApprovals,
    lastMessage,

    // Actions
    createSession,
    addFiles,
    removeFiles,
    fetchSessions,
    selectSession,
    clearCurrentSession,
    deleteSession: deleteSessionAction,
    clearAllSessions,
    stop,
    loadTurns,
    sendMessage,
    approveCommand,
    approvePatch,
    submitFileDecision: submitFileDecisionAction,
    isImageSaved,
    clearMessages,
    clearErrors,
    reset,
  };
});