优化LLM消息格式化和响应处理逻辑，增强错误处理和调试信息，改进说话人识别器的JSON输出提取逻辑。

src/podcast_transcribe/llm/llm_base.py

@@ -22,78 +22,178 @@ class BaseChatCompletion(ABC):
         pass
 
     def _format_messages_for_gemma(self, messages: List[Dict[str, str]]) -> str:
-        """
-        为Gemma格式化消息。
-        Gemma期望特定的格式，通常类似于：
-        <start_of_turn>user
-        {user_message}<end_of_turn>
-        <start_of_turn>model
-        {assistant_message}<end_of_turn>
-        ...
-        <start_of_turn>user
-        {current_user_message}<end_of_turn>
-        <start_of_turn>model
-        """
-        # 尝试使用分词器的聊天模板（如果可用）
         try:
-            # Hugging Face分词器中的apply_chat_template方法
-            # 通常需要一个字典列表，每个字典包含'role'和'content'。
-            # 我们需要确保我们的`messages`格式兼容。
-            # add_generation_prompt=True 至关重要，以确保模型知道轮到它发言了。
-            return self.tokenizer.apply_chat_template(
-                messages, tokenize=False, add_generation_prompt=True
+            # 确保消息格式正确
+            formatted_messages = []
+            for msg in messages:
+                if msg.get("role") and msg.get("content"):
+                    formatted_messages.append({
+                        "role": msg["role"],
+                        "content": msg["content"]
+                    })
+            
+            # 使用官方聊天模板
+            prompt_str = self.tokenizer.apply_chat_template(
+                formatted_messages, 
+                tokenize=False, 
+                add_generation_prompt=True
             )
-        except Exception:
-            # 如果apply_chat_template失败或不可用，则回退到手动格式化
+            
+            # 调试信息
+            print(f"使用官方聊天模板格式化成功，长度: {len(prompt_str)}")
+            return prompt_str
+            
+        except Exception as e:
+            print(f"官方聊天模板失败: {e}，使用手动格式化")
+            
+            # 手动格式化 - 改进版本
             prompt_parts = []
-            for message in messages:
+            
+            # 处理系统消息 - Gemma 3 的正确处理方式
+            system_messages = [msg for msg in messages if msg.get("role") == "system"]
+            other_messages = [msg for msg in messages if msg.get("role") != "system"]
+            
+            # 对于 Gemma，系统消息通常需要特殊处理
+            if system_messages:
+                # 将系统消息作为第一个用户消息的前缀
+                system_content = "\n".join([msg["content"] for msg in system_messages])
+                if other_messages and other_messages[0].get("role") == "user":
+                    # 将系统提示合并到第一个用户消息中
+                    first_user_msg = other_messages[0]
+                    combined_content = f"{system_content}\n\n{first_user_msg['content']}"
+                    other_messages[0] = {"role": "user", "content": combined_content}
+                else:
+                    # 如果没有用户消息，创建一个包含系统提示的用户消息
+                    other_messages.insert(0, {"role": "user", "content": system_content})
+            
+            # 格式化其他消息
+            for message in other_messages:
                 role = message.get("role")
-                content = message.get("content")
+                content = message.get("content", "").strip()
+                
+                if not content:
+                    continue
+                    
                 if role == "user":
                     prompt_parts.append(f"<start_of_turn>user\n{content}<end_of_turn>")
                 elif role == "assistant":
                     prompt_parts.append(f"<start_of_turn>model\n{content}<end_of_turn>")
-                elif role == "system": # Gemma可能不会以相同的方式显式使用'system'，通常是前置的
-                    # 对于Gemma，系统提示通常只是前置到第一个用户消息或隐式处理。
-                    # 我们会在这里前置它，尽管其有效性取决于特定的Gemma微调。
-                    # 一种常见的模式是在开头放置系统指令，不使用特殊标记。
-                    # 然而，为了保持结构化，我们将尝试一种通用方法。
-                    # 如果分词器在其模板中有特定的方式来处理系统提示，
-                    # 那么`apply_chat_template`将是首选。
-                    # 由于我们处于回退状态，这是一个最佳猜测。
-                    # 一些模型期望系统提示在轮次结构之外，或者在最开始。
-                    # 为了在回退中简化，我们只做前置处理。
-                    # 如果`apply_chat_template`不可用，更健壮的解决方案是检查模型的特定聊天模板。
-                    prompt_parts.insert(0, f"<start_of_turn>system\n{content}<end_of_turn>")
-
-            # 添加提示，让模型开始生成
+            
+            # 添加生成提示
             prompt_parts.append("<start_of_turn>model")
-            return "\n".join(prompt_parts)
+            
+            formatted_prompt = "\n".join(prompt_parts)
+            print(f"手动格式化完成，长度: {len(formatted_prompt)}")
+            return formatted_prompt
 
     def _post_process_response(self, response_text: str, prompt_str: str) -> str:
         """
         后处理生成的响应文本，清理提示和特殊标记
         """
-        # 后处理：Gemma的输出可能包含输入提示或特殊标记。
-        # 我们需要清理这些，以仅返回助手的最新消息。
-        # 一种常见的模式是，模型输出将以我们给它的提示开始，
-        # 或者它可能包含 <start_of_turn>model 标记，然后是其响应。
-
-        # 如果模型输出包含提示，然后是新的响应：
+        print(f"原始响应长度: {len(response_text)}")
+        print(f"原始响应前100字符: {response_text[:100]}")
+        
+        # 如果模型输出包含提示，则移除提示部分
         if response_text.startswith(prompt_str):
             assistant_message_content = response_text[len(prompt_str):].strip()
+            print("检测到响应包含提示，已移除提示部分")
         else:
-            # 如果模型不回显提示，则可能需要更复杂的清理。
-            # 对于Gemma，响应通常跟随提示的最后一部分 "<start_of_turn>model\n"。
-            # 让我们尝试找到最后一个 "<start_of_turn>model" 并获取其后的文本。
-            # 这是一种启发式方法，可能需要根据实际模型输出进行调整。
-            parts = response_text.split("<start_of_turn>model")
-            if len(parts) > 1:
+            # 尝试找到最后一个 "<start_of_turn>model" 标记
+            model_start_marker = "<start_of_turn>model"
+            if model_start_marker in response_text:
+                parts = response_text.split(model_start_marker)
                 assistant_message_content = parts[-1].strip()
-                # 进一步清理 <end_of_turn> 或其他特殊标记
-                assistant_message_content = assistant_message_content.split("<end_of_turn>")[0].strip()
-            else: # 如果上述方法不起作用，则回退
+                print("通过 <start_of_turn>model 标记分割响应")
+            else:
+                # 如果没有找到标记，使用整个响应
                 assistant_message_content = response_text.strip()
+                print("未找到特殊标记，使用完整响应")
+        
+        # 清理结束标记
+        end_markers = ["<end_of_turn>", "<|endoftext|>", "</s>"]
+        for marker in end_markers:
+            if marker in assistant_message_content:
+                assistant_message_content = assistant_message_content.split(marker)[0].strip()
+                print(f"移除结束标记: {marker}")
+        
+        # 特殊处理：如果响应看起来像 JSON，尝试提取 JSON 部分
+        if "{" in assistant_message_content and "}" in assistant_message_content:
+            # 尝试提取 JSON 对象
+            first_brace = assistant_message_content.find("{")
+            last_brace = assistant_message_content.rfind("}")
+            if first_brace != -1 and last_brace != -1 and last_brace > first_brace:
+                potential_json = assistant_message_content[first_brace:last_brace + 1]
+                # 验证是否为有效 JSON
+                try:
+                    import json
+                    json.loads(potential_json)
+                    assistant_message_content = potential_json
+                    print("提取并验证了 JSON 响应")
+                except json.JSONDecodeError:
+                    print("JSON 验证失败，保持原始响应")
+                    # 如果JSON验证失败，尝试清理常见的非JSON内容
+                    lines = assistant_message_content.split('\n')
+                    cleaned_lines = []
+                    json_started = False
+                    
+                    for line in lines:
+                        line = line.strip()
+                        # 跳过明显的解释性文本
+                        if any(phrase in line.lower() for phrase in [
+                            'here is', 'here\'s', 'based on', 'analysis', 'looking at',
+                            'the json', 'response:', 'result:', 'output:', 'answer:',
+                            'i can see', 'it appears', 'according to'
+                        ]):
+                            continue
+                        
+                        # 如果遇到JSON开始，标记开始
+                        if '{' in line:
+                            json_started = True
+                        
+                        # 如果已经开始JSON，保留所有内容
+                        if json_started:
+                            cleaned_lines.append(line)
+                        
+                        # 如果遇到JSON结束，停止
+                        if '}' in line and json_started:
+                            break
+                    
+                    if cleaned_lines:
+                        assistant_message_content = '\n'.join(cleaned_lines)
+                        print("清理了非JSON解释性内容")
+        
+        # 最终清理：移除常见的解释性前缀和后缀
+        prefixes_to_remove = [
+            "Here is the JSON:", "Here's the JSON:", "The JSON response is:",
+            "Based on the analysis:", "Looking at the information:",
+            "Here is my analysis:", "The result is:", "My response:",
+            "Output:", "Answer:", "Result:"
+        ]
+        
+        for prefix in prefixes_to_remove:
+            if assistant_message_content.lower().startswith(prefix.lower()):
+                assistant_message_content = assistant_message_content[len(prefix):].strip()
+                print(f"移除前缀: {prefix}")
+                break
+        
+        # 移除常见的后缀解释
+        suffixes_to_remove = [
+            "This JSON object maps each speaker ID to their identified name or role.",
+            "Each speaker has been identified based on the provided information.",
+            "The identification is based on the dialogue samples and metadata."
+        ]
+        
+        for suffix in suffixes_to_remove:
+            if assistant_message_content.lower().endswith(suffix.lower()):
+                assistant_message_content = assistant_message_content[:-len(suffix)].strip()
+                print(f"移除后缀: {suffix}")
+                break
+        
+        # 最终清理
+        assistant_message_content = assistant_message_content.strip()
+        
+        print(f"处理后响应长度: {len(assistant_message_content)}")
+        print(f"处理后响应前100字符: {assistant_message_content[:100]}")
         
         return assistant_message_content
 
@@ -223,19 +323,26 @@ class TransformersBaseChatCompletion(BaseChatCompletion):
                 print("警告: MPS 设备不支持 device_map，将手动管理设备")
             else:
                 model_kwargs["device_map"] = self.device_map
+                print(f"使用设备映射: {self.device_map}")
         
         # 加载模型
+        print("开始加载模型...")
         self.model = AutoModelForCausalLM.from_pretrained(
             self.model_name,
             **model_kwargs
         )
         
         # MPS 或手动设备管理
-        if self.device_map is None:
+        if self.device_map is None and self.device is not None:
             print(f"手动移动模型到设备: {self.device}")
             self.model = self.model.to(self.device)
         
+        # 设置模型为评估模式
+        self.model.eval()
+        
         print(f"模型 {self.model_name} 加载成功")
+        print(f"模型数据类型: {self.model.dtype}")
+        print(f"模型设备: {next(self.model.parameters()).device}")
     
     def _load_model_and_tokenizer(self):
         """加载模型和分词器"""
@@ -269,26 +376,102 @@ class TransformersBaseChatCompletion(BaseChatCompletion):
         inputs = self.tokenizer.encode(prompt_str, return_tensors="pt")
         
         # 移动输入到正确的设备
-        if self.device_map is None or (self.device and self.device.type == "mps"):
+        if self.device_map is None or (self.device and hasattr(self.device, 'type') and self.device.type == "mps"):
             inputs = inputs.to(self.device)
         
-        # 生成参数
+        # 优化的生成参数配置
         generation_config = {
             "max_new_tokens": max_tokens,
-            "temperature": temperature,
-            "top_p": top_p,
-            "do_sample": True if temperature > 0 else False,
             "pad_token_id": self.tokenizer.pad_token_id,
             "eos_token_id": self.tokenizer.eos_token_id,
-            "repetition_penalty": kwargs.get("repetition_penalty", 1.1),
-            "no_repeat_ngram_size": kwargs.get("no_repeat_ngram_size", 3),
+            "use_cache": True,  # 启用 KV 缓存以提高速度
         }
         
-        # 如果温度为0，使用贪婪解码
-        if temperature == 0:
-            generation_config["do_sample"] = False
-            generation_config.pop("temperature", None)
-            generation_config.pop("top_p", None)
+        # 温度和采样配置 - 修复 CUDA 采样错误
+        if temperature > 0:
+            # 确保温度值在合理范围内
+            temperature = max(0.01, min(temperature, 2.0))
+            top_p = max(0.01, min(top_p, 1.0))
+            
+            generation_config.update({
+                "do_sample": True,
+                "temperature": temperature,
+                "top_p": top_p,
+                "top_k": kwargs.get("top_k", 10),  # 降低top_k以提高确定性
+            })
+        else:
+            # 贪婪解码 - 完全确定性
+            generation_config.update({
+                "do_sample": False,
+                "temperature": None,
+                "top_p": None,
+                "top_k": None,
+            })
+        
+        # 如果明确指定do_sample=False，强制使用贪婪解码
+        if kwargs.get("do_sample") is False:
+            generation_config.update({
+                "do_sample": False,
+                "temperature": None,
+                "top_p": None,
+                "top_k": None,
+            })
+            print("强制使用贪婪解码模式")
+        
+        # 重复惩罚配置 - 针对结构化输出优化
+        repetition_penalty = kwargs.get("repetition_penalty", 1.0)  # 默认不使用重复惩罚
+        if repetition_penalty != 1.0:
+            repetition_penalty = max(1.0, min(repetition_penalty, 1.3))  # 限制在更小范围内
+            generation_config["repetition_penalty"] = repetition_penalty
+        
+        # 移除no_repeat_ngram_size以避免干扰JSON格式
+        # generation_config["no_repeat_ngram_size"] = kwargs.get("no_repeat_ngram_size", 2)
+        
+        # 长度惩罚（可选）- 针对结构化输出调整
+        if kwargs.get("length_penalty") and kwargs["length_penalty"] != 1.0:
+            length_penalty = max(0.9, min(kwargs["length_penalty"], 1.1))  # 更保守的长度惩罚
+            generation_config["length_penalty"] = length_penalty
+        
+        # 针对结构化输出的特殊配置
+        if max_tokens <= 256:  # 如果是短输出任务（如JSON），使用更确定性的配置
+            generation_config.update({
+                "early_stopping": True,
+                "num_beams": 1,  # 使用贪婪搜索
+            })
+            # 如果允许采样，使用较低的温度
+            if generation_config.get("do_sample", False):
+                generation_config["temperature"] = min(generation_config.get("temperature", 0.1), 0.3)
+                generation_config["top_p"] = min(generation_config.get("top_p", 0.3), 0.5)
+            print("检测到短输出任务，使用优化的生成配置")
+        
+        # 处理stop tokens
+        stop_strings = kwargs.get("stop", [])
+        if stop_strings:
+            # 将stop字符串转换为token IDs
+            stop_token_ids = []
+            for stop_str in stop_strings:
+                try:
+                    # 编码stop字符串为token IDs
+                    stop_tokens = self.tokenizer.encode(stop_str, add_special_tokens=False)
+                    stop_token_ids.extend(stop_tokens)
+                except Exception as e:
+                    print(f"无法编码stop字符串 '{stop_str}': {e}")
+            
+            if stop_token_ids:
+                # 去重并添加到eos_token_id列表中
+                existing_eos = generation_config.get("eos_token_id", self.tokenizer.eos_token_id)
+                if isinstance(existing_eos, int):
+                    existing_eos = [existing_eos]
+                elif existing_eos is None:
+                    existing_eos = []
+                
+                all_stop_tokens = list(set(existing_eos + stop_token_ids))
+                generation_config["eos_token_id"] = all_stop_tokens
+                print(f"添加了 {len(stop_token_ids)} 个stop token IDs")
+        
+        # 调试信息
+        print(f"生成配置: temperature={temperature}, max_tokens={max_tokens}, top_p={top_p}")
+        print(f"输入长度: {len(inputs[0])} tokens")
         
         try:
             # 生成响应
@@ -302,10 +485,41 @@ class TransformersBaseChatCompletion(BaseChatCompletion):
             generated_tokens = outputs[0][len(inputs[0]):]
             generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True)
             
