Build a Complete Agent & Subagent System

mkdir ucc-agent && cd ucc-agent
python -m venv venv
# macOS/Linux:
source venv/bin/activate
# Windows:
# venv\Scripts\activate
pip install "anthropic>=0.30.0"
export ANTHROPIC_API_KEY=your-key-here
# Windows: set ANTHROPIC_API_KEY=your-key-here

anthropic>=0.30.0

# mock_data.py — Realistic UCC filing records for testing
# Each filing represents a real-world lien: a lender's claim on a borrower's assets.

UCC_FILINGS = [
    {
        "filing_number": "NY-2024-001234",
        "state": "NY",
        "debtor_name": "Acme Corporation",
        "debtor_id": "ACME-001",
        "secured_party": "First National Bank",
        "collateral_description": "All inventory, equipment, and accounts receivable",
        "filing_date": "2024-01-15",
        "lapse_date": "2029-01-15",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 2500000
    },
    {
        "filing_number": "NY-2024-005678",
        "state": "NY",
        "debtor_name": "Acme Corporation",
        "debtor_id": "ACME-001",
        "secured_party": "Silicon Valley Lending Group",
        "collateral_description": "All intellectual property, patents, and trademarks",
        "filing_date": "2024-03-22",
        "lapse_date": "2029-03-22",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 4000000
    },
    {
        "filing_number": "TX-2023-009876",
        "state": "TX",
        "debtor_name": "Acme Corporation",
        "debtor_id": "ACME-001",
        "secured_party": "Lone Star Capital",
        "collateral_description": "Equipment and machinery at 456 Industrial Blvd, Houston TX",
        "filing_date": "2023-11-01",
        "lapse_date": "2028-11-01",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 1800000
    },
    {
        "filing_number": "CA-2024-003456",
        "state": "CA",
        "debtor_name": "Pacific Rim Trading LLC",
        "debtor_id": "PRT-002",
        "secured_party": "West Coast Venture Fund",
        "collateral_description": "All assets including inventory, accounts, and general intangibles",
        "filing_date": "2024-02-10",
        "lapse_date": "2029-02-10",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 8500000
    },
    {
        "filing_number": "CA-2023-007890",
        "state": "CA",
        "debtor_name": "Pacific Rim Trading LLC",
        "debtor_id": "PRT-002",
        "secured_party": "Bank of the West",
        "collateral_description": "Accounts receivable and deposit accounts",
        "filing_date": "2023-06-15",
        "lapse_date": "2028-06-15",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 3200000
    },
    {
        "filing_number": "FL-2024-002345",
        "state": "FL",
        "debtor_name": "Sunshine Medical Devices Inc",
        "debtor_id": "SMD-003",
        "secured_party": "Atlantic Health Finance",
        "collateral_description": "Medical equipment, FDA-approved devices, and related inventory",
        "filing_date": "2024-04-01",
        "lapse_date": "2029-04-01",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 5600000
    },
    {
        "filing_number": "IL-2023-004567",
        "state": "IL",
        "debtor_name": "Midwest Manufacturing Group",
        "debtor_id": "MMG-004",
        "secured_party": "Great Lakes Commercial Bank",
        "collateral_description": "All equipment, fixtures, and inventory at 789 Factory Lane, Chicago IL",
        "filing_date": "2023-09-20",
        "lapse_date": "2028-09-20",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 6200000
    },
    {
        "filing_number": "IL-2024-006789",
        "state": "IL",
        "debtor_name": "Midwest Manufacturing Group",
        "debtor_id": "MMG-004",
        "secured_party": "Industrial Credit Corp",
        "collateral_description": "Accounts receivable, contract rights, and general intangibles",
        "filing_date": "2024-01-30",
        "lapse_date": "2029-01-30",
        "filing_type": "Amendment",
        "status": "Active",
        "collateral_value_estimate": 2100000
    },
    {
        "filing_number": "NY-2022-008901",
        "state": "NY",
        "debtor_name": "Empire State Logistics Corp",
        "debtor_id": "ESL-005",
        "secured_party": "Manhattan Commercial Lending",
        "collateral_description": "Fleet vehicles, transportation equipment, and warehouse inventory",
        "filing_date": "2022-07-12",
        "lapse_date": "2027-07-12",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 3800000
    },
    {
        "filing_number": "TX-2024-001111",
        "state": "TX",
        "debtor_name": "Gulf Energy Solutions LLC",
        "debtor_id": "GES-006",
        "secured_party": "Texas Energy Capital Partners",
        "collateral_description": "Oil and gas equipment, pipelines, and related fixtures",
        "filing_date": "2024-05-18",
        "lapse_date": "2029-05-18",
        "filing_type": "Original",
        "status": "Active",
        "collateral_value_estimate": 12000000
    }
]


