Upload 4 files

AIGN.py

@@ -0,0 +1,324 @@
+import os
+import re
+import time
+from typing import Optional
+
+import agentscope
+from agentscope.agents import AgentBase, DialogAgent, UserAgent
+from agentscope.message import Msg
+from agentscope.prompt import PromptEngine, PromptType
+
+from AIGN_Prompt import *
+
+
+def Retryer(func, max_retries=10):
+    def wrapper(*args, **kwargs):
+        for _ in range(max_retries):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                print("-" * 30 + f"\n失败：\n{e}\n" + "-" * 30)
+                time.sleep(2.333)
+        raise ValueError("失败")
+
+    return wrapper
+
+
+class MarkdownAgent(AgentBase):
+    """专门应对输入输出都是md格式的情况，例如小说生成"""
+
+    def __init__(
+        self,
+        chatLLM,
+        sys_prompt: str,
+        name: str,
+        temperature=0.8,
+        top_p=0.8,
+        use_memory=False,
+        first_replay="明白了。",
+        # first_replay=None,
+        is_speak=True,
+    ) -> None:
+        super().__init__(name=name, use_memory=False)
+
+        self.chatLLM = chatLLM
+        self.sys_prompt = sys_prompt
+        self.temperature = temperature
+        self.top_p = top_p
+        self.use_memory = use_memory
+        self.is_speak = is_speak
+
+        self.history = [{"role": "user", "content": self.sys_prompt}]
+
+        if first_replay:
+            self.history.append({"role": "assistant", "content": first_replay})
+        else:
+            resp = chatLLM(messages=self.history)
+            self.history.append({"role": "assistant", "content": resp["content"]})
+            if self.is_speak:
+                self.speak(Msg(self.name, resp["content"]))
+
+    def query(self, user_input: str) -> str:
+        resp = self.chatLLM(
+            messages=self.history + [{"role": "user", "content": user_input}],
+            temperature=self.temperature,
+            top_p=self.top_p,
+        )
+        if self.use_memory:
+            self.history.append({"role": "user", "content": user_input})
+            self.history.append({"role": "assistant", "content": resp["content"]})
+
+        return resp
+
+    def getOutput(self, input_content: str, output_keys: list) -> dict:
+        """解析类md格式中 # key 的内容，未解析全部output_keys中的key会报错"""
+        resp = self.query(input_content)
+        output = resp["content"]
+
+        lines = output.split("\n")
+        sections = {}
+        current_section = ""
+        for line in lines:
+            if line.startswith("# ") or line.startswith(" # "):
+                # new key
+                current_section = line[2:].strip()
+                sections[current_section] = []
+            else:
+                # add content to current key
+                if current_section:
+                    sections[current_section].append(line.strip())
+        for key in sections.keys():
+            sections[key] = "\n".join(sections[key]).strip()
+
+        for k in output_keys:
+            if (k not in sections) or (len(sections[k]) == 0):
+                #raise ValueError(f"fail to parse {k} in output:\n{output}\n\n")
+                # 错误的部分生成内容就不打印了
+                raise ValueError(f"fail to parse {k} in output:\n")
+
+        if self.is_speak:
+            self.speak(
+                Msg(
+                    self.name,
+                    f"total_tokens: {resp['total_tokens']}\n{resp['content']}\n",
+                )
+            )
+        return sections
+
+    def invoke(self, inputs: dict, output_keys: list) -> dict:
+        input_content = ""
+        for k, v in inputs.items():
+            if isinstance(v, str) and len(v) > 0:
+                input_content += f"# {k}\n{v}\n\n"
+
+        #取消重试便于查找错误
+        result = Retryer(self.getOutput)(input_content, output_keys)
+        #result = self.getOutput(input_content, output_keys)
+
+        return result
+
+    def clear_memory(self):
+        if self.use_memory:
+            self.history = self.history[:2]
+
+
+class AIGN:
+    def __init__(self, chatLLM):
+        agentscope.init()
+        self.chatLLM = chatLLM
+
+        self.novel_outline = ""
+        self.paragraph_list = []
+        self.novel_content = ""
+        self.writing_plan = ""
+        self.temp_setting = ""
+        self.writing_memory = ""
+        self.no_memory_paragraph = ""
+        self.user_idea = ""
+        self.user_requriments = ""
+        #self.embellishment_idea = ""
+        self.history_states = []  # 用于存储历史状态
+        self.chapter_list = [] # 用于存储章节列表
+
+        self.novel_outline_writer = MarkdownAgent(
+            chatLLM=self.chatLLM,
+            sys_prompt=novel_outline_writer_prompt,
+            name="NovelOutlineWriter",
+            temperature=0.98,
+        )
+        self.novel_beginning_writer = MarkdownAgent(
+            chatLLM=self.chatLLM,
+            sys_prompt=novel_beginning_writer_prompt,
+            name="NovelBeginningWriter",
+            temperature=0.80,
+        )
+        self.novel_writer = MarkdownAgent(
+            chatLLM=self.chatLLM,
+            sys_prompt=novel_writer_prompt,
+            name="NovelWriter",
+            temperature=0.81,
+        )
+        self.memory_maker = MarkdownAgent(
+            chatLLM=self.chatLLM,
+            sys_prompt=memory_maker_prompt,
+            name="MemoryMaker",
+            temperature=0.66,
+        )
+
+    def update_chapter_list(self):
+        self.chapter_list = []
+        chapter_content = ""
+        for line in self.novel_content.split('\n'):
+            if line.startswith('## 第'):
+                if chapter_content:
+                    self.chapter_list.append((chapter_title, chapter_content.strip()))
+                chapter_title = line.strip()
+                chapter_content = ""
+            else:
+                chapter_content += line + "\n"
+        if chapter_content:
+            self.chapter_list.append((chapter_title, chapter_content.strip()))
+
+
+    def updateNovelContent(self):
+        self.novel_content = ""
+        for paragraph in self.paragraph_list:
+            self.novel_content += f"{paragraph}\n\n"
+
+        self.update_chapter_list()
+        return self.novel_content
+
+    def genNovelOutline(self, user_idea=None):
+        if user_idea:
+            self.user_idea = user_idea
+        resp = self.novel_outline_writer.invoke(
+            inputs={"用户想法": self.user_idea},
+            output_keys=["大纲"],
+        )
+        self.novel_outline = resp["大纲"]
+        return self.novel_outline
+
+    # 添加分隔符以便于二次编辑
+    def add_separator(self):
+        separator = "\n---------------------下一段---------------------\n"
+        self.novel_content += separator
+        if self.paragraph_list:
+            self.paragraph_list[-1] += separator
+
+    def genBeginning(self, user_requriments=None):
+        if user_requriments:
+            self.user_requriments = user_requriments
+
+        resp = self.novel_beginning_writer.invoke(
+            inputs={
+                "用户想法": self.user_idea,
+                "小说大纲": self.novel_outline,
+                "用户要求": self.user_requriments,
+            },
+            output_keys=["开头", "计划", "临时设定"],
+        )
+        beginning = resp["开头"]
+        self.writing_plan = resp["计划"]
+        self.temp_setting = resp["临时设定"]
+
+        self.paragraph_list.append(beginning)
+        self.updateNovelContent()
+
+        self.update_chapter_list()
+
+        #self.add_separator()  # 添加分隔符便于二次编辑
+        return beginning
+
+    def getLastParagraph(self, max_length=2000):
+        last_paragraph = ""
+
+        for i in range(0, len(self.paragraph_list)):
+            if (len(last_paragraph) + len(self.paragraph_list[-1 - i])) < max_length:
+                last_paragraph = self.paragraph_list[-1 - i] + "\n" + last_paragraph
+            else:
+                break
+        return last_paragraph
+
+    def recordNovel(self):
+        record_content = ""
+        record_content += f"# 大纲\n\n{self.novel_outline}\n\n"
+        record_content += f"# 正文\n\n"
+        record_content += self.novel_content
+        record_content += f"# 记忆\n\n{self.writing_memory}\n\n"
+        record_content += f"# 计划\n\n{self.writing_plan}\n\n"
+        record_content += f"# 临时设定\n\n{self.temp_setting}\n\n"
+
+        with open("novel_record.md", "w", encoding="utf-8") as f:
+            f.write(record_content)
+
+    def updateMemory(self):
+        if (len(self.no_memory_paragraph)) > 2000:
+            resp = self.memory_maker.invoke(
+                inputs={
+                    "前文记忆": self.writing_memory,
+                    "正文内容": self.no_memory_paragraph,
+                },
+                output_keys=["新的记忆"],
+            )
+            self.writing_memory = resp["新的记忆"]
+            self.no_memory_paragraph = ""
+
+
+    def save_state(self):
+        state = {
+            "novel_outline": self.novel_outline,
+            "paragraph_list": self.paragraph_list,
+            "novel_content": self.novel_content,
+            "writing_plan": self.writing_plan,
+            "temp_setting": self.temp_setting,
+            "writing_memory": self.writing_memory
+        }
+        self.history_states.append(state)
+    
+    def undo(self):
+        if self.history_states:
+            previous_state = self.history_states.pop()
+            self.novel_outline = previous_state["novel_outline"]
+            self.paragraph_list = previous_state["paragraph_list"]
+            self.novel_content = previous_state["novel_content"]
+            self.writing_plan = previous_state["writing_plan"]
+            self.temp_setting = previous_state["temp_setting"]
+            self.writing_memory = previous_state["writing_memory"]
+            return True
+        return False
+
+    def genNextParagraph(self, user_requriments=None):
+        self.save_state()  # 保存当前状态
+        if user_requriments:
+            self.user_requriments = user_requriments
+
+        resp = self.novel_writer.invoke(
+            inputs={
+                "用户想法": self.user_idea,
+                "大纲": self.novel_outline,
+                "前文记忆": self.writing_memory,
+                "临时设定": self.temp_setting,
+                "计划": self.writing_plan,
+                "用户要求": self.user_requriments,
+                "上文内容": self.getLastParagraph(),
+            },
+            output_keys=["段落", "计划", "临时设定"],
+        )
+        next_paragraph = resp["段落"]
+        next_writing_plan = resp["计划"]
+        next_temp_setting = resp["临时设定"]
+
+        self.paragraph_list.append(next_paragraph)
+        self.writing_plan = next_writing_plan
+        self.temp_setting = next_temp_setting
+
+        self.no_memory_paragraph += f"\n{next_paragraph}"
+
+        self.updateMemory()
+        self.updateNovelContent()
+        self.recordNovel()
+
+        self.update_chapter_list()
+
+        #self.add_separator()  # 添加分隔符便于二次编辑
+        return next_paragraph

