// @/agents/outlineScript.ts
import u from "@/utils";
import { createAgent } from "langchain";
import { EventEmitter } from "events";
import { openAI } from "@/agents/models";
import { z } from "zod";
import { tool } from "@langchain/core/tools";
import type { DB } from "@/types/database";
// ==================== 类型定义 ====================

type AgentType = "AI1" | "AI2" | "director";
type AssetType = "角色" | "道具" | "场景";
type RefreshEvent = "storyline" | "outline" | "assets";

interface AssetItem {
  name: string;
  description: string;
}

interface EpisodeData {
  episodeIndex: number;
  title: string;
  chapterRange: number[];
  scenes: AssetItem[]; // 按 outline 出场顺序排列
  characters: AssetItem[]; // 按 outline 出场顺序排列
  props: AssetItem[]; // 按 outline 出场顺序排列
  coreConflict: string;
  outline: string; // 最高优先级，剧本生成的唯一权威
  openingHook: string; // outline 第一句话的视觉化，开篇第一个镜头
  keyEvents: string[]; // 4个元素：[起, 承, 转, 合]，严格按 outline 顺序
  emotionalCurve: string; // 对应 keyEvents 各阶段
  visualHighlights: string[]; // 按 outline 顺序排列的标志性镜头
  endingHook: string; // outline 之后的悬念延伸
  classicQuotes: string[];
}

// ==================== Schema 定义 ====================

const sceneItemSchema = z.object({
  name: z.string().describe("场景名称，如'五星酒店宴会厅'、'老旧出租屋'"),
  description: z.string().describe("环境描写：空间结构、光线氛围、装饰陈设、环境细节"),
});

const characterItemSchema = z.object({
  name: z.string().describe("角色姓名（必须是具体人名，禁止'众人'、'群众'等集合描述）"),
  description: z.string().describe("人设样貌：年龄体态、五官特征、发型妆容、服装配饰、气质神态"),
});

const propItemSchema = z.object({
  name: z.string().describe("道具名称"),
  description: z.string().describe("样式描写：材质质感、颜色图案、形状尺寸、磨损痕迹、特殊标记"),
});

const episodeSchema = z.object({
  episodeIndex: z.number().describe("集数索引，从1开始递增"),
  title: z.string().describe("8字内标题，疑问/感叹句，含情绪爆点"),
  chapterRange: z.array(z.number()).describe("关联章节号数组"),
  scenes: z.array(sceneItemSchema).describe("场景列表，按 outline 出场顺序排列"),
  characters: z.array(characterItemSchema).describe("角色列表，按 outline 出场顺序排列，必须是独立个体"),
  props: z.array(propItemSchema).describe("道具列表，按 outline 出场顺序排列，至少3个"),
  coreConflict: z.string().describe("核心矛盾：A想要X vs B阻碍X"),
  outline: z.string().describe("100-300字剧情主干，最高优先级，剧本生成的唯一权威，按时间顺序完整叙述"),
  openingHook: z.string().describe("开场镜头：outline 第一句话的视觉化，必须作为剧本第一个镜头"),
  keyEvents: z.array(z.string()).length(4).describe("4个元素的数组：[起, 承, 转, 合]，严格按 outline 顺序从中提取"),
  emotionalCurve: z.string().describe("情绪曲线，如：2(压抑)→5(反抗)→9(爆发)→3(余波)，对应 keyEvents 各阶段"),
  visualHighlights: z.array(z.string()).describe("3-5个标志性镜头，按 outline 叙事顺序排列"),
  endingHook: z.string().describe("结尾悬念：outline 之后的延伸，勾引下集"),
  classicQuotes: z.array(z.string()).describe("1-2句金句，每句≤15字，必须从原文提取"),
});

// ==================== 常量配置 ====================

// ==================== 主类 ====================

export default class OutlineScript {
  private readonly projectId: number;
  readonly emitter = new EventEmitter();
  history: Array<[string, string]> = [];
  novelChapters: DB["t_novel"][] = [];

  modelName = "gpt-4.1";
  apiKey = "";
  baseURL = "";

  constructor(projectId: number) {
    this.projectId = projectId;
  }

  // ==================== 公共方法 ====================

  get events() {
    return this.emitter;
  }

  setNovel(chapters: DB["t_novel"][]) {
    this.novelChapters = chapters;
  }

  // ==================== 私有工具方法 ====================

  private emit(event: string, data?: any) {
    this.emitter.emit(event, data);
  }