def search_filings_data(debtor_name, state=None):
    """Search filings by debtor name (case-insensitive partial match).
    Optionally filter by state code."""
    query = debtor_name.lower()
    results = []
    for filing in UCC_FILINGS:
        if query in filing["debtor_name"].lower():
            if state is None or filing["state"].upper() == state.upper():
                results.append(filing)
    return results


def get_filing_by_number(filing_number):
    """Look up a single filing by its filing number."""
    for filing in UCC_FILINGS:
        if filing["filing_number"] == filing_number:
            return filing
    return None


def calculate_risk(debtor_id):
    """Calculate a risk score for an entity based on their filings.
    Returns a score from 0.0 (low risk) to 1.0 (high risk)."""
    entity_filings = [f for f in UCC_FILINGS if f["debtor_id"] == debtor_id]

    if not entity_filings:
        return {
            "debtor_id": debtor_id,
            "risk_score": 0.0,
            "risk_level": "UNKNOWN",
            "filing_count": 0,
            "total_collateral_value": 0,
            "factors": ["No filings found for this entity"],
            "recommendation": "No data available for risk assessment."
        }

    filing_count = len(entity_filings)
    total_value = sum(f["collateral_value_estimate"] for f in entity_filings)
    states = list(set(f["state"] for f in entity_filings))
    secured_parties = list(set(f["secured_party"] for f in entity_filings))

    # Risk scoring logic
    score = 0.0
    factors = []

    # More filings = higher risk
    if filing_count >= 3:
        score += 0.3
        factors.append(f"High filing count ({filing_count} active filings)")
    elif filing_count >= 2:
        score += 0.15
        factors.append(f"Multiple filings ({filing_count} active filings)")

    # High total collateral = higher risk
    if total_value > 5000000:
        score += 0.25
        factors.append(f"High collateral exposure (${total_value:,.0f})")
    elif total_value > 2000000:
        score += 0.1
        factors.append(f"Moderate collateral exposure (${total_value:,.0f})")

    # Multiple secured parties = higher risk
    if len(secured_parties) >= 3:
        score += 0.2
        factors.append(f"Multiple secured parties ({len(secured_parties)} lenders)")
    elif len(secured_parties) >= 2:
        score += 0.1
        factors.append(f"Two secured parties involved")

    # Multi-state filings = higher complexity
    if len(states) >= 2:
        score += 0.15
        factors.append(f"Multi-state filings ({', '.join(states)})")

    score = min(score, 1.0)

    if score >= 0.6:
        risk_level = "HIGH"
        recommendation = "Thorough due diligence required. Multiple liens across jurisdictions indicate significant financial obligations."
    elif score >= 0.3:
        risk_level = "MEDIUM"
        recommendation = "Standard due diligence recommended. Some lien exposure exists but appears manageable."
    else:
        risk_level = "LOW"
        recommendation = "Minimal lien exposure. Standard review sufficient."

    return {
        "debtor_id": debtor_id,
        "risk_score": round(score, 2),
        "risk_level": risk_level,
        "filing_count": filing_count,
        "total_collateral_value": total_value,
        "states_involved": states,
        "secured_parties": secured_parties,
        "factors": factors,
        "recommendation": recommendation
    }

