Agentic Loops with max_turns

import aisuite as ai

def search_web(query: str):
    """Search the web for information."""
    # Simulate web search
    return f"Results for: {query}"

def summarize_text(text: str, max_words: int = 100):
    """Summarize text to specified length."""
    # Your summarization logic
    return f"Summary of {len(text)} chars in {max_words} words"

def save_to_file(filename: str, content: str):
    """Save content to a file."""
    with open(filename, 'w') as f:
        f.write(content)
    return f"Saved to {filename}"

client = ai.Client()

# Create a research agent that can search, summarize, and save
response = client.chat.completions.create(
    model="openai:gpt-4o",
    messages=[{
        "role": "user",
        "content": "Research the latest developments in quantum computing, "
                   "summarize the findings, and save to quantum_research.txt"
    }],
    tools=[search_web, summarize_text, save_to_file],
    max_turns=5  # Allow up to 5 tool interactions
)

print(response.choices[0].message.content)

# View the agent's workflow
print("\nAgent workflow:")
for msg in response.choices[0].intermediate_messages:
    if hasattr(msg, 'tool_calls'):
        for call in msg.tool_calls:
            print(f"→ Called {call.function.name}({call.function.arguments})")

import aisuite as ai
import json

def load_data(file_path: str):
    """Load data from a CSV or JSON file."""
    # Implementation to load data
    return {"rows": 1000, "columns": ["date", "sales", "region"]}

def analyze_data(data: dict, analysis_type: str):
    """Perform statistical analysis on data."""
    # Your analysis logic
    return {"mean": 45.2, "std": 12.3, "trend": "increasing"}

def create_visualization(data: dict, chart_type: str):
    """Create a data visualization."""
    # Visualization logic
    return f"Created {chart_type} chart"

def generate_report(analysis: dict, charts: list):
    """Generate a comprehensive report."""
    return f"Report with {len(analysis)} analyses and {len(charts)} charts"

client = ai.Client()

# Data analysis agent
response = client.chat.completions.create(
    model="anthropic:claude-3-5-sonnet-20240620",
    messages=[{
        "role": "user",
        "content": "Analyze the sales data in sales_2024.csv, "
                   "create visualizations, and generate a report"
    }],
    tools=[load_data, analyze_data, create_visualization, generate_report],
    max_turns=6  # Complex workflow needs more turns
)

# The agent autonomously:
# 1. Loads the data
# 2. Performs multiple analyses
# 3. Creates appropriate visualizations
# 4. Generates a comprehensive report

import aisuite as ai

def run_code(code: str):
    """Execute Python code and return output."""
    try:
        exec_globals = {}
        exec(code, exec_globals)
        return "Code executed successfully"
    except Exception as e:
        return f"Error: {str(e)}"

def fix_code(code: str, error: str):
    """Attempt to fix code based on error message."""
    # Simple fix logic - in practice, could be more sophisticated
    if "NameError" in error:
        return code.replace("print", "print")  # Example fix
    return code

def test_code(code: str, test_cases: list):
    """Run test cases against code."""
    passed = 0
    for test in test_cases:
        # Test logic here
        passed += 1
    return f"{passed}/{len(test_cases)} tests passed"

client = ai.Client()

# Self-improving code agent
response = client.chat.completions.create(
    model="openai:gpt-4o",
    messages=[{
        "role": "user",
        "content": "Write a function to calculate fibonacci numbers, "
                   "test it, and fix any issues until all tests pass"
    }],
    tools=[run_code, fix_code, test_code],
    max_turns=10  # Allow iteration until solution works
)

# Access all intermediate messages
for msg in response.choices[0].intermediate_messages:
    if hasattr(msg, 'role'):
        print(f"{msg.role}: {msg.content[:100]}...")
    if hasattr(msg, 'tool_calls'):
        for call in msg.tool_calls:
            print(f"Tool: {call.function.name}")
            print(f"Args: {call.function.arguments}")
    if hasattr(msg, 'tool_call_id'):
        print(f"Tool Result: {msg.content}")