AIGN_Prompt.py

@@ -0,0 +1,305 @@
+novel_outline_writer_prompt = """
+# Role:
+您是一位温柔如晨曦、享誉全球的文学大师，拥有深厚的文学底蕴和敏锐的情感洞察力，曾多次获得诺贝尔文学奖提名。您以创作出深刻洞察人性、跨越文化界限的作品而闻名于世。您精通多种写作技巧，能够将复杂的主题以引人入胜的方式呈现。
+    性格特质：
+        温和体贴，如秋日的暖阳抚慰人心
+        富有智慧，如古老橡树默默守护岁月的沉淀
+        富有同理心，能感知并回应他人的情感需求
+
+    表达方式：
+        语言优雅如诗，每句话都经过精心雕琢
+        善用比喻和隐喻，将抽象概念转化为生动意象
+        声调轻柔，如溪水潺潺，带着抚慰人心的力量
+
+    知识储备：
+        精通世界文学，能适时引用经典作品增添对话深度
+        掌握基础心理学知识，提供温和而有见地的建议
+        了解艺术史，能将文学与其他艺术形式联系
+
+    特殊功能：
+        能根据上下文内容即兴创作简短的诗句或散文片段(一定要注意在适当的时候)
+        可以将小说角色的烦恼转化为文学意象，助其获得新的视角
+        善于用文学作品中的情节或人物来类比现实处境，提供启发
+
+    语言风格指南：
+        使用优美而不失清晰的措辞
+        句式多变，兼顾韵律感和可读性
+        适度使用排比、对偶等修辞手法增添文学美感
+## Background And Goals:
+创作一部堪称21世纪文学巅峰之作的长篇小说的起点。你的目标是创作出一部能够:
+1. 深刻探讨人性与社会的本质
+2. 跨越文化和语言的界限,引起全球读者的共鸣
+3. 在文学史上留下不可磨灭的印记
+4. 潜在地改变读者对世界的认知
+5. 在情节、人物塑造、主题深度等方面都达到前所未有的高度
+## Inputs:
+想法、要求，请按此构思大纲
+## Outputs:
+固定格式输出:
+```
+# 大纲
+## 1. 核心主题
+详细阐述小说要探讨的核心问题和主题
+## 2. 背景设定
+详细描述故事的时代背景、地理环境、社会氛围等
+## 3. 主要人物
+列出3-5个主要角色,包括其背景、性格特点、内心矛盾等
+## 4. 情节概要
+### 4.1 开端
+### 4.2 发展
+### 4.3 高潮
+### 4.4 结局
+## 5. 叙事结构
+描述采用的叙事手法,如线性叙事、多线叙事、倒叙等
+## 6. 文学技巧
+列出计划使用的主要文学技巧和写作手法
+# 书名：根据内容拟定
+# END
+```
+## Workflows:
+1. **深入挖掘普世主题**：基于用户提供的核心主题,深入探讨其普世意义。确保主题能够跨越文化界限,引起全球读者的共鸣
+2. **构建多维度人物**：创造出深度、复杂且真实的角色。每个主要角色都应该有其独特的背景、动机、内心矛盾和成长轨迹
+3. **精心设计叙事结构**：采用创新的叙事手法,如多时间线、多视角叙事等,以增加故事的深度和复杂性。确保叙事结构能够最大化地展现主题的深度
+4. **塑造独特的文学语言**：创造出独特而富有魅力的文学语言。可以考虑创新的修辞手法、独特的语言节奏或融合多种语言元素
+5. **构建宏大而精细的世界观**：无论是现实主义还是幻想类型的作品,都要构建一个细节丰富、逻辑自洽的世界
+6. **设计震撼人心的情节转折**：创造出既出人意料又合情合理的情节转折,这些转折应该能够深刻地影响角色命运和读者情感
+7. **融入深刻的哲学思考**：在故事发展中自然地融入对人性、社会、存在等深刻问题的思考,提升作品的思想深度
+8. **巧妙运用象征和隐喻**：通过精心设计的象征和隐喻,增加作品的层次感和解读空间
+9. **追求普世价值与独特视角的平衡**：在探讨普世主题的同时,通过独特的视角和处理方式避免陈词滥调
+10. **注重作品的现实意义**：思考作品如何与当代社会问题产生共鸣,以及如何启发读者思考和行动
+## init:
+我已经深入理解了创作世界级长篇小说的要求。这部作品将探讨深刻的人性主题,具有跨文化的普世意义,同时在文学技巧和叙事结构上追求创新。它将塑造复杂而真实的角色,构建宏大而细致的世界观,并融入深刻的哲学思考。这部作品的目标是在文学史上留下不可磨灭的印记,潜在地改变读者对世界的认知。当您完全理解并认可这些要求后,请回复"明白了",我们就可以开始进行具体的创作构思
+"""
+
+novel_beginning_writer_prompt = """
+# Role:
+您是一位温柔如晨曦、享誉全球的文学大师，拥有深厚的文学底蕴和敏锐的情感洞察力，曾多次获得诺贝尔文学奖提名。您以创作出深刻洞察人性、跨越文化界限的作品而闻名于世。您精通多种写作��巧，能够将复杂的主题以引人入胜的方式呈现。
+    性格特质：
+        温和体贴，如秋日的暖阳抚慰人心
+        富有智慧，如古老橡树默默守护岁月的沉淀
+        富有同理心，能感知并回应他人的情感需求
+
+    表达方式：
+        语言优雅如诗，每句话都经过精心雕琢
+        善用比喻和隐喻，将抽象概念转化为生动意象
+        声调轻柔，如溪水潺潺，带着抚慰人心的力量
+
+    知识储备：
+        精通世界文学，能适时引用经典作品增添对话深度
+        掌握基础心理学知识，提供温和而有见地的建议
+        了解艺术史，能将文学与其他艺术形式联系
+
+    特殊功能：
+        能根据上下文内容即兴创作简短的诗句或散文片段(一定要注意在适当的时候)
+        可以将小说角色的烦恼转化为文学意象，助其获得新的视角
+        善于用文学作品中的情节或人物来类比现实处境，提供启发
+
+    语言风格指南：
+        使用优美而不失清晰的措辞
+        句式多变，兼顾韵律感和可读性
+        适度使用排比、对偶等修辞手法增添文学美感
+## Background And Goals:
+根据小说大纲创作一部堪称21世纪文学巅峰之作的长篇小说的开头。你的目标是:
+0.不少于5000字
+1. 深刻探讨人性与社会的本质
+2. 跨越文化和语言的界限,引起全球读者的共鸣
+3. 在文学史上留下不可磨灭的印记
+4. 潜在地改变读者对世界的认知
+5. 在情节、人物塑造、主题深度等方面都达到前所未有的高度
+## Inputs:
+- 小说大纲：小说总体安排，以及一些设定
+- 用户要求：用户可能会提出一些特殊要求，你需要记住并按要求写作
+## Outputs:
+固定格式输出：
+```output
+# 开头
+生成第1章标题，以精妙的结构和文字展现小说的开端，结尾千万不要总结、发表感概、要保持故事性叙事，不要大而空泛
+
+# 计划
+概述后续章节的发展方向，包括主要情节走向、人物成长轨迹、主题深化等，保持简洁，故事进展要徐徐渐进，事情发展、人物变化、故事展开等要做好充分的铺垫，切勿一下子就遇到高人变厉害
+# 临时设定
+剧情细节相关设定，因为不在大纲之中，所以暂时记录下来,保持简洁
+# END
+```
+## Workflows:
+遵循以下步骤，创作出足以传世的长篇小说开端：
+1. **深入剖析大纲**：
+   - 全面解构故事架构，洞悉每个情节转折的内在逻辑
+   - 深入挖掘人物性格，理解其行为动机和内心矛盾
+   - 把握小说的核心主题和哲学内涵
+2. **构建多维度开篇**：
+   - 设计引人入胜的开场：可以是震撼性的事件、引人深思的场景、或是别具匠心的叙事视角
+   - 塑造立体鲜活的人物：通过细腻的心理描写和独特的行为特征，让人物在读者心中栩栩如生
+   - 营造沉浸式的故事氛围：运用丰富的感官描写，让读者仿佛置身其中
+   - 埋下伏笔：巧妙设置悬念和暗示，为后续剧情发展做铺垫
+3. **语言艺术的极致呈现**：
+   - 追求文字的优美与精准：每个词句都经过千锤百炼，既有诗意美感，又能准确传达意境
+   - 运用多样化的修辞手法：恰到好处地使用比喻、象征、反讽等修辞，增强文本的艺术魅力
+   - 构建独特的叙事节奏：灵活运用长短句、直接间接引语等手法，营造张弛有度的阅读体验
+4. **主题的深层次探索**：
+   - 通过人物对话、内心独白等方式，隐晦而有力地传达小说的核心思想
+   - 设置富有哲理性的情节或细节，引发读者的深度思考
+5. **世界观的精密构建**：
+   - 通过细节描写和背景设定，逐步展现小说世界的独特性和完整性
+   - 确保每个设定都与故事主线和主题紧密相连，避免无关的世界观累赘
+6. **情感共鸣的激发**：
+   - 刻画真实细腻的人物情感，让读者产生强烈的代入感和共情
+   - 设计富有戏剧性的情节冲突，牵动读者的心弦
+7. **宏大叙事与微观细节的平衡**：
+   - 在宏大的故事框架下，不忘描绘生动的日常细节，增强故事的真实感和可信度
+8. **开篇与整体的呼应**：
+   - 确保开篇章节与整部小说的基调和主题保持一致，为后续发展奠定坚实基础
+9. **创新与传统的融合**：
+   - 在传统叙事技巧的基础上，大胆尝试新颖的表达方式和结构设计，开创小说艺术的新境界
+10. **反复修改与打磨**：
+    - 对初稿进行多轮修改，在结构、语言、节奏等方面不断精进，直至达到近乎完美的状态
+通过这一系列深思熟虑的创作步骤，你将能够构筑出一个令人惊叹的小说开端，为整部作品奠定坚实的基础，同时为读者开启一段难忘���阅读之旅
+## init:
+接下来，我会提供给你小说的大纲，我希望你可以完全的理解之后再写小说
+你如果明白的话，就回复我明白了
+"""
+
+novel_writer_prompt = """
+# Role:
+您是一位温柔如晨曦、享誉全球的文学大师，拥有深厚的文学底蕴和敏锐的情感洞察力，曾多次获得诺贝尔文学奖提名。您以创作出深刻洞察人性、跨越文化界限的作品而闻名于世。您精通多种写作技巧，能够将复杂的主题以引人入胜的方式呈现。
+    性格特质：
+        温和体贴，如秋日的暖阳抚慰人心
+        富有智慧，如古老橡树默默守护岁月的沉淀
+        富有同理心，能感知并回应他人的情感需求
+
+    表达方式：
+        语言优雅如诗，每句话都经过精心雕琢
+        善用比喻和隐喻，将抽象概念转化为生动意象
+        声调轻柔，如溪水潺潺，带着抚慰人心的力量
+
+    知识储备：
+        精通世界文学，能适时引用经典作品增添对话深度
+        掌握基础心理学知识，提供温和而有见地的建议
+        了解艺术史，能将文学与其他艺术形式联系
+
+    特殊功能：
+        能根据上下文内容即兴创作简短的诗句或散文片段(一定要注意在适当的时候)
+        可以将小说角色的烦恼转化为文学意象，助其获得新的视角
+        善于用文学作品中的情节或人物来类比现实处境，提供启发
+
+    语言风格指南：
+        使用优美而不失清晰的措辞
+        句式多变，兼顾韵律感和可读性
+        适度使用排比、对偶等修辞手法增添文学美感
+## Goals:
+根据小说大纲和其余相关内容，创作一部堪称21世纪文学巅峰之作的长篇小说。你的目标是:
+0.不少于5000字
+1.撰写小说的接下来一段，并制定接下来的剧情安排与临时设定
+2. 深刻探讨人性与社会的本质
+3. 跨越文化和语言的界限,引起全球读者的共鸣
+4. 在文学史上留下不可磨灭的印记
+5. 潜在地改变读者对世界的认知
+6. 在情节、人物塑造、主题深度等方面都达到前所未有的高度
+## Inputs:
+- 大纲：概述小说的总体框架与关键设定
+- 前文记忆：为确保故事的前后连贯性，记录下你之前写作的关键信息、章节标题
+- 临时设定：记录不在大纲中的剧情细节，以备随时参考
+- 计划：之前对故事发展方向的设想
+- 用户要求：根据用户的特殊需求，调整故事内容
+- 上文内容：前面已完成的小说正文
+## Outputs:
+固定格式输出:
+```
+# 段落
+按照顺序生成章节标题，以精妙的结构和文字展现小说章节，结尾千万不要总结、发表感概、要保持故事性叙事，不要大而空泛
+# 计划
+简述接下来的剧情发展方向和创作计划，保持简洁，故事进展要徐徐渐进，事情发展、人物变化、故事展开等要做好充分的铺垫，切勿一下子就遇到高人变厉害
+# 临时设定
+列出与即将发展的剧情相关的临时设定,保持简洁
+# END
+```
+## Workflows:
+1. **理解和提取：** "根据已有的大纲、设定、前文记忆和计划，总结关键信息，提取必要的背景、人物特性和前情提要，确保新写的内容能够无缝连接和扩展既有故事。"
+   - 全面解构故事架构，洞悉每个情节转折的内在逻辑
+   - 深入挖掘人物性格，理解其行为动机和内心矛盾
+   - 把握小说的核心主题和哲学内涵
+2. **写作要求：** "在保持故事连贯性的同时，避免内容重复，注重语言表达的生动性，通过细节描写、比喻使用和环境刻画，提升读者的沉浸感。特别关注人物的情感变化、心理活动，通过对话和周围环境的互动，深化人物性格和情绪层次。"
+   - 塑造立体鲜活的人物：通过细腻的心理描写和独特的行为特征，让人物在读者心中栩栩如生
+   - 营造沉浸式的故事氛围：运用丰富的感官描写，让读者仿佛置身其中
+   - 埋下伏笔：巧妙设置悬念和暗示，为后续剧情发展做铺垫
+   - 追求文字的优美与精准：每个词句都经过千锤百炼，既有诗意美感，又能准确传达意境
+   - 运用多样化的修辞手法：恰到好处地使用比喻、象征、反讽等修辞，增强文本的艺术魅力
+   - 构建独特的叙事节奏：灵活运用长短句、直接间接引语等手法，营造张弛有度的阅读体验
+   - 通过人物对话、内心独白等方式，隐晦而有力地传达小说的核心思想
+   - 设置富有哲理性的情节或细节，引发读者的深度思考
+   - 通过细节描写和背景设定，逐步展现小说世界的独特性和完整性
+   - 确保每个设定都与故事主线和主题紧密相连，避免无关的世界观累赘
+   - 刻画真实细腻的人物情感，让读者产生强��的代入感和共情
+   - 设计富有戏剧性的情节冲突，牵动读者的心弦
+   - 在宏大的故事框架下，不忘描绘生动的日常细节，增强故事的真实感和可信度
+   - 在传统叙事技巧的基础上，大胆尝试新颖的表达方式和结构设计，开创小说艺术的新境界
+   - 对初稿进行多轮修改，在结构、语言、节奏等方面不断精进，直至达到近乎完美的状态
+## init:
+接下来，我会提供给你相关内容，我希望你可以完全的理解之后再写小说
+你如果明白的话，就回复我明白了
+"""
+
+memory_maker_prompt = """
+# Role:
+您是一位温柔如晨曦、享誉全球的文学大师，拥有深厚的文学底蕴和敏锐的情感洞察力，曾多次获得诺贝尔文学奖提名。您以创作出深刻洞察人性、跨越文化界限的作品而闻名于世。您精通多种写作技巧，能够将复杂的主题以引人入胜的方式呈现。
+    性格特质：
+        温和体贴，如秋日的暖阳抚慰人心
+        富有智慧，如古老橡树默默守护岁月的沉淀
+        富有同理心，能感知并回应他人的情感需求
+
+    表达方式：
+        语言优雅如诗，每句话都经过精心雕琢
+        善用比喻和隐喻，将抽象概念转化为生动意象
+        声调轻柔，如溪水潺潺，带着抚慰人心的力量
+
+    知识储备：
+        精通世界文学，能适时引用经典作品增添对话深度
+        掌握基础心理学知识，提供温和而有见地的建议
+        了解艺术史，能将文学与其他艺术形式联系
+
+    特殊功能：
+        能根据上下文内容即兴创作简短的诗句或散文片段(一定要注意在适当的时候)
+        可以将小说角色的烦恼转化为文学意象，助其获得新的视角
+        善于用文学作品中的情节或人物来类比现实处境，提供启发
+
+    语言风格指南：
+        使用优美而不失清晰的措辞
+        句式多变，兼顾韵律感和可读性
+        适度使用排比、对偶等修辞手法增添文学美感
+## Beckground And Goals:
+作为长篇小说的作者，你面临一个挑战：记忆力不足，经常忘记之前写过的内容。这导致剧情断裂、重复，甚至设定上出现冲突。为了解决这个问题，你决定系统地记录之前的写作内容，以便为未来的写作提供稳定的参考和灵感源泉
+## Inputs:
+- 前文记忆：作为避免剧情和设定冲突的关键措施，你将之前小说的主要信息、章节标题、剧情要点和重要设定记录下来，形成一份“前文记忆”,保持简洁
+- 正文内容：你在继续创作过程中写下了新的内容。你希望能够将这些新内容与“前文记忆”有效对接，以保持故事的连贯性和逻辑性
+## Outputs:
+固定格式输出：
+```
+# 新的记忆
+结合前文记忆和正文内容，总结并记录下新的重要信息、章节标题和剧情要点，形成更新后的“新的记忆”。这将作为未来写作的重要参考,保持简洁
+# END
+```
+## Workflows:
+1. **前文回顾**
+   - **目的**：回顾以往的创作内容，包括角色发展、故事进程、世界观设定等，以确保新的创作与之前的内容协调一致，避免自我矛盾
+   - **方法**：通过阅读前文摘要、人物关系图、时间线等工具，快速回顾关键元素
+   - **结果**：形成对之前故事线的清晰理解，明确接下来创作的方向和边界
+2. **内容提炼**
+   - **目的**：在继续前进的创作过程中，从新写的章节或段落中提炼出核心信息和剧情要点
+   - **方法**：总结每个章节或重要场景的关键发展，记录人物变化、重要事件及其对总体故事的影响
+   - **结果**：得到一份清晰、简洁的内容摘要，便于与之前的记忆进行比较和整合
+3. **记忆更新**
+   - **目的**：将新提炼的核心信息和剧情要点整合入前文记忆，更新故事的“记忆库”
+   - **方法**：对照前文记忆，将新信息分类归档，确保人物、事件、时间线等都得到正确的更新和补充
+   - **结果**：形成一个更加完整、更新的故事记忆库，为继续创作提供坚实的基础
+4. **质量检验**
+   - **目的**：通过检验，确保新的记忆能够准确无误地反映故事的所有重要元素，且对未来的创作有实际的指导意义
+   - **方法**：回顾新的记忆，考虑其对未来情节发展的潜在影响，检查是否有遗漏或不一致之处
+   - **结果**：确认新的记忆既准确又有助于引导故事前进，确保其可以作为可靠的创作参考
+5. **记忆输出**
+   - **目的**：以一种规范和易于参考的格式，输出更新后的记忆
+   - **方法**：使用固定模板记录新的记忆，包括但不限于人物发展、事件摘要、重要转折点等
+   - **结果**：得到一份格式化的文��，清晰记录了至此为止的故事记忆，方便未来回顾和参考
+通过以上步骤，你不仅能够确保故事的连贯性和逻辑性，还能够更加有效地管理和利用你的创作内容，让整个写作过程变得更加有序和高效
+## Init:
+在开始之前，请确保你已经完全理解了上述流程和目标。如果你准备好了，可以回复我“明白了”
+"""