# tools.py — Tool definitions for Claude to use
# Each tool has: a JSON Schema definition + an execute function.

import json
from mock_data import search_filings_data, get_filing_by_number, calculate_risk

# --------------------------------------------------
# TOOL SCHEMAS — These tell Claude what tools exist,
# what parameters they accept, and what they return.
# Claude reads these schemas and decides which tool
# to call based on the user's question.
# --------------------------------------------------

TOOL_DEFINITIONS = [
    {
        "name": "search_filings",
        "description": "Search UCC filings by debtor (company) name. Optionally filter by US state code. Returns a list of matching filing records with basic details.",
        "input_schema": {
            "type": "object",
            "properties": {
                "debtor_name": {
                    "type": "string",
                    "description": "The company or person name to search for. Partial matches work (e.g., 'Acme' matches 'Acme Corporation')."
                },
                "state": {
                    "type": "string",
                    "description": "Optional two-letter US state code to filter results (e.g., 'NY', 'CA', 'TX'). If omitted, searches all states.",
                    "enum": ["NY", "CA", "TX", "FL", "IL"]
                }
            },
            "required": ["debtor_name"]
        }
    },
    {
        "name": "get_filing_details",
        "description": "Get full details for a specific UCC filing by its filing number. Returns all fields including collateral description, secured party, dates, and estimated value.",
        "input_schema": {
            "type": "object",
            "properties": {
                "filing_number": {
                    "type": "string",
                    "description": "The unique filing number (e.g., 'NY-2024-001234')."
                }
            },
            "required": ["filing_number"]
        }
    },
    {
        "name": "check_risk_score",
        "description": "Calculate a risk score for a business entity based on their UCC filing history. Returns a score from 0.0 (low) to 1.0 (high), risk level, contributing factors, and a recommendation.",
        "input_schema": {
            "type": "object",
            "properties": {
                "debtor_id": {
                    "type": "string",
                    "description": "The unique entity identifier (e.g., 'ACME-001'). Get this from search_filings results."
                }
            },
            "required": ["debtor_id"]
        }
    }
]


def execute_tool(tool_name, tool_input):
    """Execute a tool call and return the result as a string.
    Handles errors gracefully — never crashes, always returns
    a structured response that Claude can understand."""
    try:
        if tool_name == "search_filings":
            debtor_name = tool_input["debtor_name"]
            state = tool_input.get("state", None)
            results = search_filings_data(debtor_name, state)

            if not results:
                return json.dumps({
                    "status": "no_results",
                    "message": f"No UCC filings found for '{debtor_name}'" + (f" in {state}" if state else ""),
                    "filings": [],
                    "count": 0
                })

            # Return summary for each filing (not full details)
            summaries = []
            for f in results:
                summaries.append({
                    "filing_number": f["filing_number"],
                    "state": f["state"],
                    "debtor_name": f["debtor_name"],
                    "debtor_id": f["debtor_id"],
                    "secured_party": f["secured_party"],
                    "filing_date": f["filing_date"],
                    "status": f["status"],
                    "collateral_value_estimate": f["collateral_value_estimate"]
                })

            return json.dumps({
                "status": "success",
                "count": len(summaries),
                "filings": summaries
            })

        elif tool_name == "get_filing_details":
            filing_number = tool_input["filing_number"]
            result = get_filing_by_number(filing_number)

            if result is None:
                return json.dumps({
                    "status": "not_found",
                    "message": f"No filing found with number '{filing_number}'",
                    "filing": None
                })

            return json.dumps({
                "status": "success",
                "filing": result
            })

        elif tool_name == "check_risk_score":
            debtor_id = tool_input["debtor_id"]
            result = calculate_risk(debtor_id)
            return json.dumps({
                "status": "success",
                "risk_assessment": result
            })

        else:
            return json.dumps({
                "status": "error",
                "message": f"Unknown tool: {tool_name}"
            })

    except Exception as e:
        return json.dumps({
            "status": "error",
            "message": f"Tool execution failed: {str(e)}"
        })