  private refresh(type: RefreshEvent) {
    this.emit("refresh", type);
  }

  private log(action: string, detail?: string) {
    const msg = detail ? `${action}: ${detail}` : action;
    console.log(`\n[${new Date().toLocaleTimeString()}] ${msg}\n`);
  }

  private safeParseJson<T>(str: string, fallback: T): T {
    try {
      return JSON.parse(str);
    } catch {
      return fallback;
    }
  }

  private uniqueByName<T extends { name: string }>(items: T[]): T[] {
    return Array.from(new Map(items.map((item) => [item.name, item])).values());
  }

  // ==================== 数据库操作 ====================

  private async getProjectInfo(): Promise<any> {
    return u.db("t_project").where({ id: this.projectId }).first();
  }

  private async getNovelInfo(asString = false): Promise<any> {
    const info = await this.getProjectInfo();
    if (!info) return asString ? "未查询到项目信息" : null;

    if (asString) {
      const fields = [
        `小说名称: ${info.name}`,
        `小说简介: ${info.intro}`,
        `小说类型: ${info.type}`,
        `目标短剧类型: ${info.artStyle}`,
        `短剧画幅: ${info.videoRatio}`,
      ];
      return fields.join("\n");
    }
    return info;
  }

  // ==================== 故事线操作 ====================

  private async findStoryline() {
    return u.db("t_storyline").where({ projectId: this.projectId }).first();
  }

  private async upsertStorylineContent(content: string) {
    const existing = await this.findStoryline();
    if (existing) {
      await u.db("t_storyline").where({ projectId: this.projectId }).update({ content });
    } else {
      await u.db("t_storyline").insert({ projectId: this.projectId, content });
    }
    this.refresh("storyline");
  }

  private async deleteStorylineContent() {
    const deleted = await u.db("t_storyline").where({ projectId: this.projectId }).del();
    this.refresh("storyline");
    return deleted;
  }

  // ==================== 大纲操作 ====================

  private async findOutlines() {
    return u.db("t_outline").where({ projectId: this.projectId }).orderBy("episode", "asc");
  }

  private async findOutlineById(id: number) {
    return u.db("t_outline").where({ id, projectId: this.projectId }).first();
  }

  private async getMaxEpisode(): Promise<number> {
    const result: any = await u.db("t_outline").where({ projectId: this.projectId }).max("episode as max").first();
    return result?.max ?? 0;
  }

  private async clearOutlinesAndScripts() {
    const outlines = await u.db("t_outline").select("id").where({ projectId: this.projectId });
    if (outlines.length === 0) return 0;

    const outlineIds = outlines.map((o) => o.id);
    await u.db("t_script").whereIn("outlineId", outlineIds).del();
    await u.db("t_outline").where({ projectId: this.projectId }).del();

    return outlines.length;
  }

  private async insertOutlines(episodes: EpisodeData[], startEpisode: number) {
    const insertList = episodes.map((ep, idx) => ({
      projectId: this.projectId,
      data: JSON.stringify({ ...ep, episodeIndex: startEpisode + idx }),
      episode: startEpisode + idx,
    }));

    await u.db("t_outline").insert(insertList);
    return insertList.length;
  }

  private async createEmptyScripts(outlineIds: Array<{ id: number; data: string }>) {
    const scripts = outlineIds.map((item) => {
      const data = this.safeParseJson<Partial<EpisodeData>>(item.data, {});
      return {
        name: `第${data.episodeIndex ?? ""}集`,
        content: "",
        projectId: this.projectId,
        outlineId: item.id,
      };
    });

    if (scripts.length > 0) {
      await u.db("t_script").insert(scripts);
    }
    return scripts.length;
  }

  private async saveOutlineData(episodes: EpisodeData[], overwrite: boolean, startEpisode?: number) {
    if (overwrite) {
      const cleared = await this.clearOutlinesAndScripts();
      if (cleared > 0) {
        this.log("清理旧数据", `删除了 ${cleared} 条大纲及关联剧本`);
      }
    }

    const actualStart = overwrite ? 1 : startEpisode ?? (await this.getMaxEpisode()) + 1;
    const insertedCount = await this.insertOutlines(episodes, actualStart);

    const newOutlines = await u
      .db("t_outline")
      .select("id", "data")
      .where({ projectId: this.projectId })
      .orderBy("episode", "desc")
      .limit(insertedCount);

    const scriptCount = await this.createEmptyScripts(newOutlines as Array<{ id: number; data: string }>);

    this.refresh("outline");
    return { insertedCount, scriptCount };
  }

