Multi-Provider Reasoning Engine

import aisuite as ai
from typing import List, Dict, Any

class MultiProviderReasoning:
    """Use different models for different reasoning steps"""
    
    def __init__(self):
        self.client = ai.Client()
        # Assign models to specific tasks based on strengths
        self.models = {
            "decomposition": "anthropic:claude-3-sonnet",  # Good at breaking down problems
            "calculation": "openai:gpt-4",                  # Strong at math
            "verification": "google:gemini-pro",            # Double-check results
            "synthesis": "anthropic:claude-3-opus"          # Final answer synthesis
        }
    
    def solve_problem(self, problem: str) -> Dict[str, Any]:
        """Solve complex problem using multiple models"""
        
        steps = {}
        
        # Step 1: Problem decomposition
        print("🔍 Decomposing problem...")
        decomposition_prompt = f"""Break down this problem into clear steps:
        {problem}
        
        List each step needed to solve this problem."""
        
        steps["decomposition"] = self.client.chat.completions.create(
            model=self.models["decomposition"],
            messages=[{"role": "user", "content": decomposition_prompt}]
        ).choices[0].message.content
        
        # Step 2: Execute calculations/logic
        print("🧮 Executing calculations...")
        calculation_prompt = f"""Given this problem breakdown:
        {steps['decomposition']}
        
        Original problem: {problem}
        
        Please execute each step and show your work."""
        
        steps["calculation"] = self.client.chat.completions.create(
            model=self.models["calculation"],
            messages=[{"role": "user", "content": calculation_prompt}]
        ).choices[0].message.content
        
        # Step 3: Verify the solution
        print("✅ Verifying solution...")
        verification_prompt = f"""Please verify this solution:
        
        Problem: {problem}
        Solution: {steps['calculation']}
        
        Check for errors and confirm if the solution is correct."""
        
        steps["verification"] = self.client.chat.completions.create(
            model=self.models["verification"],
            messages=[{"role": "user", "content": verification_prompt}]
        ).choices[0].message.content
        
        # Step 4: Synthesize final answer
        print("📝 Synthesizing final answer...")
        synthesis_prompt = f"""Based on the following analysis:
        
        Problem decomposition: {steps['decomposition']}
        Calculations: {steps['calculation']}
        Verification: {steps['verification']}
        
        Provide a clear, concise final answer to: {problem}"""
        
        steps["final_answer"] = self.client.chat.completions.create(
            model=self.models["synthesis"],
            messages=[{"role": "user", "content": synthesis_prompt}]
        ).choices[0].message.content
        
        return steps

# Example usage
reasoner = MultiProviderReasoning()

problem = """A train leaves Station A at 9:00 AM traveling at 60 mph. 
Another train leaves Station B at 10:00 AM traveling at 80 mph toward Station A. 
If the stations are 280 miles apart, when and where will the trains meet?"""

solution = reasoner.solve_problem(problem)

print("\n🎯 FINAL ANSWER:")
print(solution["final_answer"])