# single_agent.py — A single agent with all tools (baseline)
# This uses the ReAct pattern from M12: Reason → Act → Observe → Repeat

import os
import sys
import json
import anthropic
from tools import TOOL_DEFINITIONS, execute_tool

# Initialize the client — reads ANTHROPIC_API_KEY from environment
client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"

SYSTEM_PROMPT = """You are a UCC filing research assistant. You help users investigate
Uniform Commercial Code filings — these are public records that show when a lender
has a security interest (lien) in a company's assets.

You have three tools available:
1. search_filings — Find filings by company name, optionally filtered by state
2. get_filing_details — Get full details for a specific filing number
3. check_risk_score — Calculate a risk assessment for a company based on their filings

Always search for filings first before calculating risk scores, so you have context
about the entity. When presenting results, be specific — cite filing numbers, dates,
and dollar amounts. If a search returns no results, tell the user clearly."""


def run_agent(user_message, max_turns=10):
    """Run the agent loop until Claude is done or we hit max_turns.

    The loop works like this:
    1. Send the user message + tool definitions to Claude
    2. Check stop_reason: if 'tool_use', execute the tools and continue
    3. If 'end_turn', Claude is done — return the final response
    4. Safety net: stop after max_turns to prevent infinite loops
    """
    print(f"\n{'='*60}")
    print(f"User: {user_message}")
    print(f"{'='*60}")

    messages = [{"role": "user", "content": user_message}]

    for turn in range(max_turns):
        try:
            response = client.messages.create(
                model=MODEL,
                max_tokens=4096,
                system=SYSTEM_PROMPT,
                tools=TOOL_DEFINITIONS,
                messages=messages
            )
        except anthropic.APIError as e:
            print(f"\nAPI Error: {e}")
            return None

        # Check if Claude wants to use tools
        if response.stop_reason == "tool_use":
            # Extract all tool use blocks from the response
            tool_results = []
            assistant_content = response.content

            for block in response.content:
                if block.type == "tool_use":
                    tool_name = block.name
                    tool_input = block.input
                    tool_id = block.id

                    print(f"\n  [Tool Call] {tool_name}({json.dumps(tool_input)})")

                    # Execute the tool
                    result = execute_tool(tool_name, tool_input)
                    print(f"  [Tool Result] {result[:150]}...")

                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": tool_id,
                        "content": result
                    })

            # Append assistant message + tool results to conversation
            messages.append({"role": "assistant", "content": assistant_content})
            messages.append({"role": "user", "content": tool_results})

        elif response.stop_reason == "end_turn":
            # Claude is done — extract the final text response
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text += block.text

            print(f"\nAssistant: {final_text}")
            return final_text

        else:
            print(f"\nUnexpected stop_reason: {response.stop_reason}")
            return None

    print(f"\nWarning: Reached max turns ({max_turns}) without completion.")
    return None


if __name__ == "__main__":
    # Default query or use command-line argument
    query = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "Find all UCC filings for Acme Corporation"
    run_agent(query)

# subagents.py — Specialized subagents with focused tool sets
# Each subagent runs its own ReAct loop with isolated context.

import json
import anthropic
from tools import execute_tool

client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"

# --------------------------------------------------
# RESEARCH SUBAGENT
# Tools: search_filings, get_filing_details
# Purpose: Find and gather information about UCC filings
# --------------------------------------------------

RESEARCH_TOOLS = [
    {
        "name": "search_filings",
        "description": "Search UCC filings by debtor name. Optionally filter by state code.",
        "input_schema": {
            "type": "object",
            "properties": {
                "debtor_name": {
                    "type": "string",
                    "description": "Company name to search for. Partial matches work."
                },
                "state": {
                    "type": "string",
                    "description": "Optional two-letter state code.",
                    "enum": ["NY", "CA", "TX", "FL", "IL"]
                }
            },
            "required": ["debtor_name"]
        }
    },
    {
        "name": "get_filing_details",
        "description": "Get full details for a specific filing by number.",
        "input_schema": {
            "type": "object",
            "properties": {
                "filing_number": {
                    "type": "string",
                    "description": "The unique filing number (e.g., 'NY-2024-001234')."
                }
            },
            "required": ["filing_number"]
        }
    }
]

