isa-model 0.3.91__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/inference/services/llm/helpers/llm_adapter.py

@@ -150,7 +150,7 @@ class LangChainMessageAdapter:
                     tool_calls.append(tool_call)
                 
                 return AIMessage(
-                    content=response.content or "",
+                    content=response.content if response.content is not None else "",
                     tool_calls=tool_calls
                 )
             else:
@@ -177,7 +177,7 @@ class LangChainMessageAdapter:
                     }
                     tool_calls.append(tool_call)
                 
-                return SimpleAIMessage(response.content or "", tool_calls)
+                return SimpleAIMessage(response.content if response.content is not None else "", tool_calls)
             else:
                 content = response if isinstance(response, str) else getattr(response, 'content', str(response))
                 return SimpleAIMessage(content)
@@ -427,15 +427,74 @@ class StandardMessageAdapter:
     
     def from_openai_format(self, response: Union[str, Any], original_input: Any) -> Any:
         """从 OpenAI 格式转换回原始格式"""
-        # Handle response objects with tool_calls (preserve message object for compatibility)
-        if hasattr(response, 'tool_calls') and response.tool_calls:
-            # For standard format, we preserve the message object for tool_calls access
-            # This handles both OpenAI and Ollama message objects
-            return response
-        else:
-            # Handle simple string response
-            content = response if isinstance(response, str) else getattr(response, 'content', str(response))
-            return content
+        # For consistency, always return a message object similar to LangChain
+        try:
+            from langchain_core.messages import AIMessage
+            
+            # Extract content - handle None content for tool calls
+            if isinstance(response, str):
+                content = response
+            elif hasattr(response, 'content'):
+                content = response.content if response.content is not None else ""
+            else:
+                content = str(response)
+            
+            # Handle tool_calls if present
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                # Convert to LangChain format tool_calls
+                tool_calls = []
+                for tc in response.tool_calls:
+                    if hasattr(tc, 'function'):
+                        # OpenAI format: tc.function.name, tc.function.arguments
+                        try:
+                            import json
+                            args = json.loads(tc.function.arguments) if tc.function.arguments else {}
+                        except:
+                            args = {}
+                        
+                        tool_call = {
+                            "name": tc.function.name,
+                            "args": args,
+                            "id": getattr(tc, 'id', 'unknown'),
+                            "type": "tool_call"
+                        }
+                        tool_calls.append(tool_call)
+                
+                return AIMessage(content=content, tool_calls=tool_calls)
+            else:
+                return AIMessage(content=content)
+                
+        except ImportError:
+            # Fallback: create a simple message object
+            class SimpleAIMessage:
+                def __init__(self, content, tool_calls=None):
+                    self.content = content
+                    self.type = "ai"
+                    self.tool_calls = tool_calls or []
+            
+            # Handle tool_calls if present
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                tool_calls = []
+                for tc in response.tool_calls:
+                    if hasattr(tc, 'function'):
+                        try:
+                            import json
+                            args = json.loads(tc.function.arguments) if tc.function.arguments else {}
+                        except:
+                            args = {}
+                        
+                        tool_call = {
+                            "name": tc.function.name,
+                            "args": args,
+                            "id": getattr(tc, 'id', 'unknown'),
+                            "type": "tool_call"
+                        }
+                        tool_calls.append(tool_call)
+                
+                return SimpleAIMessage(content, tool_calls)
+            else:
+                content = response if isinstance(response, str) else getattr(response, 'content', str(response))
+                return SimpleAIMessage(content)
 
 
 # ============= 适配器管理器 =============
@@ -504,7 +563,7 @@ class AdapterManager:
         # 不应该到这里，因为有回退适配器
         return [{"role": "user", "content": str(input_data)}]
     
-    def format_response(self, response: str, original_input: Any) -> Any:
+    def format_response(self, response: Union[str, Any], original_input: Any) -> Any:
         """格式化响应"""
         for adapter in self.message_adapters:
             if adapter.can_handle(original_input):

isa_model/inference/services/llm/helpers/llm_prompts.py

@@ -164,6 +164,348 @@ class LLMPrompts:
             prompt = f"Please think step by step and answer the following question:\n\n{question}\n\nReasoning and answer:"
         return prompt
     
