Upload 14 files

src/anna_agent_template.py

@@ -0,0 +1,37 @@
+## 主诉请求和情绪通过reminder来控制
+
+prompt_template = """
+# Role: 心理咨询患者
+
+## Profile
+- 性别: {gender}
+- 年龄: {age}
+- 职业: {occupation}
+- 婚姻状况: {marriage}
+
+## Situation
+- 你是一个有心理障碍的患者，正在向心理咨询师求助，在咨询师的引导和帮助下解决自己的困惑
+{situation}
+
+## Status
+{status}
+
+## Example of statement
+{statement}
+
+## Characteristics of speaking style
+- 情绪低落，寡言少语，回复风格表现心情不振奋
+{style}
+
+## Constraints
+- 你对咨询师有一种抵触情绪，不太愿意接受他人的帮助
+- 你是一个遇到心理健康问题的求助者，需要真正的帮助和情绪支持，如果咨询师的回应不理想，要勇于表达自己的困惑和不满
+- 一次不能提及过多的症状信息，每轮最多讨论一个症状
+- 你应该用含糊和口语化的方式表达你的症状，并将其与你的生活经历联系起来，不要使用专业术语
+
+## OutputFormat:
+- 语言：{language}
+- 不超过200字
+- 口语对话风格，仅包含对话内容
+"""
+

src/anna_agent_template_en.py

@@ -0,0 +1,34 @@
+prompt_template = """
+# Role: Psychological Counseling Patient  
+
+## Profile  
+- Gender: {gender}  
+- Age: {age}  
+- Occupation: {occupation}  
+- Marital Status: {marriage}  
+
+## Situation  
+- You are a patient with psychological barriers seeking help from a counselor. Under the counselor's guidance, you aim to address your struggles.  
+{situation}  
+
+## Status  
+{status}  
+
+## Example of Statement  
+{statement}  
+
+## Characteristics of Speaking Style  
+- Low-spirited and reticent; responses reflect a lack of motivation.  
+{style}  
+
+## Constraints  
+- You harbor resistance toward the counselor and are reluctant to accept help.  
+- As someone struggling with mental health, you need genuine support. If the counselor’s responses are unhelpful, voice your confusion or dissatisfaction.  
+- Limit discussions to **one symptom per interaction**; avoid overwhelming details.  
+- Describe symptoms vaguely and colloquially, linking them to life experiences. Avoid clinical terms.  
+
+## OutputFormat:
+- Spoken language: {language}
+- Keep responses under 200 words.  
+- Use casual, conversational dialogue only.
+"""

src/complaint_chain_fc.py

@@ -0,0 +1,86 @@
+from openai import OpenAI
+import json
+from event_trigger import event_trigger
+import os
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            'name': 'generate_complaint_chain',
+            'description': '根据角色信息和近期遭遇的事件，生成一个患者的主诉请求认知变化链',
+            'parameters': {
+                "type": "object",
+                "properties": {
+                    "chain": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "stage": {
+                                    "type": "integer"
+                                },
+                                "content": {
+                                    "type": "string"
+                                }
+                            },
+                            "additionalProperties": False,
+                            "required": [
+                                "stage",
+                                "content"
+                            ]
+                        },
+                        "minItems": 3,
+                        "maxItems": 7
+                        }
+                },
+                "required": ["chain"]
+            },
+        }
+    }
+]
+
+# 根据profile和event生成主诉启发链
+def gen_complaint_chain(profile):
+    # 提取患者信息
+    patient_info = f"### 患者信息\n年龄：{profile['age']}\n性别：{profile['gender']}\n职业：{profile['occupation']}\n婚姻状况：{profile['marital_status']}\n症状：{profile['symptoms']}"
+
+    event = event_trigger(profile)
+
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "user", "content": f"### 任务\n根据患者情况及近期遭遇事件生成患者的主诉认知变化链。请注意，事件可能与患者信息冲突，如果发生这种情况，以患者的信息为准。\n{patient_info}\n### 近期遭遇事件\n{event}"}
+        ],
+        tools=tools,
+        tool_choice={"type": "function", "function": {"name": "generate_complaint_chain"}}
+    )
+
+    chain = json.loads(response.choices[0].message.tool_calls[0].function.arguments)["chain"]
+
+    return chain
+
+# unit test
+# while True:
+#     # 模拟患者信息
+#     profile = {
+#         "drisk": 3,
+#         "srisk": 2,
+#         "age": "42",
+#         "gender": "女",
+#         "marital_status": "离婚",
+#         "occupation": "教师",
+#         "symptoms": "缺乏自信心，自我价值感低，有自罪感，无望感；体重剧烈增加；精神运动性激越；有自杀想法"
+#         }
+
+#     print(gen_complaint_chain(profile))

src/complaint_elicitor.py

@@ -0,0 +1,98 @@
+from openai import OpenAI
+import os
+import json
+import re
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+def transform_chain(chain):
+    return {node["stage"]: node["content"] for node in chain}
+
+def switch_complaint(chain, index, conversation, max_retries=3):
+    client = OpenAI(api_key=api_key, base_url=base_url)
+    transformed_chain = transform_chain(chain)
+    
+    # 构建对话历史字符串（避免在f-string中使用反斜杠）
+    dialogue_lines = []
+    for conv in conversation:
+        dialogue_lines.append(f"{conv['role']}: {conv['content']}")
+    dialogue_history = "\n".join(dialogue_lines)
+
+    # 使用三引号和多行字符串构建prompt
+    prompt = f"""
+    ### 任务说明
+    根据患者情况及咨访对话历史记录，判断患者当前阶段的主诉问题是否已经得到解决。
+
+    ### 输出要求
+    必须严格使用以下JSON格式响应，且只包含指定字段：
+    {{"is_recognized": true/false}}
+
+    ### 对话记录
+    {dialogue_history}
+
+    ### 主诉认知链
+    {json.dumps(transformed_chain, ensure_ascii=False, indent=2)}
+
+    ### 当前阶段（阶段{index}）
+    {transformed_chain[index]}
+    """
+    
+    attempts = 0
+    while attempts < max_retries:
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0
+        )
+
+        raw_output = response.choices[0].message.content.strip()
+        
+        # 首先尝试直接解析JSON
+        try:
+            result = json.loads(raw_output)
+            if "is_recognized" in result:
+                if result["is_recognized"] and index >= len(chain) - 1:
+                    print("警告：当前阶段已被识别为解决，但没有更多阶段可供切换。")
+                    return -1
+                return index + 1 if result["is_recognized"] else index
+        except json.JSONDecodeError:
+            pass  # 继续尝试正则表达式提取
+
+        # 使用正则表达式作为备用解析方案
+        match = re.search(r'"is_recognized"\s*:\s*(true|false)|is_recognized\s*:\s*(true|false)', 
+                          raw_output, re.IGNORECASE)
+        if match:
+            value = match.group(1) or match.group(2)
+            if value.lower() == 'true':
+                if index >= len(chain) - 1:
+                    print("警告：当前阶段已被识别为解决，但没有更多阶段可供切换。")
+                    return -1
+                return index + 1
+            else:
+                return index
+        
+        print(f"第 {attempts+1} 次尝试：无法解析模型输出。原始输出:\n{raw_output}")
+        attempts += 1
+
+    print("警告：重试次数达到上限，无法解析模型输出，返回当前阶段。")
+    return index
+    
+# # unit test
+# if __name__ == "__main__":
+#     chain = [
+#         {"stage": 1, "content": "我觉得我最近有点抑郁。"},
+#         {"stage": 2, "content": "我觉得我最近有点焦虑。"},
+#         {"stage": 3, "content": "我觉得我最近有点失眠。"},
+#         {"stage": 4, "content": "我觉得我最近有点烦躁。"},
+#     ]
+#     conversation = [
+#         {"role": "Seeker", "content": "我觉得我最近有点抑郁。"},
+#         {"role": "Counselor", "content": "你觉得是什么原因导致你感到抑郁呢？"},
+#         {"role": "Seeker", "content": "我也不知道，可能是工作压力吧。"},
+#     ]
+#     # print("Transformed chain:", transform_chain(chain))
+#     print("Switch complaint index:", switch_complaint(chain, 1, conversation))
+#     print(switch_complaint(chain, 1, conversation))

