Prompting

@agentic()
async def summarize(text: str) -> str:
    """Summarize the text"""
    ...

@agentic()
async def summarize(text: str) -> str:
    """
    Create a 2-3 sentence summary of the text.
    Focus on the main argument and key supporting points.
    Use objective language without opinion.
    """
    ...

@agentic()
async def extract_sql(user_request: str, schema: dict) -> str:
    """
    Generate a SQL query from the user's natural language request.

    Requirements:
    - Use only SELECT statements (no INSERT, UPDATE, DELETE)
    - Always include LIMIT clauses to prevent large result sets
    - Use table aliases for readability
    - When joining tables, prefer INNER JOIN over implicit joins
    - Add comments explaining complex WHERE clauses

    Return valid PostgreSQL syntax.
    """
    ...

@agentic()
async def write_changelog_entry(commit_messages: list[str]) -> str:
    """
    Write a changelog entry from commit messages.

    Example input: ["fix: resolve login timeout", "feat: add dark mode"]
    Example output:
    ### Features
    - Added dark mode support

    ### Bug Fixes
    - Fixed login timeout issue

    Follow this format exactly.
    """
    ...

@agentic()
async def format_currency(amount: float, currency: str) -> str:
    """
    Format a currency amount for display.

    Examples:
    - format_currency(1234.50, "USD") → "$1,234.50"
    - format_currency(999.99, "EUR") → "€999.99"
    - format_currency(50, "GBP") → "£50.00"

    Always include the currency symbol and exactly 2 decimal places.
    """
    ...

from typing import Literal

@agentic()
async def categorize_severity(error_message: str, stack_trace: str) -> Literal['critical', 'high', 'medium', 'low']:
    """
    Categorize error severity.

    Constraints:
    - Return 'critical' if: data loss, security breach, system crash
    - Return 'high' if: feature unusable, affects multiple users
    - Return 'medium' if: degraded performance, workaround available
    - Return 'low' if: cosmetic issue, minimal impact

    Edge cases:
    - If stack_trace is empty, base decision on error_message alone
    - Database errors are at minimum 'high' severity
    - Authentication errors are at minimum 'high' severity
    """
    ...

@agentic()
async def parse_date_range(text: str) -> tuple[str, str] | None:
    """
    Extract start and end dates from natural language.

    Return format: (start_date, end_date) as YYYY-MM-DD strings

    Constraints:
    - Start date must be before or equal to end date
    - Return None if no date range found
    - Return None if only one date found (need both)

    Edge cases:
    - "last week" → Monday to Sunday of previous week
    - "Q1 2024" → 2024-01-01 to 2024-03-31
    - Relative dates use today's date as reference
    """
    ...

from agentica import spawn
from typing import Literal

agent = await spawn(premise="You are a security validator for user queries")

# Step 1: Agent analyzes input for safety
safety = await agent.call(
    Literal['safe', 'sql_injection', 'invalid_chars'],
    "Classify this user input for security issues",
    user_input=untrusted_input
)

# Step 2: Based on what agent found, take different actions
if safety == 'safe':
    # Agent remembers the input it just analyzed
    normalized = await agent.call(
        str,
        "Normalize the input you just validated (lowercase, trim, remove extra spaces)"
    )
    return normalized
elif safety == 'sql_injection':
    # Agent remembers what SQL patterns it detected
    details = await agent.call(
        str,
        "Explain which SQL patterns you detected and why they're dangerous"
    )
    log_security_violation(details)
    raise SecurityError(details)
else:
    # Agent remembers the invalid characters it found
    suggestion = await agent.call(
        str,
        "Suggest what the user should change about their input"
    )
    return f"Invalid input. {suggestion}"