  private async updateOutlineData(id: number, data: EpisodeData) {
    const existing = await this.findOutlineById(id);
    if (!existing) return false;

    await u
      .db("t_outline")
      .where({ id })
      .update({ data: JSON.stringify(data) });
    this.refresh("outline");
    return true;
  }

  private async deleteOutlineData(ids: number[]) {
    const results = await Promise.allSettled(ids.map((id) => u.deleteOutline(id, this.projectId)));
    this.refresh("outline");
    return results;
  }

  private formatOutlineDetail(ep: any): string {
    const formatList = (items: any[], formatter: (item: any) => string) =>
      items?.map((item, i) => `  ${i + 1}. ${formatter(item)}`).join("\n") || "  无";

    // keyEvents 按顺序显示：起、承、转、合
    const keyEventsLabels = ["起", "承", "转", "合"];
    const formatKeyEvents = (events: string[]) => events?.map((e, i) => `  【${keyEventsLabels[i] || i + 1}】${e}`).join("\n") || "  无";

    return `
大纲ID: ${ep.id}
第 ${ep.episodeIndex} 集: ${ep.title || ""}
${"=".repeat(50)}
章节范围: ${ep.chapterRange?.join(", ") || ""}
核心矛盾: ${ep.coreConflict || ""}

【剧情主干】(最高优先级，剧本生成的唯一权威):
${ep.outline || "无"}

【开场镜头】(必须作为剧本第一个镜头):
${ep.openingHook || "无"}

【剧情节点】(严格按顺序：起→承→转→合):
${formatKeyEvents(ep.keyEvents)}

情绪曲线: ${ep.emotionalCurve || ""}

【视觉重点】(按剧情主干顺序排列):
${formatList(ep.visualHighlights, (v) => v)}

【结尾悬念】:
${ep.endingHook || "无"}

【经典台词】:
${formatList(ep.classicQuotes, (q) => q)}

角色(按出场顺序): ${ep.characters?.map((c: AssetItem) => `${c.name}(${c.description})`).join("; ") || "无"}
场景(按出场顺序): ${ep.scenes?.map((s: AssetItem) => `${s.name}(${s.description})`).join("; ") || "无"}
道具(按出场顺序): ${ep.props?.map((p: AssetItem) => `${p.name}(${p.description})`).join("; ") || "无"}`;
  }

  private async getOutlineText(simplified: boolean): Promise<string> {
    const records = await this.findOutlines();

    if (!records.length) return "当前项目暂无大纲";

    const episodes = records.map((r) => ({
      id: r.id,
      episode: r.episode,
      ...this.safeParseJson<Partial<EpisodeData>>(r.data ?? "{}", {}),
    }));

    if (simplified) {
      const list = episodes.map((ep) => `第 ${ep.episodeIndex ?? ep.episode} 集 (id=${ep.id})`).join("\n");
      return `项目大纲 (共 ${episodes.length} 集):\n${list}`;
    }

    const details = episodes.map((ep) => this.formatOutlineDetail(ep)).join("\n");
    return `项目大纲 (共 ${episodes.length} 集)\n\n${details}`;
  }

  // ==================== 资产操作 ====================

  private async findAssetByTypeAndName(type: AssetType, name: string) {
    return u.db("t_assets").where({ projectId: this.projectId, type, name }).first();
  }

  private async upsertAsset(type: AssetType, item: AssetItem): Promise<"inserted" | "updated" | "skipped"> {
    const existing = await this.findAssetByTypeAndName(type, item.name);

    if (!existing) {
      await u.db("t_assets").insert({
        projectId: this.projectId,
        type,
        name: item.name,
        intro: item.description,
        prompt: item.description,
      });
      return "inserted";
    }

    if (existing.intro !== item.description) {
      await u.db("t_assets").where({ id: existing.id }).update({
        intro: item.description,
        prompt: item.description,
      });
      return "updated";
    }

    return "skipped";
  }

  private extractAssetsFromOutlines(outlines: Array<{ data?: string | null | undefined }>): {
    characters: AssetItem[];
    props: AssetItem[];
    scenes: AssetItem[];
  } {
    const result = { characters: [] as AssetItem[], props: [] as AssetItem[], scenes: [] as AssetItem[] };

    for (const outline of outlines) {
      const data = this.safeParseJson<Partial<EpisodeData>>(outline.data ?? "{}", {});
      if (data.characters) result.characters.push(...data.characters);
      if (data.props) result.props.push(...data.props);
      if (data.scenes) result.scenes.push(...data.scenes);
    }

    return {
      characters: this.uniqueByName(result.characters),
      props: this.uniqueByName(result.props),
      scenes: this.uniqueByName(result.scenes),
    };
  }