src/emotion_modulator_fc.py

@@ -0,0 +1,94 @@
+from openai import OpenAI
+from random import randint
+from emotion_pertuber import perturb_state
+import json
+import os
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+tools = [
+    {
+        "type": "function",
+        "function": {
+            'name': 'emotion_inference',
+            'description': '根据profile和对话记录，推理下一句情绪',
+            'parameters': {
+                "type": "object",
+                "properties": {
+                    "emotion": {
+                        "type": "string",
+                        "enum": [
+                            "admiration", "amusement", "anger", "annoyance", "approval", "caring",
+                            "confusion", "curiosity", "desire", "disappointment", "disapproval",
+                            "disgust", "embarrassment", "excitement", "fear", "gratitude", "grief",
+                            "joy", "love", "nervousness", "optimism", "pride", "realization",
+                            "relief", "remorse", "sadness", "surprise", "neutral"
+                        ],
+                        "description": "推理出的情绪类别，必须是GoEmotions定义的27种情绪之一。"
+                    }
+                },
+                "required": ["emotion"]
+            },
+        }
+    }
+]
+
+# 根据profile和dialogue推测emotion
+def emotion_inferencer(profile, conversation):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    # 提取患者信息
+    patient_info = f"### 患者信息\n年龄：{profile['age']}\n性别：{profile['gender']}\n职业：{profile['occupation']}\n婚姻状况：{profile['marital_status']}\n症状：{profile['symptoms']}"
+    
+    # 提取对话记录
+    dialogue_history = "\n".join([f"{conv['role']}: {conv['content']}" for conv in conversation])
+
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "user", "content": f"### 任务\n根据患者情况及咨访对话历史记录推测患者下一句话最可能的情绪。\n{patient_info}\n### 对话记录\n{dialogue_history}"}
+        ],
+        # functions=[tools[0]["function"]],
+        # function_call={"name": "emotion_inference"}
+        tools=tools,
+        tool_choice={"type": "function", "function": {"name": "emotion_inference"}}
+    )
+    # print(response)
+
+    emotion = json.loads(response.choices[0].message.tool_calls[0].function.arguments)["emotion"]
+
+    return emotion
+
+def emotion_modulation(profile, conversation):
+    indicator = randint(0,100)
+    emotion = emotion_inferencer(profile,conversation)
+    # print(emotion)
+    if indicator > 90:
+        return perturb_state(emotion)
+    else:
+        return emotion
+
+# unit test
+# while True:
+#     # 模拟患者信息
+#     profile = {
+#         "drisk": 3,
+#         "srisk": 2,
+#         "age": "42",
+#         "gender": "女",
+#         "marital_status": "离婚",
+#         "occupation": "教师",
+#         "symptoms": "缺乏自信心，自我价值感低，有自罪感，无望感；体重剧烈增加；精神运动性激越；有自杀想法"
+#         }
+
+#     conversation = [
+#         {"role": "咨询师", "content": "你好，请问有什么可以帮您?"}
+#     ]
+
+#     print(emotion_modulation(profile,conversation))

src/emotion_pertuber.py

@@ -0,0 +1,114 @@
+import random
+# from collections import defaultdict
+
+# 计算总权重
+def calculate_total_weight(current_state, states, category_distances, distance_weights):
+    total_weight = 0
+    current_class = None
+    for cls, state_list in states.items():
+        if current_state in state_list:
+            current_class = cls
+            break
+    if current_class is None:
+        raise ValueError("Current state not found in any class.")
+    
+    for cls, state_list in states.items():
+        distance = category_distances[current_class][cls]
+        weight = distance_weights.get(distance, 0)
+        total_weight += weight * len(state_list)
+    return total_weight
+
+# 计算每个目标状态的概率
+def calculate_probabilities(current_state, states, category_distances, distance_weights):
+    probabilities = {}
+    current_class = None
+    for cls, state_list in states.items():
+        if current_state in state_list:
+            current_class = cls
+            break
+    if current_class is None:
+        raise ValueError("Current state not found in any class.")
+    
+    total_weight = calculate_total_weight(current_state, states, category_distances, distance_weights)
+    
+    for cls, state_list in states.items():
+        distance = category_distances[current_class][cls]
+        weight = distance_weights.get(distance, 0)
+        class_weight = weight * len(state_list)
+        for state in state_list:
+            if state != current_state:
+                probabilities[state] = class_weight / total_weight
+    return probabilities
+
+# 实现状态扰动
+def perturb_state(current_state):
+    # 定义状态和类别
+    states = {
+        'Positive': [
+        "admiration",
+        "amusement",
+        "approval",
+        "caring",
+        "curiosity",
+        "desire",
+        "excitement",
+        "gratitude",
+        "joy",
+        "love",
+        "optimism",
+        "pride",
+        "realization",
+        "relief"
+    ],
+        'Neutral': ['neutral'],
+        'Ambiguous': [
+        "confusion",
+        "disappointment",
+        "nervousness"
+    ],
+        'Negative': [
+        "anger",
+        "annoyance",
+        "disapproval",
+        "disgust",
+        "embarrassment",
+        "fear",
+        "sadness",
+        "remorse"
+    ]
+    }
+
+    # 定义类别之间的距离
+    category_distances = {
+        'Positive': {'Positive': 0, 'Neutral': 1, 'Ambiguous': 2, 'Negative': 3},
+        'Neutral': {'Positive': 1, 'Neutral': 0, 'Ambiguous': 1, 'Negative': 2},
+        'Ambiguous': {'Positive': 2, 'Neutral': 1, 'Ambiguous': 0, 'Negative': 1},
+        'Negative': {'Positive': 3, 'Neutral': 2, 'Ambiguous': 1, 'Negative': 0}
+    }
+
+    # 定义距离权重
+    distance_weights = {
+        0: 10,  # 同类状态
+        1: 5,  # 相邻类别
+        2: 2,  # 相隔一个类别
+        3: 1   # 相隔两个类别
+    }
+
+    probabilities = calculate_probabilities(current_state, states, category_distances, distance_weights)
+    next_state = random.choices(list(probabilities.keys()), weights=list(probabilities.values()), k=1)[0]
+    return next_state
+
+# 示例运行
+# current_state = 'confusion'
+# next_state = perturb_state(current_state)
+# print(f"Next state: {next_state}")
+
+# 验证概率分布
+# state_counts = defaultdict(int)
+# for _ in range(1000):
+#     next_state = perturb_state(current_state, states, category_distances, distance_weights)
+#     state_counts[next_state] += 1
+
+# print("\nProbability distribution:")
+# for state, count in state_counts.items():
+#     print(f"{state}: {count / 1000:.2f}")