RESEARCH_SYSTEM = """You are a UCC filing research specialist. Your ONLY job is to search
for and retrieve UCC filing records. You have two tools: search_filings and get_filing_details.

When given a research task:
1. Search for filings matching the debtor name and optional state filter
2. If needed, get full details for specific filings
3. Return a structured summary of what you found

Always return your findings as a JSON object with this structure:
{"filings_found": [...], "total_count": N, "states_searched": [...], "summary": "..."}

Be thorough but focused. Do NOT try to analyze risk — that is another specialist's job."""


def run_research_subagent(task_description, max_turns=6):
    """Run the research subagent with a focused task.

    Args:
        task_description: What to research (e.g., "Find all filings for Acme Corporation")
        max_turns: Safety limit on tool call rounds

    Returns:
        dict with research results, or error dict
    """
    messages = [{"role": "user", "content": task_description}]

    for turn in range(max_turns):
        try:
            response = client.messages.create(
                model=MODEL,
                max_tokens=2048,
                system=RESEARCH_SYSTEM,
                tools=RESEARCH_TOOLS,
                messages=messages
            )
        except anthropic.APIError as e:
            return {"status": "error", "message": f"Research subagent API error: {str(e)}"}

        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        elif response.stop_reason == "end_turn":
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text += block.text

            # Try to parse as JSON, fall back to text
            try:
                return {"status": "success", "data": json.loads(final_text)}
            except json.JSONDecodeError:
                return {"status": "success", "data": {"summary": final_text}}
        else:
            return {"status": "error", "message": f"Unexpected stop: {response.stop_reason}"}

    return {"status": "error", "message": "Research subagent reached max turns"}


# --------------------------------------------------
# ANALYSIS SUBAGENT (Step 6 — added next)
# --------------------------------------------------

ANALYSIS_TOOLS = [
    {
        "name": "check_risk_score",
        "description": "Calculate risk score for an entity based on UCC filing history.",
        "input_schema": {
            "type": "object",
            "properties": {
                "debtor_id": {
                    "type": "string",
                    "description": "Entity identifier (e.g., 'ACME-001')."
                }
            },
            "required": ["debtor_id"]
        }
    }
]

ANALYSIS_SYSTEM = """You are a UCC filing risk analysis specialist. Your ONLY job is to
analyze risk based on UCC filing data provided to you.

You have one tool: check_risk_score. Use it with the debtor_id provided in your task.

You will receive context about the entity's filings from the research team. Use that
context plus the risk score tool to produce a complete risk assessment.

Return your analysis as a JSON object:
{"risk_score": 0.X, "risk_level": "HIGH/MEDIUM/LOW", "factors": [...],
 "recommendation": "...", "filing_context": "..."}

Be specific and quantitative. Cite dollar amounts and filing counts."""


def run_analysis_subagent(task_description, max_turns=4):
    """Run the analysis subagent with filing context and a risk assessment task.

    Args:
        task_description: What to analyze, including context from research subagent
        max_turns: Safety limit

    Returns:
        dict with analysis results, or error dict
    """
    messages = [{"role": "user", "content": task_description}]

    for turn in range(max_turns):
        try:
            response = client.messages.create(
                model=MODEL,
                max_tokens=2048,
                system=ANALYSIS_SYSTEM,
                tools=ANALYSIS_TOOLS,
                messages=messages
            )
        except anthropic.APIError as e:
            return {"status": "error", "message": f"Analysis subagent API error: {str(e)}"}

        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        elif response.stop_reason == "end_turn":
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text += block.text
            try:
                return {"status": "success", "data": json.loads(final_text)}
            except json.JSONDecodeError:
                return {"status": "success", "data": {"summary": final_text}}
        else:
            return {"status": "error", "message": f"Unexpected stop: {response.stop_reason}"}

    return {"status": "error", "message": "Analysis subagent reached max turns"}