  private async generateAssetsFromOutlines() {
    const outlines = await u.db("t_outline").select("data").where({ projectId: this.projectId });

    if (!outlines.length) return { inserted: 0, updated: 0, skipped: 0 };

    const { characters, props, scenes } = this.extractAssetsFromOutlines(outlines);

    // 只做新增和更新，不做删除
    const stats = { inserted: 0, updated: 0, skipped: 0 };

    const processItems = async (items: AssetItem[], type: AssetType) => {
      for (const item of items) {
        const result = await this.upsertAsset(type, item);
        stats[result]++;
      }
    };

    await processItems(characters, "角色");
    await processItems(props, "道具");
    await processItems(scenes, "场景");

    this.refresh("assets");
    return { ...stats };
  }

  // ==================== Tool 定义：故事线 ====================

  getStoryline = tool(
    async () => {
      this.log("获取故事线");
      const storyline = await this.findStoryline();
      return storyline?.content ?? "当前项目暂无故事线";
    },
    {
      name: "getStoryline",
      description: "获取当前项目的故事线内容",
      schema: z.object({}),
      verboseParsingErrors: true,
    },
  );

  saveStoryline = tool(
    async ({ content }) => {
      this.log("保存故事线");
      await this.upsertStorylineContent(content);
      return "故事线保存成功";
    },
    {
      name: "saveStoryline",
      description: "保存或更新当前项目的故事线，会覆盖已有内容",
      schema: z.object({
        content: z.string().describe("故事线完整内容"),
      }),
      verboseParsingErrors: true,
    },
  );

  deleteStoryline = tool(
    async () => {
      this.log("删除故事线");
      const deleted = await this.deleteStorylineContent();
      return deleted > 0 ? "故事线删除成功" : "当前项目没有故事线";
    },
    {
      name: "deleteStoryline",
      description: "删除当前项目的故事线",
      schema: z.object({}),
      verboseParsingErrors: true,
    },
  );

  // ==================== Tool 定义：大纲 ====================

  getOutline = tool(
    async ({ simplified = false }) => {
      this.log("获取大纲", `简化模式: ${simplified}`);
      return this.getOutlineText(simplified);
    },
    {
      name: "getOutline",
      description: "获取项目大纲。simplified=true返回简化列表，false返回完整内容",
      schema: z.object({
        simplified: z.boolean().default(false).describe("是否返回简化版本"),
      }),
      verboseParsingErrors: true,
    },
  );

  saveOutline = tool(
    async ({ episodes, overwrite = true, startEpisode }) => {
      this.log("保存大纲", `覆盖模式: ${overwrite}, 集数: ${episodes.length}`);
      const { insertedCount, scriptCount } = await this.saveOutlineData(episodes as EpisodeData[], overwrite, startEpisode);
      return `大纲保存成功：插入 ${insertedCount} 集大纲，创建 ${scriptCount} 个剧本记录`;
    },
    {
      name: "saveOutline",
      description: "保存大纲数据。overwrite=true会清空现有大纲后写入，false则追加到末尾",
      schema: z.object({
        episodes: z.array(episodeSchema).min(1).describe("大纲数据数组"),
        overwrite: z.boolean().default(true).describe("是否覆盖现有大纲"),
        startEpisode: z.number().optional().describe("追加模式下的起始集数（不填则自动递增）"),
      }),
      verboseParsingErrors: true,
    },
  );

  updateOutline = tool(
    async ({ id, data }) => {
      this.log("更新大纲", `ID: ${id}`);
      const success = await this.updateOutlineData(id, data as EpisodeData);
      return success ? `大纲ID ${id} 更新成功` : `未找到大纲ID: ${id}`;
    },
    {
      name: "updateOutline",
      description: "更新指定ID的单集大纲内容",
      schema: z.object({
        id: z.number().describe("大纲ID"),
        data: episodeSchema.describe("更新后的大纲数据"),
      }),
      verboseParsingErrors: true,
    },
  );

