Update core/pipeline_agent.py

core/pipeline_agent.py

@@ -68,6 +68,28 @@ class SSciPipelineAgent:
         except:
             self.tokenizer = tiktoken.get_encoding("gpt2")
 
+    # 🚨 新增：无敌 JSON 提取器。杜绝大模型废话导致的解析崩溃
+    def _extract_json_from_text(self, text):
+        if not text: return None
+        text = text.strip()
+        try:
+            start_dict = text.find('{')
+            end_dict = text.rfind('}')
+            start_list = text.find('[')
+            end_list = text.rfind(']')
+            
+            dict_len = end_dict - start_dict if start_dict != -1 and end_dict != -1 else -1
+            list_len = end_list - start_list if start_list != -1 and end_list != -1 else -1
+            
+            if dict_len == -1 and list_len == -1: return None
+            
+            if dict_len > list_len:
+                return json.loads(text[start_dict:end_dict+1])
+            else:
+                return json.loads(text[start_list:end_list+1])
+        except Exception:
+            return None
+
     def export_state(self):
         with self.lock:
             return {
@@ -151,29 +173,31 @@ class SSciPipelineAgent:
         if self.global_memory["method_summary"]: memory_parts.append(f"【METHODOLOGICAL SUMMARY】\n{self.global_memory['method_summary']}")
         
         golden_meta = self.global_memory.get("core_golden_metadata", [])
-        if golden_meta and section_name:
+        # 🚨 类型安全防护：确保 golden_meta 一定是 List，防止大模型意外包裹字典导致遍历崩溃
+        if isinstance(golden_meta, list) and section_name:
             lower_sec = section_name.lower()
             injected_data = []
             
             if any(kw in lower_sec for kw in ["introduction", "background"]):
                 for p in golden_meta:
-                    if p.get('future_gaps'): injected_data.append(f"[{p['title']}] Future Gaps: {p['future_gaps']}")
+                    if isinstance(p, dict) and p.get('future_gaps'): injected_data.append(f"[{p.get('title', 'Ref')}] Future Gaps: {p['future_gaps']}")
                 if injected_data: memory_parts.append("【TARGETED INJECTION: CORE LITERATURE GAPS (FOR RESEARCH GAP FORMULATION)】\n" + "\n".join(injected_data))
                 
             elif any(kw in lower_sec for kw in ["literature", "theor", "hypothesis", "review"]):
                 for p in golden_meta:
-                    if p.get('theoretical_lens'): injected_data.append(f"[{p['title']}] Theoretical Lens: {p['theoretical_lens']}")
-                    if p.get('causal_pathways'): injected_data.append(f"[{p['title']}] Pathways: {p['causal_pathways']}")
+                    if isinstance(p, dict):
+                        if p.get('theoretical_lens'): injected_data.append(f"[{p.get('title', 'Ref')}] Theoretical Lens: {p['theoretical_lens']}")
+                        if p.get('causal_pathways'): injected_data.append(f"[{p.get('title', 'Ref')}] Pathways: {p['causal_pathways']}")
                 if injected_data: memory_parts.append("【TARGETED INJECTION: CORE LITERATURE THEORIES & PATHWAYS (USE FOR HYPOTHESIS DEDUCTION)】\n" + "\n".join(injected_data))
                 
             elif any(kw in lower_sec for kw in ["method", "measure", "data", "sample"]):
                 for p in golden_meta:
-                    if p.get('variables_and_measurements'): injected_data.append(f"[{p['title']}] Measurements: {p['variables_and_measurements']}")
+                    if isinstance(p, dict) and p.get('variables_and_measurements'): injected_data.append(f"[{p.get('title', 'Ref')}] Measurements: {p['variables_and_measurements']}")
                 if injected_data: memory_parts.append("【TARGETED INJECTION: CORE LITERATURE MEASUREMENTS (USE FOR SCALE ADAPTATION DEFENSE)】\n" + "\n".join(injected_data))
                 
             elif any(kw in lower_sec for kw in ["discussion", "conclusion", "implication", "result", "analysis"]):
                 for p in golden_meta:
-                    if p.get('causal_pathways'): injected_data.append(f"[{p['title']}] Confirmed Pathways: {p['causal_pathways']}")
+                    if isinstance(p, dict) and p.get('causal_pathways'): injected_data.append(f"[{p.get('title', 'Ref')}] Confirmed Pathways: {p['causal_pathways']}")
                 if injected_data: memory_parts.append("【TARGETED INJECTION: CORE LITERATURE FINDINGS (COMPARE OUR RESULTS AGAINST THESE)】\n" + "\n".join(injected_data))
 
         full = "\n\n".join(memory_parts)
@@ -291,7 +315,6 @@ class SSciPipelineAgent:
             try:
                 response = self.call_deepseek(sys_prompt, user_prompt, max_tokens=300)
                 clean_resp = re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL).strip()