+    @staticmethod
+    def chain_of_thought_prompt(
+        problem: str,
+        domain: Optional[str] = None,
+        format_json: bool = False,
+        include_confidence: bool = False
+    ) -> str:
+        """Generate Chain-of-Thought reasoning prompt with structured output"""
+        
+        domain_context = ""
+        if domain:
+            domain_context = f" in the {domain} domain"
+        
+        if format_json:
+            prompt = f"""Solve the following problem{domain_context} using step-by-step reasoning.
+
+Problem: {problem}
+
+Please provide your response in the following JSON format:
+{{
+    "reasoning_steps": [
+        {{
+            "step": 1,
+            "description": "Brief description of this step",
+            "thinking": "Detailed explanation of your thought process",
+            "result": "What you conclude from this step"
+        }}
+    ],
+    "final_answer": "Your final answer",
+    "reasoning_chain": "Summary of your complete reasoning process"
+"""
+            
+            if include_confidence:
+                prompt += ',\n    "confidence_score": 0.85,\n    "confidence_explanation": "Why you have this level of confidence"'
+            
+            prompt += "\n}\n\nResponse:"
+        else:
+            prompt = f"""Solve the following problem{domain_context} using step-by-step reasoning.
+
+Problem: {problem}
+
+Please structure your response as follows:
+
+**Step-by-Step Reasoning:**
+
+Step 1: [Brief description]
+- Thinking: [Detailed explanation]
+- Result: [What you conclude]
+
+Step 2: [Brief description]
+- Thinking: [Detailed explanation]
+- Result: [What you conclude]
+
+[Continue for all steps...]
+
+**Final Answer:**
+[Your final answer]
+
+**Reasoning Summary:**
+[Brief summary of your complete reasoning process]
+"""
+
+            if include_confidence:
+                prompt += "\n**Confidence Assessment:**\n[Your confidence level and explanation]\n"
+            
+            prompt += "\nResponse:"
+        
+        return prompt
+    
+    @staticmethod
+    def tree_of_thoughts_prompt(
+        problem: str,
+        num_branches: int = 3,
+        depth_levels: int = 3,
+        format_json: bool = True
+    ) -> str:
+        """Generate Tree-of-Thoughts reasoning prompt for complex problem solving"""
+        
+        if format_json:
+            prompt = f"""Solve the following complex problem using Tree-of-Thoughts reasoning. Generate {num_branches} different approaches and evaluate them through {depth_levels} levels of thinking.
+
+Problem: {problem}
+
+Please structure your response in JSON format:
+
+{{
+    "problem_analysis": "Initial understanding and breakdown of the problem",
+    "thought_tree": [
+        {{
+            "approach": 1,
+            "initial_thought": "First approach description",
+            "levels": [
+                {{
+                    "level": 1,
+                    "thoughts": ["Thought 1", "Thought 2", "Thought 3"],
+                    "evaluations": ["Evaluation of thought 1", "Evaluation of thought 2", "Evaluation of thought 3"],
+                    "best_thought": "Selected best thought with reasoning"
+                }}
+            ],
+            "final_conclusion": "Where this approach leads",
+            "viability_score": 0.8
+        }}
+    ],
+    "best_approach": {{
+        "approach_number": 1,
+        "reasoning": "Why this approach is best",
+        "final_answer": "The solution"
+    }},
+    "alternative_solutions": ["Other possible solutions"],
+    "confidence_assessment": "Overall confidence in the solution"
+}}
+
+Response:"""
+        else:
+            prompt = f"""Solve the following complex problem using Tree-of-Thoughts reasoning. Generate {num_branches} different approaches and evaluate them through {depth_levels} levels of thinking.
+
+Problem: {problem}
+
+**Problem Analysis:**
+[Initial understanding and breakdown]
+
+**Approach 1:**
+- Initial Thought: [Description]
+- Level 1 Exploration:
+  - Thought A: [Details] → Evaluation: [Assessment]
+  - Thought B: [Details] → Evaluation: [Assessment]  
+  - Thought C: [Details] → Evaluation: [Assessment]
+  - Best: [Selected thought with reasoning]
+- [Continue for {depth_levels} levels]
+- Final Conclusion: [Where this approach leads]
+- Viability: [Score/Assessment]
+
+[Repeat for {num_branches} approaches]
+
+**Best Approach Selection:**
+- Chosen Approach: [Number and reasoning]
+- Final Answer: [Solution]
+
+**Alternative Solutions:**
+[Other viable options]
+
+**Confidence Assessment:**
+[Overall confidence and reasoning]
+
+Response:"""
+        
+        return prompt
+    
+    @staticmethod
+    def step_back_reasoning_prompt(
+        problem: str,
+        domain: Optional[str] = None,
+        include_principles: bool = True
+    ) -> str:
+        """Generate Step-Back reasoning prompt for principle-based problem solving"""
+        
+        domain_context = f" in {domain}" if domain else ""
+        
+        prompt = f"""Solve the following problem{domain_context} using step-back reasoning. First identify the underlying principles, then apply them to solve the specific problem.
+
+Problem: {problem}
+
+Please structure your response as follows:
+
+**Step 1: Step Back - Identify General Principles**
+What are the fundamental principles, concepts, or rules that apply to this type of problem?
+
+**Step 2: Connect Principles to Problem**  
+How do these general principles relate to the specific problem at hand?
+
+**Step 3: Apply Principles**
+Use the identified principles to work through the problem systematically.
+
+**Step 4: Verify Solution**
+Check if your solution aligns with the fundamental principles.
+
+**Final Answer:**
+[Your solution]
+
+"""
+        
+        if include_principles:
+            prompt += "**Principle Summary:**\n[Key principles used in solving this problem]\n\n"
+        
+        prompt += "Response:"
+        
+        return prompt
+    
+    @staticmethod
+    def analogical_reasoning_prompt(
+        problem: str,
+        include_multiple_analogies: bool = True,
+        format_structured: bool = True
+    ) -> str:
+        """Generate analogical reasoning prompt using similar problems/situations"""
+        
+        if format_structured:
+            prompt = f"""Solve the following problem using analogical reasoning. Find similar problems or situations that can guide your thinking.
+
+Problem: {problem}
+
+**Step 1: Find Analogies**
+Think of 2-3 similar problems, situations, or concepts that share structural similarities with this problem.
+
+Analogy 1: [Description]
+- Similarities: [How it's similar to the current problem]
+- Key insights: [What can be learned from this analogy]
+
+Analogy 2: [Description]
+- Similarities: [How it's similar to the current problem] 
+- Key insights: [What can be learned from this analogy]
+
+{f'''Analogy 3: [Description]
+- Similarities: [How it's similar to the current problem]
+- Key insights: [What can be learned from this analogy]''' if include_multiple_analogies else ''}
+
+**Step 2: Extract Patterns**
+What common patterns or principles emerge from these analogies?
+
+**Step 3: Apply to Current Problem**
+How can the insights from these analogies be applied to solve the current problem?
+
+**Step 4: Adapt and Refine** 
+What modifications are needed to account for differences between the analogies and current problem?
+
+**Final Answer:**
+[Your solution based on analogical reasoning]
+
+Response:"""
+        else:
+            prompt = f"""Solve this problem by thinking of similar situations: {problem}
+
+Find analogous problems or situations, extract useful patterns, and apply them here.
+
+Response:"""
+        
+        return prompt
+    
+    @staticmethod 
+    def multi_perspective_reasoning_prompt(
+        problem: str,
+        perspectives: Optional[List[str]] = None,
+        synthesis_required: bool = True
+    ) -> str:
+        """Generate multi-perspective reasoning prompt to consider different viewpoints"""
+        
+        if not perspectives:
+            perspectives = [
+                "practical/pragmatic",
+                "theoretical/analytical", 
+                "creative/innovative",
+                "critical/skeptical",
+                "ethical/moral"
+            ]
+        
+        prompt = f"""Analyze and solve the following problem from multiple perspectives to gain a comprehensive understanding.
+
+Problem: {problem}
+
+"""
+        
+        for i, perspective in enumerate(perspectives, 1):
+            prompt += f"""**Perspective {i}: {perspective.title()}**
+From this viewpoint:
+- How would you understand the problem?
+- What solution approach would you take?
+- What are the key considerations?
+- What would be your recommended action?
+
+"""
+        
+        if synthesis_required:
+            prompt += f"""**Synthesis & Integration**
+- Compare and contrast the insights from different perspectives
+- Identify areas of agreement and disagreement
+- Synthesize the best elements from each perspective
+- Develop a balanced, comprehensive solution
+
+**Final Integrated Solution:**
+[Your solution that incorporates insights from multiple perspectives]
+
+"""
+        
+        prompt += "Response:"
+        
+        return prompt
+    
+    @staticmethod
+    def metacognitive_reasoning_prompt(
+        problem: str,
+        include_strategy_selection: bool = True,
+        include_self_monitoring: bool = True
+    ) -> str:
+        """Generate metacognitive reasoning prompt with explicit thinking about thinking"""
+        
+        prompt = f"""Solve the following problem using metacognitive reasoning - explicitly think about your thinking process.
+
+Problem: {problem}
+
+"""
+        
+        if include_strategy_selection:
+            prompt += """**Strategy Selection:**
+- What type of problem is this?
+- What reasoning strategies could be effective? (logical deduction, pattern recognition, analogy, etc.)
+- Which strategy seems most promising and why?
+- What are potential pitfalls to avoid?
+
+"""
+        
+        prompt += """**Problem Solving Process:**
+Now work through the problem while monitoring your thinking:
+
+Step 1: [Your approach]
+- Metacognitive check: Is this approach working? Do I need to adjust?
+
+Step 2: [Continue reasoning] 
+- Metacognitive check: Am I on the right track? What evidence supports this?
+
+[Continue with metacognitive monitoring throughout]
+
+"""
+        
+        if include_self_monitoring:
+            prompt += """**Self-Monitoring Reflection:**
+- How confident am I in this solution?
+- What assumptions did I make?
+- How could I verify this answer?
+- What would I do differently next time?
+
+"""
+        
+        prompt += """**Final Answer:**
+[Your solution]
+
+**Meta-Analysis:**
+[Reflection on your reasoning process and what you learned about your own thinking]
+
+Response:"""
+        
+        return prompt
+    
     @staticmethod
     def problem_solving_prompt(problem: str, problem_type: Optional[str] = None) -> str:
         """生成问题求解提示词"""