+            print(f"生成完成，输出长度: {len(generated_tokens)} tokens")
             return generated_text
             
+        except RuntimeError as e:
+            if "CUDA error" in str(e):
+                print(f"CUDA 错误，尝试使用 CPU 进行推理: {e}")
+                # 尝试移动到 CPU 并重试
+                try:
+                    inputs_cpu = inputs.cpu()
+                    model_cpu = self.model.cpu()
+                    
+                    with torch.no_grad():
+                        outputs = model_cpu.generate(
+                            inputs_cpu,
+                            **generation_config
+                        )
+                    
+                    # 移回原设备
+                    self.model = self.model.to(self.device)
+                    
+                    generated_tokens = outputs[0][len(inputs_cpu[0]):]
+                    generated_text = self.tokenizer.decode(generated_tokens, skip_special_tokens=True)
+                    
+                    print(f"CPU 推理完成，输出长度: {len(generated_tokens)} tokens")
+                    return generated_text
+                    
+                except Exception as cpu_e:
+                    print(f"CPU 推理也失败: {cpu_e}")
+                    raise e
+            else:
+                raise e
         except Exception as e:
             print(f"生成响应时出错: {e}")
+            import traceback
+            traceback.print_exc()
             raise
     
     def get_model_info(self) -> Dict[str, Union[str, bool, int]]:

src/podcast_transcribe/summary/speaker_identify.py

@@ -167,67 +167,38 @@ class SpeakerIdentifier:
         if len(cleaned_episode_shownotes) > max_shownotes_length:
             episode_shownotes_for_prompt += "..."
 
-        system_prompt = """You are an experienced podcast content analyst. Your task is to accurately identify the real names, nicknames, or roles of different speakers (tagged in SPEAKER_XX format) in a podcast episode, based on the provided metadata, episode information, dialogue snippets, and speech patterns. Your analysis should NOT rely on the order of speakers or speaker IDs. Your output MUST be a single, valid JSON object and nothing else, without any markdown formatting or other explanatory text."""
+        system_prompt = """You are a speaker identification expert. Return only a JSON object mapping speaker IDs to names. Start directly with { and end with }. No markdown, no explanations."""
 
-        user_prompt_template = f"""
-Contextual Information:
-
-1.  **Podcast Information**:
-    *   Podcast Title: {podcast_title}
-    *   Podcast Author/Producer: {podcast_author} (This information often points to the main host or production team)
-    *   Podcast Description: {podcast_desc_for_prompt}
-
-2.  **Current Episode Information**:
-    *   Episode Title: {episode_title}
-    *   Episode Summary: {episode_summary_for_prompt}
-    *   Detailed Episode Notes (Shownotes):
-        ```text
-        {episode_shownotes_for_prompt}
-        ```
-        (Pay close attention to any host names, guest names, positions, or social media handles mentioned in the Shownotes.)
-
-3.  **Speakers to Identify and Their Information**:
-    ```json
-    {json.dumps(speaker_info_for_prompt, ensure_ascii=False, indent=2)}
-    ```
-    (Analyze dialogue samples and speech statistics to understand speaker roles and identities. DO NOT use speaker IDs to determine roles - SPEAKER_00 is not necessarily the host.)
+        # 进一步简化，只保留最关键的信息
+        key_info = []
+        for speaker_id in unique_speaker_ids:
+            samples = dialogue_samples.get(speaker_id, [])
+            stats = speaker_stats.get(speaker_id, {"total_segments": 0, "intro_likely": False})
+            
+            # 构建简短描述
+            desc_parts = []
+            if stats["intro_likely"]:
+                desc_parts.append("intro")
+            if stats["total_segments"] > 0:
+                desc_parts.append(f"{stats['total_segments']}segs")
+            if samples:
+                # 只取第一个样本的前50个字符
+                sample_text = samples[0][:50].replace('\n', ' ').strip()
+                if sample_text:
+                    desc_parts.append(f'"{sample_text}"')
+            
+            key_info.append(f"{speaker_id}: {', '.join(desc_parts)}")
 
-Task:
-Based on all the information above, assign the most accurate name or role to each "speaker_id".
+        user_prompt_template = f"""Podcast: {podcast_title}
+Host: {podcast_author}
+Episode: {episode_title}
 