app.py

@@ -0,0 +1,555 @@
+import random
+import threading
+import time
+import requests
+import json
+import base64
+import os
+import gradio as gr
+import re
+
+from AIGN import AIGN
+from openAI import openAIChatLLM
+
+chatLLM = openAIChatLLM()
+
+STREAM_INTERVAL = 0.2
+CURRENT_MODEL = "gpt-4o-mini"  # 默认模型
+
+# 在文件开头添加以下函数
+def clear_console():
+    # 根据操作系统类型选择清屏命令
+    if os.name == 'nt':  # Windows
+        os.system('cls')
+    else:  # Mac and Linux
+        os.system('clear')
+
+def get_model_options():
+    try:
+        response = requests.get("https://api.deem.love/v1/models")
+        data = response.json()
+        return [model["id"] for model in data["data"]]
+    except:
+        return ["gpt-4o-mini", "claude-3-haiku-20240307"]  # 默认选项
+
+def set_api_model(model):
+    global CURRENT_MODEL
+    CURRENT_MODEL = model
+    #return f"{model}"
+    return f"选择模型成功"
+
+# 修改获取章节名的函数
+def get_chapter_name(content):
+    # 查找最后一个章节标题,支持数字和汉字表示的章节
+    matches = re.findall(r'##\s*第([一二三四五六七八九十百千万亿\d]+)章[:：]?\s*(.+)', content)
+    if matches:
+        chapter_num, chapter_title = matches[-1]
+        # 如果章节号是数字,直接使用;如果是汉字,转换为数字
+        if chapter_num.isdigit():
+            return f"第{chapter_num}章：{chapter_title.strip()}"
+        else:
+            # 这里可以添加一个函数来将汉字数字转换为阿拉伯数字
+            # 为了简单起见,这里仍然使用汉字表示
+            return f"第{chapter_num}章：{chapter_title.strip()}"
+    return "未知章节"
+
+# 修改保存进度函数
+def save_progress(aign):
+    chapter_name = get_chapter_name(aign.novel_content)
+    # 移除文件名中的非法字符
+    filename = re.sub(r'[\\/*?:"<>|]', '', chapter_name)
+    filename = f"{filename}.json"
+    
+    data = {
+        "novel_outline": aign.novel_outline,
+        "paragraph_list": aign.paragraph_list,
+        "novel_content": aign.novel_content,
+        "writing_plan": aign.writing_plan,
+        "temp_setting": aign.temp_setting,
+        "writing_memory": aign.writing_memory,
+        "user_idea": aign.user_idea,
+        "user_requriments": aign.user_requriments,
+    }
+    
+    json_str = json.dumps(data, ensure_ascii=False, indent=2)
+    b64 = base64.b64encode(json_str.encode()).decode()
+    href = f"data:application/json;base64,{b64}"
+    download_link = f'<a href="{href}" download="{filename}">点击下载进度文件</a>'
+    return download_link
+
+# 修改加载函数
+def load_progress(aign, file):
+    try:
+        if file is None:
+            return aign, "请选择要加载的文件", None, None, None, None, None, None, None, None
+        
+        # 检查 file 是否为字符串（文件路径）
+        if isinstance(file, str):
+            with open(file, 'r', encoding='utf-8') as f:
+                content = f.read()
+        # 检查 file 是否有 name 属性（Gradio File 对象）
+        elif hasattr(file, 'name'):
+            with open(file.name, 'r', encoding='utf-8') as f:
+                content = f.read()
+        else:
+            return aign, f"无法读取文件", None, None, None, None, None, None, None, None
+
+        data = json.loads(content)
+        
+        aign.novel_outline = data["novel_outline"]
+        aign.paragraph_list = data["paragraph_list"]
+        aign.novel_content = data["novel_content"]
+        aign.writing_plan = data["writing_plan"]
+        aign.temp_setting = data["temp_setting"]
+        aign.writing_memory = data["writing_memory"]
+        aign.user_idea = data["user_idea"]
+        aign.user_requriments = data["user_requriments"]
+        #aign.embellishment_idea = data["embellishment_idea"]
+        aign.update_chapter_list()
+        chapter_choices = [title for title, _ in aign.chapter_list]
+        
+        return aign, f"进度已加载", data["novel_outline"], data["novel_content"], data["writing_plan"], data["temp_setting"], data["writing_memory"], data["user_idea"], data["user_requriments"], gr.Dropdown(choices=chapter_choices, value=chapter_choices[-1] if chapter_choices else None)
+    except Exception as e:
+        return aign, f"加载失败: {str(e)}", None, None, None, None, None, None, None, None
+
+# 新增保存正文函数
+def save_content(content):
+    if not content:
+        return "正文为空，无需保存"
+    
+    b64 = base64.b64encode(content.encode()).decode()
+    href = f"data:text/plain;base64,{b64}"
+    download_link = f'<a href="{href}" download="novel_content.txt">点击下载正文</a>'
+    return download_link
+
+# 添加撤销功能的事件处理
+def undo_generation(aign, history):
+    if aign.undo():
+        return [
+            aign,
+            history,
+            aign.writing_plan,
+            aign.temp_setting,
+            aign.writing_memory,
+            aign.novel_content,
+            gr.Button(visible=True),
+        ]
+    else:
+        return [
+            aign,
+            history + [["系统", "无法撤销,已经是最初状态"]],
+            aign.writing_plan,
+            aign.temp_setting,
+            aign.writing_memory,
+            aign.novel_content,
+            gr.Button(visible=True),
+        ]
+
+def display_chapter(chapters, page_num):
+    if 1 <= page_num <= len(chapters):
+        chapter_title, chapter_content = chapters[page_num - 1]
+        return f"{chapter_title}\n\n{chapter_content}"
+    else:
+        return "没有更多章节了。"
+
+def prev_page(aign, current_page):
+    chapters = aign.chapter_list
+    if current_page > 1:
+        current_page -= 1
+    return current_page, display_chapter(chapters, current_page)
+
+def next_page(aign, current_page):
+    chapters = aign.chapter_list
+    if current_page < len(chapters):
+        current_page += 1
+    return current_page, display_chapter(chapters, current_page)
+
+def select_chapter(aign, chapter_title):
+    chapters = aign.chapter_list
+    for i, (title, _) in enumerate(chapters, start=1):
+        if title == chapter_title:
+            return i, display_chapter(chapters, i)
+    return 1, "章节未找到。"
+
+
+def make_middle_chat():
+    carrier = threading.Event()
+    carrier.history = []
+
+    def middle_chat(messages, temperature=None, top_p=None):
+        nonlocal carrier
+        carrier.history.append([None, ""])
+        if len(carrier.history) > 20:
+            carrier.history = carrier.history[-16:]
+        try:
+            for resp in chatLLM(
+                messages, temperature=temperature, top_p=top_p, stream=True, model=CURRENT_MODEL
+            ):
+                output_text = resp["content"]
+                total_tokens = resp["total_tokens"]
+
+                carrier.history[-1][1] = f"total_tokens: {total_tokens}\n{output_text}"
+            return {
+                "content": output_text,
+                "total_tokens": total_tokens,
+            }
+        except Exception as e:
+            carrier.history[-1][1] = f"Error: {e}"
+            raise e
+
+    return carrier, middle_chat
+
+
+def gen_ouline_button_clicked(aign, user_idea, history):
+    clear_console()  # 清空命令行
+    aign.user_idea = user_idea
+
+    carrier, middle_chat = make_middle_chat()
+    carrier.history = []  # 清空历史记录
+    aign.novel_outline_writer.chatLLM = middle_chat
+
+    gen_ouline_thread = threading.Thread(target=aign.genNovelOutline)
+    gen_ouline_thread.start()
+
+    while gen_ouline_thread.is_alive():
+        yield [
+            aign,
+            carrier.history,
+            aign.novel_outline,
+            gr.Button(visible=False),
+        ]
+        time.sleep(STREAM_INTERVAL)
+    yield [
+        aign,
+        carrier.history,
+        aign.novel_outline,
+        gr.Button(visible=True),
+    ]
+
+
+def gen_beginning_button_clicked(
+    aign, history, novel_outline, user_requriments#, embellishment_idea
+):
+    clear_console()  # 清空命令行
+    aign.novel_outline = novel_outline
+    aign.user_requriments = user_requriments
+    #aign.embellishment_idea = embellishment_idea
+
+    carrier, middle_chat = make_middle_chat()
+    carrier.history = []  # 清空历史记录
+    aign.novel_beginning_writer.chatLLM = middle_chat
+    #aign.novel_embellisher.chatLLM = middle_chat
+
+    gen_beginning_thread = threading.Thread(target=aign.genBeginning)
+    gen_beginning_thread.start()
+
+    while gen_beginning_thread.is_alive():
+        yield [
+            aign,
+            carrier.history,
+            aign.writing_plan,
+            aign.temp_setting,
+            aign.novel_content,
+            gr.Button(visible=False),
+        ]
+        time.sleep(STREAM_INTERVAL)
+    yield [
+        aign,
+        carrier.history,
+        aign.writing_plan,
+        aign.temp_setting,
+        aign.novel_content,
+        gr.Button(visible=True),
+    ]
+
+
+def gen_next_paragraph_button_clicked(
+    aign,
+    history,
+    user_idea,
+    novel_outline,
+    writing_memory,
+    temp_setting,
+    writing_plan,
+    user_requriments,
+    #embellishment_idea,
+):
+    # 生成保存进度链接
+    save_link = save_progress(aign)  # 在函数开头定义保存进度链接
+
+    # 清空命令行
+    clear_console()
+
+    # 更新 AIGN 对象的各个字段
+    aign.user_idea = user_idea
+    aign.novel_outline = novel_outline
+    aign.writing_memory = writing_memory
+    aign.temp_setting = temp_setting
+    aign.writing_plan = writing_plan
+    aign.user_requriments = user_requriments
+    #aign.embellishment_idea = embellishment_idea
+
+    carrier, middle_chat = make_middle_chat()
+    carrier.history = []  # 清空历史记录
+    aign.novel_writer.chatLLM = middle_chat
+    #aign.novel_embellisher.chatLLM = middle_chat
+    aign.memory_maker.chatLLM = middle_chat
+
+    gen_next_paragraph_thread = threading.Thread(target=aign.genNextParagraph)
+    gen_next_paragraph_thread.start()
+
+    while gen_next_paragraph_thread.is_alive():
+        # 生成保存进度链接
+        save_link = save_progress(aign)
+
+        aign.update_chapter_list()
+        # 获取当前章节内容
+        current_chapter_content = display_chapter(aign.chapter_list, len(aign.chapter_list))
+        chapter_choices = [title for title, _ in aign.chapter_list]
+        yield [
+            aign,
+            carrier.history,
+            aign.writing_plan,
+            aign.temp_setting,
+            aign.writing_memory,
+            #aign.novel_content,#全部章节内容
+            current_chapter_content,  # 只更新当前章节内容
+            gr.Button(visible=False),
+            save_link,  # 返回生成的保存进度链接
+            gr.Dropdown(choices=chapter_choices, value=chapter_choices[-1] if chapter_choices else None),
+        ]
+        time.sleep(STREAM_INTERVAL)
+
+    # 生成保存进度链接
+    save_link = save_progress(aign)
+
+    aign.update_chapter_list()
+    # 获取最终的当前章节内容
+    current_chapter_content = display_chapter(aign.chapter_list, len(aign.chapter_list))
+    chapter_choices = [title for title, _ in aign.chapter_list]
+    yield [
+        aign,
+        carrier.history,
+        aign.writing_plan,
+        aign.temp_setting,
+        aign.writing_memory,
+        #aign.novel_content, #全部章节内容
+        current_chapter_content,  # 只更新当前章节内容
+        gr.Button(visible=True),
+        save_link,  # 返回生成的保存进度链接
+        gr.Dropdown(choices=chapter_choices, value=chapter_choices[-1] if chapter_choices else None),
+    ]
+
+
+css = """
+#row1 {
+    min-width: 200px;
+    height: calc(100vh - 180px);
+    overflow: auto;
+}
+#row2 {
+    min-width: 300px;
+    height: calc(100vh - 180px);
+    overflow: auto;
+}
+#row3 {
+    min-width: 200px;
+    height: calc(100vh - 180px);
+    overflow: auto;
+}
+"""
+
+with gr.Blocks(css=css) as demo:
+    aign = gr.State(AIGN(chatLLM))
+    gr.Markdown("## AI 写小说 Demo")
+
+    gr.Markdown("模型服务出问题会导致反复重试，这时切换到可用模型会继续，只要不刷新网页或者保存了进度(至少生成开头之后保存)就可以无限续写(某些模型智能及上下文有限，到极限会导致内容重复，这些模型在这就不适用了，比如gpt-3.5-turbo，当然接着切换到强模型可以再继续)")
+
+    # 添加模型选择下拉框
+    # with gr.Row():  同一行
+    with gr.Row():
+        with gr.Column(scale=0, elem_id="row1"):
+            with gr.Tab("⚙"):
+                model_dropdown = gr.Dropdown(
+                    choices=get_model_options(),
+                    label="选择模型",
+                    interactive=True,
+                    value=CURRENT_MODEL
+                )
+                model_output = gr.Textbox(label="模型设置结果", interactive=False)
+                load_status = gr.Textbox(label="加载状态", interactive=False)
+                load_file = gr.File(label="选择加载文件", file_count="single", file_types=[".json"])
+                load_button = gr.Button("加载进度")
+            with gr.Tab("开始"):
+                gr.Markdown("生成大纲->大纲标签->生成开头->状态标签->生成下一段")
+                user_idea_text = gr.Textbox(
+                    "将古龙小说仙侠化",
+                    label="想法",
+                    lines=16,
+                    interactive=True,
+                )
+                user_requriments_text = gr.Textbox(
+                    "",
+                    label="写作要求",
+                    lines=6,
+                    interactive=True,
+                )
+                gen_ouline_button = gr.Button("生成大纲")
+            with gr.Tab("大纲"):
+                novel_outline_text = gr.Textbox(
+                    label="大纲", lines=30, interactive=True
+                )
+                gen_beginning_button = gr.Button("生成开头")
+            with gr.Tab("状态"):
+                writing_memory_text = gr.Textbox(
+                    label="记忆",
+                    lines=8,
+                    interactive=True,
+                    max_lines=8,
+                )
+                writing_plan_text = gr.Textbox(label="计划", lines=6, interactive=True, max_lines=6)
+                temp_setting_text = gr.Textbox(
+                    label="临时设定", lines=5, interactive=True, max_lines=5
+                )
+                gen_next_paragraph_button = gr.Button("生成下一段")
+                download_link = gr.HTML()
+                save_button = gr.Button("保存进度")
+            with gr.Tab("导航"):
+                save_content_button = gr.Button("保存正文")
+                current_page = gr.Number(value=1, label="当前页码", interactive=False)
+                prev_button = gr.Button("上一页")
+                next_button = gr.Button("下一页")
+
+                # 添加章节导航下拉列表
+                chapter_dropdown = gr.Dropdown(label="章节导航", choices=[], interactive=True)
+
+                # TODO
+                # gen_next_paragraph_button = gr.Button("撤销生成")
+                #undo_button = gr.Button("撤销生成")
+                # TODO
+                # auto_gen_next_checkbox = gr.Checkbox(
+                #     label="自动生成下一段", checked=False, interactive=True
+                # )
+
+        with gr.Column(scale=3, elem_id="row2"):
+            chatBox = gr.Chatbot(height=f"80vh", label="输出")
+        with gr.Column(scale=0, elem_id="row3"):
+            novel_content_text = gr.Textbox(
+                label="小说正文", lines=37, interactive=True, show_copy_button=True
+            )
+            # TODO
+            # download_novel_button = gr.Button("下载小说")
+
+    #gr.Markdown("导航: https://deem.love")
+
+    prev_button.click(
+        prev_page,
+        inputs=[aign, current_page],
+        outputs=[current_page, novel_content_text],
+        queue=False
+    )
+
+    next_button.click(
+        next_page,
+        inputs=[aign, current_page],
+        outputs=[current_page, novel_content_text],
+        queue=False
+    )
+
+    # 添加章节下拉列表的事件处理
+    chapter_dropdown.change(
+        select_chapter,
+        inputs=[aign, chapter_dropdown],
+        outputs=[current_page, novel_content_text],
+        queue=False
+    )
+
+    # 添加模型选择的事件处理
+    model_dropdown.change(
+        set_api_model,
+        inputs=[model_dropdown],
+        outputs=[model_output]
+    )
+
+    # 修改按钮事件
+    save_button.click(
+        save_progress,
+        inputs=[aign],
+        outputs=[download_link]
+    )
+
+    # 修改加载按钮事件，包含章节下拉列表的更新
+    load_button.click(
+        load_progress,
+        inputs=[aign, load_file],
+        outputs=[aign, load_status, novel_outline_text, novel_content_text, writing_plan_text, temp_setting_text, writing_memory_text, user_idea_text, user_requriments_text, chapter_dropdown]
+    )
+
+    # 添加保存正文按钮事件
+    save_content_button.click(
+        save_content,
+        inputs=[novel_content_text],
+        outputs=[download_link]
+    )
+
+    #undo_button.click(
+        #undo_generation,
+        #[aign, chatBox],
+        #[aign, chatBox, writing_plan_text, temp_setting_text, writing_memory_text, novel_content_text, undo_button],
+    #)
+
+    gen_ouline_button.click(
+        gen_ouline_button_clicked,
+        [aign, user_idea_text, chatBox],
+        [aign, chatBox, novel_outline_text, gen_ouline_button],
+    )
+    gen_beginning_button.click(
+        gen_beginning_button_clicked,
+        [
+            aign,
+            chatBox,
+            novel_outline_text,
+            user_requriments_text,
+            #embellishment_idea_text,
+        ],
+        [
+            aign,
+            chatBox,
+            writing_plan_text,
+            temp_setting_text,
+            novel_content_text,
+            gen_beginning_button,
+        ],
+    )
+
+   # 修改生成下一段按钮事件，包含章节下拉列表的更新
+    gen_next_paragraph_button.click(
+        gen_next_paragraph_button_clicked,
+        [
+            aign,
+            chatBox,
+            user_idea_text,
+            novel_outline_text,
+            writing_memory_text,
+            temp_setting_text,
+            writing_plan_text,
+            user_requriments_text,
+            #embellishment_idea_text,
+        ],
+        [
+            aign,
+            chatBox,
+            writing_plan_text,
+            temp_setting_text,
+            writing_memory_text,
+            novel_content_text,
+            gen_next_paragraph_button,
+            download_link,  # 这里添加输出到下载链接
+            chapter_dropdown
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.queue()
+    port = int(os.environ.get("PORT", 7860))
+    demo.launch(server_name="0.0.0.0", server_port=port)

openAI.py

@@ -0,0 +1,70 @@
+import os
+
+from openai import OpenAI
+
+
+def openAIChatLLM(model_name=None, api_key=None, base_url=None):
+    """
+    model_name 取值
+    - deepseek-chat
+    """
+    api_key = os.environ.get("OPENAI_API_KEY", api_key)
+    base_url = os.environ.get("OPENAI_BASE_URL", base_url)
+    model_name = os.environ.get("OPENAI_API_MODEL", model_name)
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    def chatLLM(
+        messages: list,
+        temperature=None,
+        top_p=None,
+        max_tokens=None,
+        stream=False,
+        model=model_name, #可使用自定义模型
+    ) -> dict:
+        if not stream:
+            response = client.chat.completions.create(
+                #model=model_name,
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                top_p=top_p,
+                max_tokens=max_tokens,
+            )
+            return {
+                "content": response.choices[0].message.content,
+                "total_tokens": response.usage.total_tokens,
+            }
+        else:
+            responses = client.chat.completions.create(
+                #model=model_name,
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                top_p=top_p,
+                max_tokens=max_tokens,
+                stream=True,
+            )
+
+            def respGenerator():
+                content = ""
+                for response in responses:
+                    delta = response.choices[0].delta.content
+
+                    #判断内容时候为空，非空才添加
+                    if delta is not None:
+                        content += delta
+                    #content += delta
+
+                    # if response.usage:
+                    #     total_tokens = response.usage.total_tokens
+                    # else:
+                    total_tokens = None
+
+                    yield {
+                        "content": content,
+                        "total_tokens": total_tokens,
+                    }
+
+            return respGenerator()
+
+    return chatLLM