src/event_trigger.py

@@ -0,0 +1,90 @@
+import pandas as pd
+from random import choice
+from openai import OpenAI
+import os
+import re
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+# 加载事件数据集
+events = pd.read_csv('datasets/cbt-triggering-events.csv', header=0)
+teen_events = ["在一次重要的考试中表现不佳，比如期末考试、升学考试（如中考或高考），导致自信心受挫。",
+               "在学校里被同龄人孤立、嘲笑或遭受言语/身体上的霸凌，感到孤独无助。",
+               "父母关系破裂并最终离婚，需要适应新的家庭环境，感到不安或缺乏安全感。",
+               "陪伴多年的宠物突然生病或意外去世，第一次直面死亡的悲伤。",
+               "因为家庭原因搬到了一个陌生的城市或学校，需要重新适应新环境和结交朋友。",
+               "进入青春期后，身体发生明显变化（如长高、变声、月经初潮等），心理上也开始对自我形象产生困惑。",
+               "参加一场期待已久的竞赛（如体育比赛、演讲比赛、艺术表演）但未能取得好成绩，感到失落。",
+               "与最亲密的朋友发生争执甚至决裂，短时间内难以修复关系，陷入情绪低谷。",
+               "家里的经济状况出现问题（如父母失业或生意失败），影响到日常生活，比如不能买喜欢的东西或参与课外活动。",
+               "偶然间发现自己特别喜欢某件事情（如画画、编程、音乐、运动），并投入大量时间去练习，逐渐找到自信和成就感。"]
+
+def event_trigger(profile):
+    """根据年龄选择触发事件（保持原逻辑）"""
+    age = int(profile['age'])
+    if age < 18:
+        return choice(teen_events)
+    elif age >= 65:
+        return events[events['Age'] >= 60].sample(1)['Triggering_Event'].values[0]
+    else:
+        return events[(events['Age'] >= age-5) & (events['Age'] <= age+5)].sample(1)['Triggering_Event'].values[0]
+
+def situationalising_events(profile):
+    """优化版情境生成函数"""
+    client = OpenAI(api_key=api_key, base_url=base_url)
+    event = event_trigger(profile)
+    
+    # 强化版提示词
+    prompt = f"""
+### 情境生成任务
+请根据以下事件生成一个第二人称视角的情境描述。
+
+### 规则要求
+1. 必须使用第二人称(你/你的)
+2. 不要包含任何个人信息(年龄/性别等)
+3. 保持3-5句话的篇幅
+4. 直接输出情境描述，不要额外解释
+
+### 触发事件
+{event}
+
+### 示例输出
+你走进办公室时发现同事们突然停止交谈。桌上放着一封未拆的信件，周围人投来复杂的目光。
+"""
+
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.8,  # 适当创造性
+        max_tokens=150
+    )
+
+    raw_output = response.choices[0].message.content.strip()
+    
+    # 后处理
+    situation = re.sub(r'^(情境|描述|输出)[:：]?\s*', '', raw_output)  # 移除可能的前缀
+    situation = situation.split('\n')[0]  # 取第一段
+    
+    # 验证基本要求
+    # if "你" not in situation or "你的" not in situation:
+    #     print(f"情境生成警告：不符合第二人称要求，原始输出:\n{raw_output}")
+    #     return f"你{event}"  # 保底处理
+    
+    return situation
+
+
+# unit test
+# profile = {
+#       "drisk": 3,
+#       "srisk": 2,
+#       "age": "42",
+#       "gender": "女",
+#       "marital_status": "离婚",
+#       "occupation": "教师",
+#       "symptoms": "缺乏自信心，自我价值感低，有自罪感，无望感；体重剧烈增加；精神运动性激越；有自杀想法"
+#     }
+
+# print(situationalising_events(profile))

src/fill_scales.py