-Analysis Guidance:
-* A host typically has more frequent, shorter segments, often introduces the show or guests, and may mention the podcast name
-* In panel discussion formats, there might be multiple hosts or co-hosts of similar speaking patterns
-* In interview formats, the host typically asks questions while guests give longer answers
-* Speakers who make introductory statements or welcome listeners are likely hosts
-* Use dialogue content (not just speaking patterns) to identify names and roles
+Notes: {episode_shownotes_for_prompt[:300]}
 
-Output Requirements and Guidelines:
-*   **Your response MUST be ONLY a valid JSON object.** Do NOT include any other text, explanations, code, or markdown formatting (like ```json ... ```). The JSON object is the ONLY content your response should contain.
-*   The keys of the JSON object MUST be the EXACT "speaker_id"s provided in the input's "Speakers to Identify and Their Information" section (e.g., "SPEAKER_00", "SPEAKER_01").
-*   The values in the JSON object should be the identified person's name or role (string type).
-*   **Prioritize Specific Names/Nicknames**: If there is sufficient information (e.g., guests explicitly listed in Shownotes, or names mentioned in dialogue), please use the identified specific names, such as "John Doe", "AI Assistant", "Dr. Evelyn Reed". Do NOT append roles like "(Host)" or "(Guest)" if a specific name is found.
-*   **Host Identification**:
-    *   Hosts may be identified by analyzing speech patterns - they often speak more frequently in shorter segments
-    *   Look for introduction patterns in dialogue where speakers welcome listeners or introduce the show
-    *   The podcast author (if provided and credible) is often a host but verify through dialogue
-    *   There may be multiple hosts (co-hosts) in panel-style podcasts
-    *   If a host's name is identified, use the identified name directly (e.g., "Lex Fridman"). Do not append "(Host)".
-    *   If the host's name cannot be determined but the role is clearly a host, use "Podcast Host".
-*   **Guest Identification**:
-    *   Guests often give longer responses and speak less frequently than hosts
-    *   For other non-host speakers, if a specific name is identified, use the identified name directly (e.g., "John Carmack"). Do not append "(Guest)".
-    *   If specific names cannot be identified for guests, label them sequentially as "Guest 1", "Guest 2", etc.
-*   **Handling Multiple Hosts/Guests**: If there are multiple hosts or guests and they can be distinguished by name, use their names. If you cannot distinguish specific identities but know there are multiple hosts, use "Host 1", "Host 2", etc. Similarly for guests without specific names, use "Guest 1", "Guest 2".
-*   **Ensure Completeness**: The returned JSON object must include ALL "speaker_id"s listed in the input's "Speakers to Identify and Their Information" section as keys. Each "speaker_id" from the input MUST be a key in your output JSON.
+Speakers:
+{chr(10).join(key_info)}
 