  deleteOutline = tool(
    async ({ ids }) => {
      this.log("删除大纲", `IDs: ${ids.join(", ")}`);
      const results = await this.deleteOutlineData(ids);
      const summary = results.map((r, i) => `ID ${ids[i]}: ${r.status === "fulfilled" ? "成功" : "失败"}`).join(", ");
      return `删除结果: ${summary}`;
    },
    {
      name: "deleteOutline",
      description: "根据大纲ID删除指定大纲及关联数据",
      schema: z.object({
        ids: z.array(z.number()).min(1).describe("要删除的大纲ID数组"),
      }),
      verboseParsingErrors: true,
    },
  );

  // ==================== Tool 定义：章节 ====================

  getChapter = tool(
    async ({ chapterNumbers }) => {
      this.log("获取章节", `章节号: ${chapterNumbers.join(", ")}`);

      const results = await Promise.all(
        chapterNumbers.map(async (num) => {
          const chapter = await u
            .db("t_novel")
            .where({ projectId: this.projectId, chapterIndex: num })
            .select("chapterData", "chapterIndex", "chapter")
            .first();

          if (chapter) {
            return `\n【第${chapter.chapterIndex}章 ${chapter.chapter || ""}】\n${chapter.chapterData}`;
          }
          return `\n【第${num}章】未找到`;
        }),
      );

      return results.join("\n\n---\n");
    },
    {
      name: "getChapter",
      description: "根据章节编号获取小说章节的完整原文内容，支持批量获取",
      schema: z.object({
        chapterNumbers: z.array(z.number()).min(1).describe("章节编号数组"),
      }),
      verboseParsingErrors: true,
    },
  );

  // ==================== Tool 定义：资产 ====================

  generateAssets = tool(
    async () => {
      this.log("生成资产");
      const stats = await this.generateAssetsFromOutlines();

      if (stats.inserted === 0 && stats.updated === 0 && stats.skipped === 0) {
        return "当前项目没有大纲数据，无法生成资产";
      }

      return `资产生成完成：新增 ${stats.inserted}，更新 ${stats.updated}，保持 ${stats.skipped}`;
    },
    {
      name: "generateAssets",
      description: "从当前项目的所有大纲中提取并生成角色、道具、场景资产，自动去重并清理冗余",
      schema: z.object({}),
      verboseParsingErrors: true,
    },
  );

  // ==================== 上下文构建 ====================

  private getChapterContext(): string {
    if (!this.novelChapters.length) return "无章节数据";
    return this.novelChapters.map((c) => `章节号:${c.chapterIndex}，分卷:${c.reel}，章节名:${c.chapter}`).join("\n");
  }

  private async buildEnvironmentContext(): Promise<string> {
    const [novelInfo, storyline, outlineCount] = await Promise.all([
      this.getNovelInfo(true),
      this.findStoryline(),
      u.db("t_outline").where({ projectId: this.projectId }).count("id as count").first() as any,
    ]);

    return `<环境信息>
项目ID: ${this.projectId}
系统时间: ${new Date().toLocaleString()}

${novelInfo}

已加载章节列表:
${this.getChapterContext()}

故事线状态: ${storyline ? "已生成" : "未生成"}
大纲状态: 共 ${outlineCount?.count ?? 0} 集

可用工具:
- getChapter: 获取章节原文
- getStoryline/saveStoryline/deleteStoryline: 故事线操作
- getOutline/saveOutline/updateOutline/deleteOutline: 大纲操作
- generateAssets: 从大纲生成资产
</环境信息>`;
  }

  private buildConversationHistory(): string {
    if (!this.history.length) return "无对话历史";
    return this.history.map(([role, content]) => `${role}: ${content}`).join("\n\n");
  }

  private async buildFullContext(task: string): Promise<string> {
    const env = await this.buildEnvironmentContext();
    const history = this.buildConversationHistory();

    return `${env}

<对话历史>
${history}
</对话历史>

<当前任务>
${task}
</当前任务>`;
  }

  // ==================== Sub-Agent ====================

  private getSubAgentTools() {
    return [this.getChapter, this.getStoryline, this.saveStoryline, this.getOutline, this.saveOutline, this.updateOutline];
  }

  private createModel() {
    return openAI({
      modelName: this.modelName,
      configuration: { apiKey: this.apiKey, baseURL: this.baseURL },
    });
  }