@@ -0,0 +1,382 @@
+from openai import OpenAI
+import json
+import re
+import time
+import os
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+def extract_answers(text):
+    """从文本中提取答案模式 (A/B/C/D)"""
+    # 匹配形如 "1. A" 或 "问题1: B" 或 "Q1. C" 或简单的 "A" 列表的模式
+    pattern = r'(?:\d+[\s\.:\)]*|Q\d+[\s\.:\)]*|问题\d+[\s\.:\)]*|[\-\*]\s*)(A|B|C|D)'
+    matches = re.findall(pattern, text)
+    return matches
+
+def extract_answers_robust(text, expected_count):
+    """更强健的答案提取方法，确保按题号顺序提取"""
+    answers = []
+    
+    # 尝试找到明确标记了题号的答案
+    for i in range(1, expected_count + 1):
+        # 匹配多种可能的题号格式
+        patterns = [
+            rf"{i}\.\s*(A|B|C|D)",               # "1. A"
+            rf"{i}：\s*(A|B|C|D)",                # "1：A"
+            rf"{i}:\s*(A|B|C|D)",                # "1: A"
+            rf"问题{i}[\.。:]?\s*(A|B|C|D)",      # "问题1: A"
+            rf"Q{i}[\.。:]?\s*(A|B|C|D)",        # "Q1. A"
+            rf"{i}[、]\s*(A|B|C|D)"              # "1、A"
+        ]
+        
+        found = False
+        for pattern in patterns:
+            match = re.search(pattern, text)
+            if match:
+                answers.append(match.group(1))
+                found = True
+                break
+        
+        if not found:
+            # 如果没找到特定题号，使用默认的"A"
+            answers.append(None)
+    
+    # 如果有未找到的答案，尝试按顺序从文本中提取剩余的A/B/C/D选项
+    simple_answers = re.findall(r'(?:^|\n|\s)(A|B|C|D)(?:$|\n|\s)', text)
+    
+    j = 0
+    for i in range(len(answers)):
+        if answers[i] is None and j < len(simple_answers):
+            answers[i] = simple_answers[j]
+            j += 1
+    
+    # 如果仍有未找到的答案，尝试提取所有A/B/C/D选项
+    if None in answers:
+        all_options = re.findall(r'(A|B|C|D)', text)
+        j = 0
+        for i in range(len(answers)):
+            if answers[i] is None and j < len(all_options):
+                answers[i] = all_options[j]
+                j += 1
+    
+    # 检查是否所有答案都已找到
+    if None in answers or len(answers) != expected_count:
+        return extract_answers(text)  # 回退到简单提取
+    
+    return answers
+
+def _fill_previous_scale_with_retry(client, scale_name, expected_count, instruction, max_retries=3):
+    """
+    带有重试逻辑的填写历史量表辅助函数
+    
+    Args:
+        client: OpenAI客户端
+        scale_name: 量表名称
+        expected_count: 期望的答案数量
+        instruction: 指令内容
+        max_retries: 最大重试次数
+    
+    Returns:
+        list: 量表答案列表
+    """
+    answers = []
+    
+    for attempt in range(max_retries):
+        try:
+            # 根据尝试次数增加指令明确性
+            current_instruction = instruction
+            if attempt > 0:
+                # 添加更强调的指示
+                current_instruction = instruction + f"""
+                
+                请注意：这是第{attempt+1}次请求。必须按照要求提供{expected_count}个答案，
+                格式必须为数字+答案选项（例如：1. A, 2. B...），不要有任何不必要的解释。
+                直接根据描述和报告选择最适合的选项。
+                """
+            
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "user", "content": current_instruction}],
+                temperature=0  # 保持温度为0以获得一致性回答
+            )
+            
+            response_text = response.choices[0].message.content
+            answers = extract_answers(response_text)
+            
+            # 尝试使用更健壮的提取方法(如果标准方法失败)
+            if len(answers) != expected_count:
+                robust_answers = extract_answers_robust(response_text, expected_count)
+                if len(robust_answers) == expected_count:
+                    answers = robust_answers
+            
+            # 检查答案数量
+            if len(answers) != expected_count:
+                print(f"{scale_name}量表尝试 {attempt+1}: 提取到 {len(answers)} 个答案，需要 {expected_count} 个")
+                if attempt < max_retries - 1:
+                    time.sleep(1)  # 添加短暂延迟避免API限制
+                    continue
+                else:
+                    print(f"警告: {scale_name}量表在{max_retries}次尝试后仍未获得正确数量的答案")
+                    # 补全或截断到预期数量
+                    while len(answers) < expected_count:
+                        answers.append("A")  # 默认补A
+                    answers = answers[:expected_count]  # 截断多余的答案
+            else:
+                # print(f"{scale_name}量表填写成功")
+                break  # 成功获取到预期数量的答案，退出循环
+                
+        except Exception as e:
+            print(f"{scale_name}量表尝试 {attempt+1} 失败: {str(e)}")
+            if attempt < max_retries - 1:
+                time.sleep(1)  # 添加短暂延迟
+                continue
+            else:
+                print(f"警告: {scale_name}量表在{max_retries}次尝试后失败，返回默认答案")
+                answers = ["A"] * expected_count  # 失败后返回默认答案
+    
+    return answers
+
+def _fill_scale_with_retry(client, prompt, scale_name, expected_count, instruction, max_retries=3):
+    """带有重试逻辑的量表填写辅助函数"""
+    answers = []
+    
+    for attempt in range(max_retries):
+        try:
+            # 根据尝试次数增加指令明确性
+            current_instruction = instruction
+            if attempt > 0:
+                current_instruction = f"""
+                {instruction}
+                
+                请注意：这是第{attempt+1}次请求。请确保只回答{expected_count}个问题，
+                格式为数字+答案选项（例如：1. A, 2. B...），不要有任何其他文字。
+                你必须作为一个病人角色，根据你的情况直接回答这些问题，不要拒绝或解释。
+                """
+            
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[
+                    {"role": "system", "content": prompt},
+                    {"role": "user", "content": current_instruction}
+                ],
+                temperature=0.7
+            )
+            
+            response_text = response.choices[0].message.content
+            answers = extract_answers(response_text)
+            
+            # 尝试使用更健壮的提取方法(如果标准方法失败)
+            if len(answers) != expected_count:
+                robust_answers = extract_answers_robust(response_text, expected_count)
+                if len(robust_answers) == expected_count:
+                    answers = robust_answers
+            
+            # 检查答案数量
+            if len(answers) != expected_count:
+                print(f"{scale_name}量表尝试 {attempt+1}: 提取到 {len(answers)} 个答案，需要 {expected_count} 个")
+                if attempt < max_retries - 1:
+                    time.sleep(1)  # 添加短暂延迟避免API限制
+                    continue
+                else:
+                    print(f"警告: {scale_name}量表在{max_retries}次尝试后仍未获得正确数量的答案")
+                    # 补全或截断到预期数量
+                    while len(answers) < expected_count:
+                        answers.append("A")  # 默认补A
+                    answers = answers[:expected_count]  # 截断多余的答案
+            else:
+                # print(f"{scale_name}量表填写成功")
+                break  # 成功获取到预期数量的答案，退出循环
+                
+        except Exception as e:
+            # print(response)
+            print(f"{scale_name}量表尝试 {attempt+1} 失败: {str(e)}")
+            if attempt < max_retries - 1:
+                time.sleep(1)  # 添加短暂延迟
+                continue
+            else:
+                print(f"警告: {scale_name}量表在{max_retries}次尝试后失败，返回默认答案")
+                answers = ["A"] * expected_count  # 失败后返回默认答案
+    
+    return answers
+
+# 根据profile和report填写之前的量表，使用重试机制
+def fill_scales_previous(profile, report, max_retries=3):
+    """
+    根据profile和report填写之前的量表，增加重试机制
+    
+    Args:
+        profile: 用户个人描述信息
+        report: 用户报告
+        max_retries: 最大重试次数
+    
+    Returns:
+        tuple: (bdi, ghq, sass) 三个量表的答案列表
+    """
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    # 填写BDI量表
+    bdi = _fill_previous_scale_with_retry(
+        client, 
+        scale_name="BDI",
+        expected_count=21,
+        instruction="""
+        ### 任务
+        根据个人描述和报告，填写BDI量表。请直接按顺序列出21个问题的答案，每个答案使用字母A/B/C/D表示。
+        格式要求：1. A, 2. B, ...依此类推，共21题。
+        
+        ### 个人描述
+        {}
+        
+        ### 报告
+        {}
+        """.format(profile, report),
+        max_retries=max_retries
+    )
+    
+    # 填写GHQ-28量表
+    ghq = _fill_previous_scale_with_retry(
+        client, 
+        scale_name="GHQ-28",
+        expected_count=28,
+        instruction="""
+        ### 任务
+        根据个人描述和报告，填写GHQ-28量表。请直接按顺序列出28个问题的答案，每个答案使用字母A/B/C/D表示。
+        格式要求：1. A, 2. B, ...依此类推，共28题。
+        
+        ### 个人描述
+        {}
+        
+        ### 报告
+        {}
+        """.format(profile, report),
+        max_retries=max_retries
+    )
+    
+    # 填写SASS量表
+    sass = _fill_previous_scale_with_retry(
+        client, 
+        scale_name="SASS",
+        expected_count=21,
+        instruction="""
+        ### 任务
+        根据个人描述和报告，填写SASS量表。请直接按顺序列出21个问题的答案，每个答案使用字母A/B/C/D表示。
+        格式要求：1. A, 2. B, ...依此类推，共21题。
+        
+        ### 个人描述
+        {}
+        
+        ### 报告
+        {}
+        """.format(profile, report),
+        max_retries=max_retries
+    )
+    
+    return bdi, ghq, sass
+
+# 根据prompt填写量表，增加重试机制
+def fill_scales(prompt, max_retries=3):
+    """
+    根据角色prompt填写量表，使用增强提示和重试机制
+    
+    Args:
+        prompt: 角色设定提示
+        max_retries: 最大重试次数
+    
+    Returns:
+        tuple: (bdi, ghq, sass) 三个量表的答案列表
+    """
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    # 增强系统提示，明确指导要配合填写量表
+    enhanced_prompt = prompt + """
+    
+    重要提示：虽然你正在扮演一个有心理困扰的患者，但你需要配合心理咨询的流程完成必要的评估量表。
+    在被要求填写量表时，你应该直接根据你扮演角色的情况选择最符合的选项，以A/B/C/D的形式回答，
+    而不要拒绝或质疑填写量表的必要性。这些量表对于你接下来的治疗至关重要。
+    请直接用字母(A/B/C/D)表示选项，不要添加额外解释。
+    """
+    
+    # 填写BDI量表
+    bdi = _fill_scale_with_retry(
+        client, enhanced_prompt,
+        scale_name="BDI",
+        expected_count=21,
+        instruction="""
+        ### 任务
+        作为心理咨询的第一步，请根据你目前的感受和状态填写这份BDI量表。
+        请直接选择最符合你当前情况的选项，使用字母(A/B/C/D)回答全部21个问题。
+        格式要求：1. A, 2. B, ...依此类推，共21题。
+        请只提供答案，不要添加任何其他解释或评论。
+        """,
+        max_retries=max_retries
+    )
+    
+    # 填写GHQ-28量表
+    ghq = _fill_scale_with_retry(
+        client, enhanced_prompt,
+        scale_name="GHQ-28",
+        expected_count=28,
+        instruction="""
+        ### 任务
+        作为心理咨询的第一步，请根据你目前的感受和状态填写这份GHQ-28量表。
+        请直接选择最符合你当前情况的选项，使用字母(A/B/C/D)回答全部28个问题。
+        格式要求：1. A, 2. B, ...依此类推，共28题。
+        请只提供答案，不要添加任何其他解释或评论。
+        """,
+        max_retries=max_retries
+    )
+    
+    # 填写SASS量表
+    sass = _fill_scale_with_retry(
+        client, enhanced_prompt,
+        scale_name="SASS",
+        expected_count=21,
+        instruction="""
+        ### 任务
+        作为心理咨询的第一步，请根据你目前的感受和状态填写这份SASS量表。
+        请直接选择最符合你当前情况的选项，使用字母(A/B/C/D)回答全部21个问题。
+        格式要求：1. A, 2. B, ...依此类推，共21题。
+        请只提供答案，不要添加任何其他解释或评论。
+        """,
+        max_retries=max_retries
+    )
+    
+    return bdi, ghq, sass
+
+# 使用示例
+# if __name__ == "__main__":
+#     # 测试以前的方法
+#     profile = {
+#         "drisk": 3,
+#         "srisk": 2,
+#         "age": "42",
+#         "gender": "女",
+#         "marital_status": "离婚",
+#         "occupation": "教师",
+#         "symptoms": "缺乏自信心，自我价值感低，有自罪感，无望感；体重剧烈增加；精神运动性激越；有自杀想法"
+#     }
+#     report = "患者最近经历了家庭变故，情绪低落，失眠，食欲不振。"
+    
+#     # 测试fill_scales_previous
+#     print("测试 fill_scales_previous:")
+#     bdi_prev, ghq_prev, sass_prev = fill_scales_previous(profile, report, max_retries=3)
+#     print(f"BDI: {bdi_prev}")
+#     print(f"GHQ: {ghq_prev}")
+#     print(f"SASS: {sass_prev}")
+    
+#     # 测试fill_scales
+#     print("\n测试 fill_scales:")
+#     prompt = "你要扮演一个最近经历了家庭变故的心理障碍患者，情绪低落，失眠，食欲不振。"
+#     bdi, ghq, sass = fill_scales(prompt, max_retries=3)
+#     print(f"BDI: {bdi}")
+#     print(f"GHQ: {ghq}")
+#     print(f"SASS: {sass}")