-                clean_resp = re.sub(r'^```.*|```$', '', clean_resp, flags=re.MULTILINE).strip()
                 if '||' in clean_resp:
                     headings = [h.strip() for h in clean_resp.split('||') if h.strip()]
                     if len(headings) >= 3: return headings
@@ -305,11 +328,10 @@ class SSciPipelineAgent:
         user_prompt = f"Target Section: {section_name}\nAnalyze the reference text:\n<REFERENCE_TEXT>\n{reference_text[:10000]}\n</REFERENCE_TEXT>\nOutput ONLY a valid JSON object: {{\"tone_and_style\": \"...\", \"reporting_structure\": \"...\", \"few_shot_snippet\": \"...\"}}"
         for attempt in range(3):
             response = self.call_deepseek(sys_prompt, user_prompt, temp=0.2)
-            clean = re.sub(r'^```json\s*|\s*```$', '', response.strip(), flags=re.IGNORECASE | re.MULTILINE)
-            try:
-                result = json.loads(clean)
-                if "few_shot_snippet" in result: return result
-            except: time.sleep(1)
+            result = self._extract_json_from_text(response)
+            if result and isinstance(result, dict) and "few_shot_snippet" in result:
+                return result
+            time.sleep(1)
         return {"tone_and_style": "objective academic tone", "reporting_structure": "standard empirical reporting", "few_shot_snippet": ""}
 
     def parse_user_core_literature(self, user_lit_text):
@@ -339,13 +361,23 @@ class SSciPipelineAgent:
         for attempt in range(2):
             try:
                 response = self.call_deepseek(sys_prompt, user_prompt, temp=0.1, model_name="deepseek-chat") 
-                clean = re.sub(r'^```json\s*|\s*```$', '', response.strip(), flags=re.IGNORECASE | re.MULTILINE)
-                papers = json.loads(clean)
+                papers = self._extract_json_from_text(response)
+                
+                if not papers: raise ValueError("Extracted JSON is null")
+                
+                # 修复可能包裹在 dict 中的情况 (e.g., {"papers": [...]})
+                if isinstance(papers, dict):
+                    for v in papers.values():
+                        if isinstance(v, list):
+                            papers = v
+                            break
+                if not isinstance(papers, list): papers = [papers]
                 
                 self.global_memory["core_golden_metadata"] = papers
                 
                 rag_context = []
                 for paper in papers:
+                    if not isinstance(paper, dict): continue
                     title = paper.get("title", "User Provided Document")
                     year = paper.get("year", "n.d.")
                     authors = paper.get("authors", ["User, Uploaded"])
@@ -396,35 +428,26 @@ class SSciPipelineAgent:
 
     def generate_outline(self, topic, keywords, synthesis_result):
         sys_prompt = "You are a senior academic journal reviewer. Design a strict empirical research paper outline."
-        user_prompt = f"""Topic: {topic}\nKeywords: {keywords}\nLiterature Synthesis & Gaps:\n{synthesis_result}\n\nConstruct a detailed empirical outline. Your response must be a single valid JSON object: {{"en_topic": "...", "en_keywords": "...", "structure": [{{"section": "...", "weight": 0.15, "is_method_or_result": false}}]}}. 
-        CRITICAL: The 'structure' array MUST ONLY contain main body sections. DO NOT include Abstract, Keywords, Acknowledgments, or References in the structure array. 
-        Do not include any other text."""
+        user_prompt = f"""Topic: {topic}\nKeywords: {keywords}\nLiterature Synthesis & Gaps:\n{synthesis_result}\n\nConstruct a detailed empirical outline. Your response must be a single valid JSON object: {{"en_topic": "...", "en_keywords": "...", "structure": [{{"section": "...", "weight": 0.15, "is_method_or_result": false}}]}}. Do not include any other text."""
         for attempt in range(3):
             response = self.call_deepseek(sys_prompt, user_prompt, temp=0.2)