# coordinator.py — The coordinator agent that delegates to subagents
# This is the hub-and-spoke pattern from M14.

import os
import sys
import json
import anthropic
from subagents import run_research_subagent, run_analysis_subagent

client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"

# --------------------------------------------------
# The coordinator does NOT have filing tools. Instead,
# it has "meta-tools" that invoke subagents. This is
# the key architectural insight: the coordinator's
# tools are OTHER AGENTS, not database queries.
# --------------------------------------------------

COORDINATOR_TOOLS = [
    {
        "name": "research_filings",
        "description": "Delegate to the filing research specialist. Use this to search for UCC filings by company name, optionally filtered by state. The research team will search and return structured results.",
        "input_schema": {
            "type": "object",
            "properties": {
                "task": {
                    "type": "string",
                    "description": "A clear research task, e.g., 'Find all UCC filings for Acme Corporation in New York'. Be specific about what to search for."
                }
            },
            "required": ["task"]
        }
    },
    {
        "name": "analyze_risk",
        "description": "Delegate to the risk analysis specialist. Use this AFTER research_filings when you have filing context. Provide the debtor_id and a summary of what research found.",
        "input_schema": {
            "type": "object",
            "properties": {
                "task": {
                    "type": "string",
                    "description": "Analysis task with context. MUST include the debtor_id and a summary of known filings. Example: 'Analyze risk for ACME-001. They have 3 filings across NY and TX totaling $8.3M.'"
                }
            },
            "required": ["task"]
        }
    }
]

COORDINATOR_SYSTEM = """You are the lead coordinator for a UCC filing research team.
You do NOT search filings or calculate risk yourself. Instead, you delegate to specialists:

1. research_filings — Searches for UCC filings by company name/state
2. analyze_risk — Calculates risk scores (use AFTER research, include context)

Your workflow for a typical question:
1. Use research_filings to find relevant filings
2. Review the research results
3. If risk analysis is needed, use analyze_risk with the debtor_id and filing context
4. Synthesize all results into a clear, specific answer for the user

IMPORTANT: When calling analyze_risk, you MUST include the debtor_id and a summary
of the research findings in the task description. The analysis specialist does NOT
have access to the research results — you must pass them explicitly.

Be specific in your answers. Cite filing numbers, dates, dollar amounts, and risk scores."""


def execute_coordinator_tool(tool_name, tool_input):
    """Execute a coordinator tool by delegating to the appropriate subagent."""
    task = tool_input["task"]

    if tool_name == "research_filings":
        print(f"  [Coordinator -> Research] {task[:80]}...")
        result = run_research_subagent(task)
        print(f"  [Research -> Coordinator] status={result['status']}")
        return json.dumps(result)

    elif tool_name == "analyze_risk":
        print(f"  [Coordinator -> Analysis] {task[:80]}...")
        result = run_analysis_subagent(task)
        print(f"  [Analysis -> Coordinator] status={result['status']}")
        return json.dumps(result)

    else:
        return json.dumps({"status": "error", "message": f"Unknown tool: {tool_name}"})