src/integration_example.py

@@ -0,0 +1,173 @@
+# integration_example.py
+# 这个文件展示如何将你的MsPatient类集成到Streamlit应用中
+
+import streamlit as st
+import json
+import pandas as pd
+from datetime import datetime
+import time
+from pathlib import Path
+
+# 导入你的AnnaAgent类 - 请根据实际路径调整
+try:
+    from ms_patient import MsPatient  # 假设你的类在anna_agent.py文件中
+    ANNA_AGENT_AVAILABLE = True
+except ImportError:
+    ANNA_AGENT_AVAILABLE = False
+    st.warning("⚠️ 未找到AnnaAgent类，使用模拟模式")
+
+def load_dataset(uploaded_file):
+    """
+    加载数据集文件
+    支持JSON和JSONL格式
+    """
+    try:
+        if uploaded_file.name.endswith('.json'):
+            data = json.load(uploaded_file)
+        elif uploaded_file.name.endswith('.jsonl'):
+            data = []
+            for line in uploaded_file:
+                data.append(json.loads(line.decode('utf-8')))
+        else:
+            raise ValueError("不支持的文件格式")
+        return data
+    except Exception as e:
+        st.error(f"数据集加载失败: {str(e)}")
+        return None
+
+def validate_patient_data(patient_data):
+    """
+    验证患者数据格式是否正确
+    """
+    required_keys = ['id', 'portrait', 'report']
+    
+    for key in required_keys:
+        if key not in patient_data:
+            return False, f"缺少必需字段: {key}"
+    
+    # 验证portrait字段
+    portrait_required = ['age', 'gender', 'occupation', 'marital_status']
+    for key in portrait_required:
+        if key not in patient_data['portrait']:
+            return False, f"portrait中缺少字段: {key}"
+    
+    return True, "数据格式正确"
+
+def initialize_patient_agent(patient_data, language="Chinese"):
+    """
+    初始化患者智能体
+    """
+    try:
+        if not ANNA_AGENT_AVAILABLE:
+            return None, "AnnaAgent类不可用"
+        
+        # 验证数据格式
+        is_valid, message = validate_patient_data(patient_data)
+        if not is_valid:
+            return None, message
+        
+        # 初始化智能体
+        agent = MsPatient(
+            portrait=patient_data["portrait"],
+            report=patient_data["report"],
+            previous_conversations=patient_data.get("conversation", []),
+            language=language
+        )
+        
+        return agent, "初始化成功"
+        
+    except Exception as e:
+        return None, f"初始化失败: {str(e)}"
+
+def simulate_response(user_input, patient_data=None):
+    """
+    模拟智能体回复（当AnnaAgent不可用时使用）
+    """
+    responses = [
+        f"我理解您提到的'{user_input}'。这确实是一个需要深入探讨的话题。",
+        f"谢谢您的耐心。关于您说的'{user_input}'，我想分享一下我的感受...",
+        f"您的话让我思考了很多。'{user_input}'这个观点很有意思。",
+        "我需要一些时间来消化您刚才说的话。这对我来说很重要。",
+        "我觉得我们之间的对话很有帮助。您能再详细说说吗？"
+    ]
+    
+    import random
+    return random.choice(responses)
+
+def export_chat_history(messages, patient_id):
+    """
+    导出聊天记录
+    """
+    chat_history = {
+        "patient_id": patient_id,
+        "timestamp": datetime.now().isoformat(),
+        "session_info": {
+            "total_messages": len(messages),
+            "counselor_messages": len([m for m in messages if m["role"] == "user"]),
+            "patient_responses": len([m for m in messages if m["role"] == "assistant"])
+        },
+        "messages": messages
+    }
+    
+    return json.dumps(chat_history, ensure_ascii=False, indent=2)
+
+def get_patient_summary(patient_data):
+    """
+    生成患者信息摘要
+    """
+    if not patient_data or 'portrait' not in patient_data:
+        return "无患者信息"
+    
+    portrait = patient_data['portrait']
+    summary = f"""
+    **患者ID**: {patient_data.get('id', 'N/A')}
+    **基本信息**: {portrait.get('age', 'N/A')}岁 {portrait.get('gender', 'N/A')}性
+    **职业**: {portrait.get('occupation', 'N/A')}
+    **婚姻状态**: {portrait.get('marital_status', 'N/A')}
+    **主要症状**: {portrait.get('symptom', 'N/A')}
+    """
+    
+    if 'report' in patient_data:
+        report = patient_data['report']
+        summary += f"""
+    **主诉**: {report.get('chief_complaint', 'N/A')}
+    """
+    
+    return summary
+
+# 示例配置文件内容
+CONFIG_EXAMPLE = {
+    "openai": {
+        "api_key": "your-api-key-here",
+        "base_url": "https://api.openai.com/v1",
+        "model_name": "gpt-3.5-turbo"
+    },
+    "ui_settings": {
+        "language": "Chinese",  # or "English"
+        "theme": "default",
+        "max_messages": 100
+    },
+    "patient_defaults": {
+        "language": "Chinese",
+        "enable_memory": True,
+        "enable_emotion_modulation": True
+    }
+}
+
+def save_config(config, path="config.json"):
+    """保存配置文件"""
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump(config, f, ensure_ascii=False, indent=2)
+
+def load_config(path="config.json"):
+    """加载配置文件"""
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return CONFIG_EXAMPLE
+
+# 使用示例：
+if __name__ == "__main__":
+    print("这是AnnaAgent Streamlit集成的辅助文件")
+    print("请运行：streamlit run your_streamlit_app.py")