-            clean = re.sub(r'^```json\s*|\s*```$', '', response.strip(), flags=re.IGNORECASE | re.MULTILINE)
-            try:
-                plan = json.loads(clean)
-                if "structure" in plan: return plan
-            except Exception: time.sleep(2)
-        raise ValueError("Outline Generation Failed. Invalid JSON structure.")
+            plan = self._extract_json_from_text(response)
+            if plan and isinstance(plan, dict) and "structure" in plan:
+                return plan
+            time.sleep(2)
+        raise ValueError("Outline Generation Failed. Invalid JSON structure returned by model.")
 
     def generate_search_queries(self, topic, keywords):
         sys_prompt = "You are an expert academic librarian. Generate English search queries."
         user_prompt = f"""Topic: {topic}\nKeywords: {keywords}\nGenerate exactly 3 concise English search queries. Return ONLY a valid JSON array of strings."""
         for attempt in range(3):
             response = self.call_deepseek(sys_prompt, user_prompt, temp=0.1 + attempt * 0.1)
-            clean = re.sub(r'^```json\s*|\s*```$', '', response.strip(), flags=re.IGNORECASE | re.MULTILINE)
-            try:
-                queries = json.loads(clean)
-                if isinstance(queries, list) and len(queries) > 0:
-                    final_queries = [str(q).strip() for q in queries if self._is_english_dominant(str(q).strip())]
-                    if final_queries: return final_queries[:3]
-            except:
-                fallback_queries = re.findall(r'"([a-zA-Z\s\-]+)"', response)
-                if fallback_queries:
-                    final_queries = [q.strip() for q in fallback_queries if self._is_english_dominant(q.strip())]
-                    if final_queries: return final_queries[:3]
+            queries = self._extract_json_from_text(response)
+            if queries and isinstance(queries, list) and len(queries) > 0:
+                final_queries = [str(q).strip() for q in queries if self._is_english_dominant(str(q).strip())]
+                if final_queries: return final_queries[:3]
             time.sleep(1)
+            
         combined_text = f"{topic} {keywords}"
         english_chunks = re.findall(r'[a-zA-Z0-9\s\-]{4,}', combined_text)
         clean_chunks = [chunk.strip() for chunk in english_chunks if len(chunk.strip()) >= 4 and self._is_english_dominant(chunk.strip())]
@@ -463,13 +486,12 @@ class SSciPipelineAgent:
             else:
                 sys_prompt = "You are an expert academic librarian. The previous literature search yielded insufficient results. We must broaden the search scope."
                 user_prompt = f"Original Topic: {topic}\nOriginal Keywords: {keywords}\nAlready Used Queries: {list(all_used_terms)}\nGenerate exactly 3 NEW, BROADER, or RELATED English search queries (max 3-4 words each) to expand the literature search. Do NOT repeat previous queries. Return ONLY a valid JSON array of strings."
-                try:
-                    response = self.call_deepseek(sys_prompt, user_prompt, temp=0.5)
-                    clean = re.sub(r'^```json\s*|\s*```$', '', response.strip(), flags=re.IGNORECASE | re.MULTILINE)
-                    queries = json.loads(clean)
-                    if isinstance(queries, list): search_terms = [str(q).strip() for q in queries if self._is_english_dominant(str(q).strip())][:3]
-                    else: search_terms = []
-                except:
+                response = self.call_deepseek(sys_prompt, user_prompt, temp=0.5)
+                queries = self._extract_json_from_text(response)
+                
+                if queries and isinstance(queries, list): 
+                    search_terms = [str(q).strip() for q in queries if self._is_english_dominant(str(q).strip())][:3]
+                else:
                     fallback_queries = re.findall(r'"([a-zA-Z\s\-]+)"', response)
                     search_terms = [q.strip() for q in fallback_queries if self._is_english_dominant(q.strip())][:3]