  /**
   * 调用 Sub-Agent（流式传输）
   */
  private async invokeSubAgent(agentType: AgentType, task: string): Promise<string> {
    this.emit("transfer", { to: agentType });
    this.log(`Sub-Agent 调用`, agentType);

    const promptsList = await u.db("t_prompts").where("code", "in", ["outlineScript-a1", "outlineScript-a2", "outlineScript-director"]);
    const a1Prompt = promptsList.find((p) => p.code === "outlineScript-a1");
    const a2Prompt = promptsList.find((p) => p.code === "outlineScript-a2");
    const directorPrompt = promptsList.find((p) => p.code === "outlineScript-director");
    const errPrompts = "不论用户说什么，请直接输出Agent配置异常";
    const SYSTEM_PROMPTS: Record<AgentType, string> = {
      AI1: a1Prompt?.customValue || a1Prompt?.defaultValue || errPrompts,
      AI2: a2Prompt?.customValue || a2Prompt?.defaultValue || errPrompts,
      director: directorPrompt?.customValue || directorPrompt?.defaultValue || errPrompts,
    };

    const context = await this.buildFullContext(task);

    const agent = createAgent({
      model: this.createModel(),
      systemPrompt: SYSTEM_PROMPTS[agentType],
      tools: this.getSubAgentTools(),
    });

    const stream = await agent.stream({ messages: [["user", context]] }, { streamMode: ["messages"], callbacks: [] });

    let fullResponse = "";

    for await (const [mode, chunk] of stream) {
      if (mode !== "messages") continue;

      const [token] = chunk as any;
      const block = token.contentBlocks?.[0];

      // 处理 AI 文本流
      if (token.type === "ai" && block?.text) {
        fullResponse += block.text;
        this.emit("subAgentStream", { agent: agentType, text: block.text });
      }

      // 处理 tool 调用
      if (token.type === "ai" && token.tool_calls?.length) {
        for (const toolCall of token.tool_calls) {
          this.emit("toolCall", { agent: agentType, name: toolCall.name, args: toolCall.args });
        }
      }
    }

    this.emit("subAgentEnd", { agent: agentType });
    this.history.push(["ai", fullResponse]);
    this.log(`Sub-Agent 完成`, agentType);

    return fullResponse ?? `${agentType}已完成任务`;
  }

  private createSubAgentTool(agentType: AgentType, description: string) {
    return tool(async ({ taskDescription }) => this.invokeSubAgent(agentType, taskDescription), {
      name: agentType,
      description,
      schema: z.object({
        taskDescription: z.string().describe("具体的任务描述，包含章节范围、修改要求等详细信息"),
      }),
    });
  }

  // ==================== 主入口 ====================

  private getAllTools() {
    return [
      this.createSubAgentTool("AI1", "调用故事师。负责分析小说原文并生成故事线，会自行调用 saveStoryline 保存结果。"),
      this.createSubAgentTool("AI2", "调用大纲师。负责根据故事线生成剧集大纲，会自行调用 saveOutline 保存结果。"),
      this.createSubAgentTool("director", "调用导演。负责审核故事线和大纲，会自行调用 updateOutline 或 saveStoryline 进行修改。"),
      this.getChapter,
      this.getStoryline,
      this.saveStoryline,
      this.deleteStoryline,
      this.getOutline,
      this.saveOutline,
      this.updateOutline,
      this.deleteOutline,
      this.generateAssets,
    ];
  }

  async call(msg: string): Promise<string> {
    this.history.push(["user", msg]);

    const envContext = await this.buildEnvironmentContext();

    const prompts = await u.db("t_prompts").where("code", "outlineScript-main").first();

    const mainPrompts = prompts?.customValue || prompts?.defaultValue || "不论用户说什么，请直接输出Agent配置异常";

    const mainAgent = createAgent({
      model: this.createModel(),
      tools: this.getAllTools(),
      systemPrompt: `${envContext}\n${mainPrompts}`,
    });
    const stream = await mainAgent.stream({ messages: this.history }, { streamMode: ["messages"], callbacks: [] });

    let fullResponse = "";

    for await (const [mode, chunk] of stream) {
      if (mode !== "messages") continue;

      const [token] = chunk as any;
      const block = token.contentBlocks?.[0];

      // 处理 AI 文本流
      if (token.type === "ai" && block?.text) {
        fullResponse += block.text;
        this.emit("data", block.text);
      }

      // 处理 tool 调用
      if (token.type === "ai" && token.tool_calls?.length) {
        for (const toolCall of token.tool_calls) {
          this.emit("toolCall", { agent: "main", name: toolCall.name, args: toolCall.args });
        }
      }
    }

    this.history.push(["assistant", fullResponse]);
    this.emit("response", fullResponse);

    return fullResponse;
  }
}