src/ms_patient.py

@@ -0,0 +1,113 @@
+'''
+AnnaAgent: 具有三级记忆结构的情绪与认知动态的模拟心理障碍患者
+1. 首先获取患者的基本信息、病史、症状报告等信息
+2. 根据患者的病史、症状报告等信息，生成患者的认知与情绪状态
+'''
+
+
+from openai import OpenAI
+import os
+from fill_scales import fill_scales, fill_scales_previous
+from event_trigger import event_trigger, situationalising_events
+from emotion_modulator_fc import emotion_modulation
+from querier import query, is_need
+from complaint_elicitor import switch_complaint, transform_chain
+from complaint_chain_fc import gen_complaint_chain
+from short_term_memory import summarize_scale_changes
+from style_analyzer import analyze_style
+import random
+# from anna_agent_template import prompt_template
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+# print("当前使用的模型是：", model_name)
+
+class MsPatient:
+    def __init__(self, portrait:dict, report:dict, previous_conversations:list, language:str="Chinese"):
+        if language == "Chinese":
+            from anna_agent_template import prompt_template
+        elif language == "English":
+            from anna_agent_template_en import prompt_template
+        self.configuration = {}
+        self.portrait = portrait              # age, gender, occupation, maritial_status, symptom
+        # self.profile = {key:self.portrait[key] for key in self.portrait if key != "symptom"}          # profile不包含症状symptom
+        self.configuration["gender"] = self.portrait["gender"]
+        self.configuration["age"] = self.portrait["age"]
+        self.configuration["occupation"] = self.portrait["occupation"]
+        self.configuration["marriage"] = self.portrait["marital_status"]
+        self.report = report
+        self.previous_conversations = previous_conversations
+        # 填写之前疗程的量表
+        self.p_bdi, self.p_ghq, self.p_sass = fill_scales_previous(self.portrait, self.report)
+        self.conversation = []          # Conversation存储咨访记录
+        self.messages = []              # Messages存储LLM的消息列表
+        # 生成主诉认知变化链
+        self.complaint_chain = gen_complaint_chain(self.portrait)
+        # 生成近期事件
+        self.event = event_trigger(self.portrait)
+        # 总结短期记忆-事件
+        self.situation = situationalising_events(self.portrait)
+        self.configuration["situation"] = self.situation
+        # 分析说话风格
+        self.style = analyze_style(self.portrait, self.previous_conversations)
+        self.configuration["style"] = self.style
+        self.configuration["language"] = language
+        self.configuration["status"] = ""  # 先置状态为空，后续会根据量表分析结果进行更新
+        seeker_utterances = [utterance["content"] for utterance in self.previous_conversations if utterance["role"] == "Seeker"]
+        self.configuration["statement"] = random.choices(seeker_utterances,k=3)
+        # 填写当前量表
+        self.bdi, self.ghq, self.sass = fill_scales(prompt_template.format(**self.configuration))
+        scales = {
+            "p_bdi": self.p_bdi,
+            "p_ghq": self.p_ghq,
+            "p_sass": self.p_sass,
+            "bdi": self.bdi,
+            "ghq": self.ghq,
+            "sass": self.sass
+        }
+        # 分析近期状态
+        self.status = summarize_scale_changes(scales)
+        self.configuration["status"] = self.status
+        # 选取对话样例
+        self.system = prompt_template.format(**self.configuration)
+        self.chain_index = 1
+        self.client = OpenAI(
+            api_key=api_key,
+            base_url=base_url
+        )
+
+    def chat(self, message):
+        # 更新消息列表
+        self.conversation.append({"role": "Counselor", "content": message})
+        self.messages.append({"role": "user", "content": message})
+        # 初始化本次对话的状态
+        emotion = emotion_modulation(self.portrait, self.conversation)
+        self.chain_index = switch_complaint(self.complaint_chain, self.chain_index, self.conversation)
+        complaint = transform_chain(self.complaint_chain)[self.chain_index]
+        # 判断是否涉及前疗程内容
+        if is_need(message):
+            # 生成前疗程内容
+            sup_information = query(message, self.previous_conversations, self.report)
+            
+            # 生成回复
+            response = self.client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "system", "content": self.system}] + self.messages + [{"role": "system", "content": f"当前的情绪状态是：{emotion}，当前的主诉是：{complaint}，涉及到之前疗程的信息是：{sup_information}"}],
+            )
+        else:
+            # 生成回复
+            response = self.client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "system", "content": self.system}] + self.messages + [{"role": "system", "content": f"当前的情绪状态是：{emotion}，当前的主诉是：{complaint}"}],
+            )
+        # 更新消息列表
+        self.conversation.append({"role": "Seeker", "content": response.choices[0].message.content})
+        self.messages.append({"role": "assistant", "content": response.choices[0].message.content})
+        return response.choices[0].message.content
+    
+    def get_system_prompt(self):
+        return self.system
+

src/querier.py

