Agent Errors

from agentica import magic

@magic()
def extract_date(text: str) -> tuple[int, int, int] | None:
    """
    Extract date in YYYY-MM-DD format.
    Return None if no date found.
    """
    ...

try:
    date = extract_date(document)
    if date is None:
        # Handle missing date
        date = "unknown"
except Exception as e:
    logger.error(f"Failed to extract date: {e}")
    # Fallback logic

from dataclasses import dataclass
from agentica import magic

@dataclass
class Price:
    amount: float
    currency: str

    def __post_init__(self):
        if self.amount < 0:
            raise ValueError("Price must be positive")
        if self.currency not in ['USD', 'EUR', 'GBP']:
            raise ValueError(f"Unsupported currency: {self.currency}")

@magic()
def extract_price(text: str) -> Price:
    """Extract price from text."""
    ...

from agentica import magic

@magic()
def generate_migration(schema_old: dict, schema_new: dict) -> str:
    """
    Generate a SQL migration script to transform the old schema to the new one.
    Handle complex cases like:
    - Column renames (detect via similarity, not just adds/drops)
    - Data type changes with appropriate conversions
    - Foreign key updates
    - Index optimizations
    Return valid SQL that preserves data.
    """
    ...

def generate_basic_migration(schema_old: dict, schema_new: dict) -> str:
    """Generate simple ADD/DROP column migration without smart renames."""
    old_cols = set(schema_old.get('columns', []))
    new_cols = set(schema_new.get('columns', []))

    added = new_cols - old_cols
    dropped = old_cols - new_cols

    sql_lines = []
    table = schema_new.get('table_name', 'table')

    for col in dropped:
        sql_lines.append(f"ALTER TABLE {table} DROP COLUMN {col};")
    for col in added:
        sql_lines.append(f"ALTER TABLE {table} ADD COLUMN {col} VARCHAR(255);")

    return "\n".join(sql_lines) if sql_lines else "-- No changes detected"

def create_migration(schema_old: dict, schema_new: dict) -> str:
    """Generate migration with AI, fallback to basic diff."""
    try:
        migration = generate_migration(schema_old, schema_new)
        logger.info("Generated smart migration with AI")
        return migration
    except Exception as e:
        logger.warning(f"AI migration generation failed: {e}, using basic diff")
        return generate_basic_migration(schema_old, schema_new)

from dataclasses import dataclass
from agentica import magic

@dataclass
class ShippingAddress:
    name: str
    street: str
    city: str
    state: str
    zip_code: str
    country: str

@magic()
def extract_validated_address(text: str) -> ShippingAddress:
    """
    Extract complete shipping address with ALL required fields.
    Fields: name, street, city, state, zip_code, country
    Raise an error if ANY field is missing from the text.
    """
    ...

@magic()
def extract_partial_address(text: str) -> ShippingAddress | None:
    """
    Extract shipping address. Return None if no address is found.
    Fill in 'unknown' for any missing fields.
    """
    ...

@magic()
def extract_location_mentions(text: str) -> str:
    """
    Extract any location information mentioned (city, state, country, etc).
    Return as a simple string description of what was found.
    """
    ...

def process_shipping_info(text: str) -> dict:
    """Extract shipping information with fallback levels."""

    # Try complete validated extraction
    try:
        address = extract_validated_address(text)
        logger.info("Complete shipping address extracted")
        return {"address": address, "completeness": "complete"}
    except Exception as e:
        logger.warning(f"Complete address extraction failed: {e}")

    # Try partial extraction
    try:
        address = extract_partial_address(text)
        if address:
            logger.warning("Partial address extracted, manual review needed")
            return {"address": address, "completeness": "partial"}
        else:
            logger.warning("No structured address found")
    except Exception as e:
        logger.error(f"Partial address extraction failed: {e}")

    # Final fallback - just get location mentions
    location_text = extract_location_mentions(text)
    logger.error("Could not extract structured address, only location mentions")
    return {"address": None, "location_text": location_text, "completeness": "minimal"}