-Ensure the output is a valid JSON object. For example:
-{{
-  "SPEAKER_00": "Jane Smith",
-  "SPEAKER_01": "Podcast Host",
-  "SPEAKER_02": "Alex Green"
-}}
-"""
+Return JSON like: {{"SPEAKER_00": "Name1", "SPEAKER_01": "Name2"}}"""
 
         messages = [
             {"role": "system", "content": system_prompt},
@@ -281,39 +252,63 @@ Ensure the output is a valid JSON object. For example:
                 messages=messages, 
                 provider=self.llm_provider,
                 model=self.llm_model_name,
-                temperature=0.1, 
-                max_tokens=1024,
-                device=self.device
+                temperature=0.2,   # 稍微提高温度
+                max_tokens=300,    # 进一步增加token数
+                top_p=0.5,         # 适度提高top_p
+                device=self.device,
+                repetition_penalty=1.0,  # 保持不使用重复惩罚
+                do_sample=True     # 允许少量采样，不使用stop tokens
             )
             logger.info(f"LLM调用日志，请求参数:【{messages}】, 响应: 【{response}】")
             assistant_response_content = response["choices"][0]["message"]["content"]
             
+            # 更严格的JSON提取逻辑
             parsed_llm_output = None
-            # 尝试从Markdown代码块中提取JSON
-            json_match = re.search(r'```json\s*(\{.*?\})\s*```', assistant_response_content, re.DOTALL)
-            if json_match:
-                json_str = json_match.group(1)
-            else:
-                # 如果没有markdown块，尝试找到第一个 '{' 到最后一个 '}'
-                first_brace = assistant_response_content.find('{')
-                last_brace = assistant_response_content.rfind('}')
-                if first_brace != -1 and last_brace != -1 and last_brace > first_brace:
-                    json_str = assistant_response_content[first_brace : last_brace+1]
-                else: # 如果还是找不到，就认为整个回复都是JSON（可能需要更复杂的清理）
-                    json_str = assistant_response_content.strip()
             