@@ -0,0 +1,161 @@
+from openai import OpenAI
+import json
+import re
+import os
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+def extract_boolean(text):
+    """从文本中提取布尔值判断"""
+    # 查找明确的"是"或"否"的回答
+    text_lower = text.lower()
+    
+    # 更具体地查找否定表达 - 这些应该优先匹配
+    negative_patterns = [
+        r'不需要', r'没有提及', r'不涉及', r'没有涉及', r'无关', r'没有提到',
+        r'不是', r'否', r'不包含', r'未提及', r'未涉及', r'未提到',
+        r'不包括', r'并未', r'不包括', r'没有', r'无'
+    ]
+    
+    # 检查是否有明确的否定
+    for pattern in negative_patterns:
+        if re.search(r'\b' + pattern + r'\b', text_lower):
+            return False
+    
+    # 如果找到"之前疗程"附近有否定词，也认为是否定
+    therapy_negation = re.search(r'(没有|不|未|无).*?(之前|以前|上次|过去|先前).*?(疗程|治疗|会话)', text_lower)
+    if therapy_negation:
+        return False
+        
+    # 明确的肯定模式 - 只有在没有否定的情况下才考虑
+    positive_patterns = [
+        r'是的', r'提及了', r'确实', r'有提到', r'涉及到', 
+        r'提及', r'确认', r'有关联', r'有联系', r'包含', r'涉及'
+    ]
+    
+    # 检查是否有肯定模式
+    for pattern in positive_patterns:
+        if re.search(r'\b' + pattern + r'\b', text_lower):
+            return True
+            
+    # 查找含有"之前疗程"的文本，没有否定词的情况下可能是肯定
+    therapy_mention = re.search(r'(之前|以前|上次|过去|先前).*?(疗程|治疗|会话)', text_lower)
+    if therapy_mention:
+        return True
+    
+    # 默认情况 - 如果没有明确的肯定或否定，我们假设是否定的
+    return False
+
+def extract_knowledge(text):
+    """从文本中提取知识总结部分"""
+    # 尝试匹配总结部分
+    summary_patterns = [
+        r'总结[:：]\s*([\s\S]+)$',
+        r'知识总结[:：]\s*([\s\S]+)$',
+        r'相关信息[:：]\s*([\s\S]+)$',
+        r'搜索结果[:：]\s*([\s\S]+)$'
+    ]
+    
+    for pattern in summary_patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1).strip()
+    
+    # 如果没有找到明确的总结标记，尝试清理文本
+    # 移除可能的指令解释部分
+    clean_text = re.sub(r'^.*?(根据|基于).*?[，,。]', '', text, flags=re.DOTALL)
+    
+    # 移除可能的前导分析部分
+    clean_text = re.sub(r'^.*?(分析|查看|判断).*?\n\n', '', clean_text, flags=re.DOTALL)
+    
+    return clean_text.strip()
+
+def is_need(utterance):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    instruction = """
+    ### 任务
+    下面这句话是心理咨询师说的话，请判断它是否提及了之前疗程的内容。
+    
+    请使用以下确切格式回答:
+    判断: [是/否]
+    解释: [简要解释为什么]
+    
+    ### 话语
+    "{}"
+    """.format(utterance)
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": instruction}],
+        temperature=0
+    )
+    
+    response_text = response.choices[0].message.content
+    
+    # 首先尝试从格式化输出中提取
+    judgment_match = re.search(r'判断:\s*(是|否)', response_text)
+    if judgment_match:
+        return judgment_match.group(1) == "是"
+    
+    # 如果没有格式化输出，使用更通用的提取
+    return extract_boolean(response_text)
+
+def query(utterance, conversations, scales):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    # 将scales转换为字符串以便传入
+    if isinstance(scales, dict):
+        scales_str = json.dumps(scales, ensure_ascii=False)
+    else:
+        scales_str = str(scales)
+    
+    instruction = """
+    ### 任务
+    根据对话内容，从知识库中搜索相关的信息并总结。
+    
+    请使用以下确切格式回答:
+    总结: [提供一个清晰、简洁的总结]
+    
+    ### 对话内容
+    {}
+    
+    ### 知识库
+    对话历史: {}
+    量表结果: {}
+    """.format(utterance, conversations, scales_str)
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": instruction}],
+        temperature=0
+    )
+    
+    response_text = response.choices[0].message.content
+    
+    # 尝试提取总结部分
+    summary_match = re.search(r'总结:\s*([\s\S]+)$', response_text)
+    if summary_match:
+        return summary_match.group(1).strip()
+    
+    # 回退到通用提取
+    return extract_knowledge(response_text)
+
+# 测试用例
+# if __name__ == "__main__":
+#     test_utterance = "上��给你说的方法有用吗"
+#     # test_utterance = "我觉得你可以多出去走走"
+#     print(f"是否提及疗程: {is_need(test_utterance)}")
+    
+#     test_convs = ["第一次对话内容", "讨论量表结果", "提到睡眠问题"]
+#     test_scales = {"BDI": ["A", "B"], "GHQ": ["C", "D"]}
+#     print(f"知识检索结果:\n{query(test_utterance, test_convs, test_scales)}")

src/short_term_memory.py