def run_coordinator(user_message, conversation_history=None, max_turns=8):
    """Run the coordinator agent with optional conversation history.

    Args:
        user_message: The user's question
        conversation_history: List of previous messages for multi-turn context
        max_turns: Safety limit on delegation rounds

    Returns:
        tuple of (response_text, updated_conversation_history)
    """
    print(f"\n{'='*60}")
    print(f"User: {user_message}")
    print(f"{'='*60}")

    if conversation_history is None:
        conversation_history = []

    # Add the new user message
    conversation_history.append({"role": "user", "content": user_message})

    # Work with a copy for the API calls
    messages = list(conversation_history)

    for turn in range(max_turns):
        try:
            response = client.messages.create(
                model=MODEL,
                max_tokens=4096,
                system=COORDINATOR_SYSTEM,
                tools=COORDINATOR_TOOLS,
                messages=messages
            )
        except anthropic.APIError as e:
            error_msg = f"Coordinator error: {str(e)}"
            print(f"\n{error_msg}")
            return error_msg, conversation_history

        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = execute_coordinator_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})

        elif response.stop_reason == "end_turn":
            final_text = ""
            for block in response.content:
                if hasattr(block, "text"):
                    final_text += block.text

            # Save the final exchange to conversation history
            conversation_history.append({"role": "assistant", "content": final_text})

            print(f"\nAssistant: {final_text}")
            return final_text, conversation_history

        else:
            msg = f"Unexpected stop: {response.stop_reason}"
            print(f"\n{msg}")
            return msg, conversation_history

    msg = f"Warning: Reached max turns ({max_turns})"
    print(f"\n{msg}")
    return msg, conversation_history


if __name__ == "__main__":
    query = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "What is the lien exposure for Acme Corporation?"
    run_coordinator(query)

# test_multiturn.py — Test multi-turn conversation with the coordinator
# This verifies that conversation history is maintained across turns.

from coordinator import run_coordinator

# Turn 1: Initial question
print("=== Turn 1 ===")
response1, history = run_coordinator(
    "Find all UCC filings for Acme Corporation"
)

# Turn 2: Follow-up question (uses context from Turn 1)
# The coordinator should understand "their" refers to Acme Corporation
print("\n=== Turn 2 ===")
response2, history = run_coordinator(
    "What about their filings in Texas specifically?",
    conversation_history=history
)

# Turn 3: Risk analysis (builds on previous turns)
print("\n=== Turn 3 ===")
response3, history = run_coordinator(
    "Based on what you found, what is their overall risk level?",
    conversation_history=history
)

print("\n=== Conversation Complete ===")
print(f"Turns completed: 3")
print(f"History length: {len(history)} messages")

# test_system.py — End-to-end test scenarios for the multi-agent system

import json
from coordinator import run_coordinator

def run_test(name, query, check_fn):
    """Run a single test and report pass/fail."""
    print(f"\n{'='*60}")
    print(f"TEST: {name}")
    print(f"{'='*60}")
    try:
        response, _ = run_coordinator(query)
        if response is None:
            print(f"  FAIL: No response returned")
            return False
        passed = check_fn(response)
        status = "PASS" if passed else "FAIL"
        print(f"\n  Result: {status}")
        return passed
    except Exception as e:
        print(f"  FAIL: Exception — {str(e)}")
        return False


def main():
    results = []

    # Test 1: Happy path — search by company name
    results.append(run_test(
        "Search by company name",
        "Find all UCC filings for Acme Corporation",
        lambda r: "acme" in r.lower() and ("filing" in r.lower() or "NY" in r)
    ))

    # Test 2: Happy path — search with state filter
    results.append(run_test(
        "Search with state filter",
        "Find UCC filings for Pacific Rim Trading in California",
        lambda r: "pacific" in r.lower() and "CA" in r
    ))

    # Test 3: Happy path — risk analysis
    results.append(run_test(
        "Risk analysis for known entity",
        "What is the risk level for Acme Corporation?",
        lambda r: any(word in r.upper() for word in ["HIGH", "RISK", "SCORE"])
    ))

    # Test 4: Edge case — entity with no filings
    results.append(run_test(
        "Search for non-existent entity",
        "Find filings for XYZ Phantom Corp",
        lambda r: "no" in r.lower() or "not found" in r.lower() or "0" in r
    ))

    # Test 5: Happy path — specific state search
    results.append(run_test(
        "Single-state filing search",
        "Show me all UCC filings in Illinois",
        lambda r: "midwest" in r.lower() or "IL" in r or "illinois" in r.lower()
    ))

    # Summary
    passed = sum(results)
    total = len(results)
    print(f"\n{'='*60}")
    print(f"TEST RESULTS: {passed}/{total} passed")
    print(f"{'='*60}")


if __name__ == "__main__":
    main()