+            # 首先尝试直接解析整个响应（如果它就是JSON）
             try:
-                # 替换换行符
-                json_str = json_str.replace("\n", "")
-
-                parsed_llm_output = json.loads(json_str)
-                if not isinstance(parsed_llm_output, dict): # 确保解析出来是字典
-                    print(f"LLM返回的JSON不是一个字典: {parsed_llm_output}")
-                    parsed_llm_output = None # 重置，以便使用默认值
-            except json.JSONDecodeError as e:
-                print(f"LLM返回的JSON解析失败: {e}")
-                print(f"用于解析的字符串: '{json_str}'")
-                # parsed_llm_output 保持为 None，将使用默认值
+                parsed_llm_output = json.loads(assistant_response_content.strip())
+                if isinstance(parsed_llm_output, dict):
+                    print("直接解析响应为JSON成功")
+                else:
+                    parsed_llm_output = None
+            except json.JSONDecodeError:
+                pass
+            
+            # 如果直接解析失败，尝试提取JSON部分
+            if parsed_llm_output is None:
+                # 尝试从Markdown代码块中提取JSON
+                json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', assistant_response_content, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(1)
+                    print("从markdown代码块中提取JSON")
+                else:
+                    # 如果没有markdown块，尝试找到第一个 '{' 到最后一个 '}'
+                    first_brace = assistant_response_content.find('{')
+                    last_brace = assistant_response_content.rfind('}')
+                    if first_brace != -1 and last_brace != -1 and last_brace > first_brace:
+                        json_str = assistant_response_content[first_brace : last_brace+1]
+                        print("通过大括号位置提取JSON")
+                    else:
+                        print("无法找到有效的JSON结构，使用默认映射")
+                        return final_map
+                
+                try:
+                    # 清理JSON字符串
+                    json_str = json_str.strip()
+                    # 移除可能的换行符和多余空格
+                    json_str = re.sub(r'\s+', ' ', json_str)
+                    
+                    parsed_llm_output = json.loads(json_str)
+                    if not isinstance(parsed_llm_output, dict):
+                        print(f"LLM返回的JSON不是一个字典: {parsed_llm_output}")
+                        parsed_llm_output = None
+                    else:
+                        print("JSON解析成功")
+                except json.JSONDecodeError as e:
+                    print(f"LLM返回的JSON解析失败: {e}")
+                    print(f"用于解析的字符串: '{json_str[:200]}...'")
+                    parsed_llm_output = None
 
             if parsed_llm_output:
                 # 直接使用LLM的有效输出，不再依赖预设的角色分配逻辑
@@ -346,6 +341,8 @@ Ensure the output is a valid JSON object. For example:
                     
                     if most_active_unknown:
                         final_map[most_active_unknown] = "Podcast Host"
+                        
+                print(f"LLM识别结果: {final_map}")
             
             return final_map