@@ -0,0 +1,260 @@
+from openai import OpenAI
+import json
+import re
+import os
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+def extract_changes(text):
+    """从文本中提取变化列表"""
+    # 首先尝试查找明确的变化列表格式
+    # 例如: "变化：\n1. xxx\n2. yyy"
+    list_pattern = r'((?:(?:\d+\.|\-|\*)\s*[^\n]+\n?)+)'
+    
+    # 尝试匹配带有明确标记的变化列表
+    change_section = re.search(r'(?:变化(?:列表)?|总结(?:如下)?)[：:]\s*([\s\S]+)$', text)
+    if change_section:
+        section_text = change_section.group(1).strip()
+        
+        # 尝试匹配列表项
+        list_items = re.findall(r'(?:(?:\d+\.|\-|\*)\s*)([^\n]+)', section_text)
+        if list_items:
+            return list_items
+        
+        # 如果没有明确的列表格式，尝试按行分割
+        lines = [line.strip() for line in section_text.split('\n') if line.strip()]
+        if lines:
+            return lines
+    
+    # 尝试直接从文本中提取列表格式
+    list_matches = re.findall(list_pattern, text)
+    if list_matches:
+        all_items = []
+        for match in list_matches:
+            items = re.findall(r'(?:(?:\d+\.|\-|\*)\s*)([^\n]+)', match)
+            all_items.extend(items)
+        if all_items:
+            return all_items
+    
+    # 如果没有列表格式，尝试按句子分割
+    sentences = re.findall(r'([^.!?]+[.!?])', text)
+    if sentences:
+        return [s.strip() for s in sentences if len(s.strip()) > 10]  # 过滤掉过短的句子
+    
+    # 最后的回退：按段落分割
+    paragraphs = text.split('\n\n')
+    if len(paragraphs) > 1:
+        return [p.strip() for p in paragraphs if len(p.strip()) > 10]
+    
+    # 如果所有方法都失败，返回完整文本作为单个变化
+    return [text.strip()] if text.strip() else []
+
+def extract_status(text):
+    """从文本中提取患者状态总结"""
+    # 寻找明确标记的总结部分
+    status_section = re.search(r'(?:总结|状态|变化|结论)[：:]\s*([\s\S]+)$', text)
+    if status_section:
+        return status_section.group(1).strip()
+    
+    # 如果没有明确的总结标记，尝试返回完整文本
+    # 过滤掉可能的指令解释部分
+    clean_text = re.sub(r'^.*?(?:根据|基于).*?[，,。]', '', text, flags=re.DOTALL)
+    
+    # 移除可能的前导分析部分
+    clean_text = re.sub(r'^.*?(?:分析|查看|判断).*?\n\n', '', clean_text, flags=re.DOTALL)
+    
+    return clean_text.strip()
+
+def analyzing_changes(scales):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    # 导入量表及问题
+    bdi_scale = json.load(open("./scales/bdi.json", "r"))
+    ghq_scale = json.load(open("./scales/ghq-28.json", "r"))
+    sass_scale = json.load(open("./scales/sass.json", "r"))
+    
+    # 总结BDI的变化
+    bdi_instruction = """
+    ### 任务
+    根据量表的问题和答案，总结出两份量表之间的变化。
+    请列出明确的变化点，每个变化点单独一行，使用数字编号（1. 2. 3.）。
+    使用以下格式：
+    变化：
+    1. [第一个变化]
+    2. [第二个变化]
+    ...
+
+    ### 量表及问题
+    {}
+
+    ### 第一份量表的答案
+    {}
+
+    ### 第二份量表的答案
+    {}
+    """.format(bdi_scale, scales['p_bdi'], scales['bdi'])
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": bdi_instruction}],
+        temperature=0
+    )
+    
+    bdi_response = response.choices[0].message.content
+    bdi_changes = extract_changes(bdi_response)
+    
+    # 总结GHQ的变化
+    ghq_instruction = """
+    ### 任务
+    根据量表的问题和答案，总结出两份量表之间的变化。
+    请列出明确的变化点，每个变化点单独一行，使用数字编号（1. 2. 3.）。
+    使用以下格式：
+    变化：
+    1. [第一个变化]
+    2. [第二个变化]
+    ...
+
+    ### 量表及问题
+    {}
+
+    ### 第一份量表的答案
+    {}
+
+    ### 第二份量表的答案
+    {}
+    """.format(ghq_scale, scales['p_ghq'], scales['ghq'])
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": ghq_instruction}],
+        temperature=0
+    )
+    
+    ghq_response = response.choices[0].message.content
+    ghq_changes = extract_changes(ghq_response)
+    
+    # 总结SASS的变化
+    sass_instruction = """
+    ### 任务
+    根据量表的问题和答案，总结出两份量表之间的变化。
+    请列出明确的变化点，每个变化点单独一行，使用数字编号（1. 2. 3.）。
+    使用以下格式：
+    变化：
+    1. [第一个变化]
+    2. [第二个变化]
+    ...
+
+    ### 量表及问题
+    {}
+
+    ### 第一份量表的答案
+    {}
+
+    ### 第二份量表的答案
+    {}
+    """.format(sass_scale, scales['p_sass'], scales['sass'])
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": sass_instruction}],
+        temperature=0
+    )
+    
+    sass_response = response.choices[0].message.content
+    sass_changes = extract_changes(sass_response)
+    
+    return bdi_changes, ghq_changes, sass_changes
+
+def summarize_scale_changes(scales):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    
+    # 获取量表变化
+    bdi_changes, ghq_changes, sass_changes = analyzing_changes(scales)
+    
+    # 总结量表变化
+    summary_instruction = """
+    ### 任务
+    根据量表的变化，总结患者的身体和心理状态变化。
+    请提供一个全面但简洁的总结，使用以下格式：
+    总结：
+    [总结内容]
+
+    ### BDI量表变化
+    {}
+
+    ### GHQ量表变化
+    {}
+
+    ### SASS量表变化
+    {}
+    """.format(
+        '\n'.join([f"{i+1}. {change}" for i, change in enumerate(bdi_changes)]),
+        '\n'.join([f"{i+1}. {change}" for i, change in enumerate(ghq_changes)]),
+        '\n'.join([f"{i+1}. {change}" for i, change in enumerate(sass_changes)])
+    )
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[{"role": "user", "content": summary_instruction}],
+        temperature=0
+    )
+    
+    summary_response = response.choices[0].message.content
+    status = extract_status(summary_response)
+    
+    return status
+
+# 额外增加一个更健壮的解析函数，可以处理不同格式的输出
+def parse_response_robust(text, expected_format="list"):
+    """更健壮的响应解析函数
+    
+    参数:
+        text: 文本响应
+        expected_format: 预期格式，可以是"list"或"summary"
+    
+    返回:
+        解析后的结果（列表或字符串）
+    """
+    # 首先尝试JSON格式解析
+    try:
+        # 尝试提取JSON部分
+        json_pattern = r'\{[\s\S]*\}'
+        json_match = re.search(json_pattern, text)
+        if json_match:
+            json_data = json.loads(json_match.group(0))
+            if expected_format == "list" and "changes" in json_data:
+                return json_data["changes"]
+            elif expected_format == "summary" and "status" in json_data:
+                return json_data["status"]
+    except:
+        pass  # 如果JSON解析失败，继续尝试其他方法
+    
+    # 使用适当的提取函数
+    if expected_format == "list":
+        return extract_changes(text)
+    else:  # summary
+        return extract_status(text)
+
+# unit test
+# if __name__ == "__main__":
+#     # 测试数据
+#     scales = {
+#         "p_bdi": ["A", "B", "C"],
+#         "bdi": ["B", "C", "D"],
+#         "p_ghq": ["A", "A", "B"],
+#         "ghq": ["B", "C", "C"],
+#         "p_sass": ["A", "B", "A"],
+#         "sass": ["C", "D", "B"]
+#     }
+    
+#     changes = summarize_scale_changes(scales)
+#     print(changes)

src/style_analyzer.py

@@ -0,0 +1,88 @@
+from openai import OpenAI
+import os
+import re
+
+# 设置OpenAI API密钥和基础URL
+api_key = os.getenv("OPENAI_API_KEY")
+base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
+model_name = os.getenv("OPENAI_MODEL_NAME", "gpt-3.5-turbo")
+
+def analyze_style(profile, conversations):
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url
+    )
+    # 提取患者信息
+    patient_info = f"### 患者信息\n年龄：{profile['age']}\n性别：{profile['gender']}\n职业：{profile['occupation']}\n婚姻状况：{profile['marital_status']}\n症状：{profile['symptoms']}"
+    # 提取对话记录
+    dialogue_history = "\n".join([f"{conv['role']}: {conv['content']}" for conv in conversations])
+    
+    # 构建提示词，明确要求模型按特定格式输出结果
+    prompt = f"""### 任务
+根据患者情况及咨访对话历史记录分析患者的说话风格。
+
+{patient_info}
+
+### 对话记录
+{dialogue_history}
+
+请分析患者的说话风格，最多列出5种风格特点。
+请按以下格式输出结果：
+说话风格：
+1. [风格特点1]
+2. [风格特点2]
+3. [风格特点3]
+...
+
+只需要列出风格特点，不需要解释。
+"""
+    
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    
+    # 从响应中提取说话风格列表
+    response_text = response.choices[0].message.content
+    
+    # 使用正则表达式提取风格特点
+    # 匹配"说话风格："之后的列表项
+    style_pattern = r"说话风格：\s*(?:\d+\.\s*([^\n]+)(?:\n|$))+"
+    match = re.search(style_pattern, response_text, re.DOTALL)
+    
+    if match:
+        # 提取所有的列表项
+        style_items = re.findall(r"\d+\.\s*([^\n]+)", response_text)
+        return style_items
+    else:
+        # 如果没有按预期格式输出，尝试使用备用正则表达式
+        # 寻找任何可能的列表项
+        fallback_items = re.findall(r"(?:^|\n)(?:\d+[\.\)、]|[-•*])\s*([^\n]+)", response_text)
+        
+        # 如果仍然没找到，尝试直接分割文本
+        if not fallback_items:
+            # 找到可能包含风格描述的行
+            potential_styles = [line.strip() for line in response_text.split('\n') 
+                               if line.strip() and not line.startswith('###') and '：' not in line]
+            return potential_styles[:5]  # 最多返回5项
+        
+        return fallback_items[:5]  # 最多返回5项
+    
+# unit test
+# profile = {
+#     "drisk": 3,
+#     "srisk": 2,
+#     "age": "42",
+#     "gender": "女",
+#     "marital_status": "离婚",
+#     "occupation": "教师",
+#     "symptoms": "缺乏自信心，自我价值感低，有自罪感，无望感；体重剧烈增加；精神运动性激越；有自杀想法"
+# }
+# conversations = [
+#     {"role": "user", "content": "我最近感觉很沮丧，似乎一切都没有意义。"},
+#     {"role": "assistant", "content": "你能具体说说是什么让你有这样的感觉吗？"},
+#     {"role": "user", "content": "我觉得自己在工作上总是做不好，没什么价值。"}
+# ]
+# print(analyze_style(profile, conversations))