pip install -r requirements.txt

from src.tool_registry import ToolRegistry, tool

registry = ToolRegistry()

@registry.register
@tool(
    description="Fetch the current price of a stock by ticker symbol",
    param_descriptions={
        "ticker": "Stock ticker symbol (e.g., 'AAPL', 'GOOGL')",
    },
    tags=["finance"],
)
def get_stock_price(ticker: str) -> str:
    # In production, call a real API here
    prices = {"AAPL": 178.50, "GOOGL": 141.20, "MSFT": 378.90}
    price = prices.get(ticker.upper())
    if price is None:
        return f"Unknown ticker: {ticker}"
    return f"{ticker.upper()}: ${price:.2f}"

from src.agent import Agent, AgentConfig
from src.llm_client import OpenAIClient  # or MockLLMClient for testing

config = AgentConfig(
    name="stock-analyst",
    system_prompt="""You are a financial analyst assistant.
    When asked about stocks, use the get_stock_price tool to look up current prices.
    Always provide context with your answers (market trends, comparisons).
    If you don't have data for a stock, say so clearly.""",
    max_steps=15,
    temperature=0.1,
    model="gpt-4o",
)

from src.guardrails import GuardrailChain, ContentFilter, RateLimiter, LengthGuardrail

guardrails = GuardrailChain()

# Block attempts to extract API keys or credentials
guardrails.add(ContentFilter(
    blocked_patterns=[r"api.?key", r"secret", r"password"],
), input_only=True)

# Prevent runaway loops
guardrails.add(RateLimiter(max_calls=20, window_seconds=60))

# Block excessively long inputs (prompt injection defense)
guardrails.add(LengthGuardrail(max_chars=10_000), input_only=True)

from src.memory.buffer import ConversationBuffer
from src.memory.long_term import LongTermMemory
from src.memory.summarizer import ConversationSummarizer

# Short-term: keeps recent conversation in context
summarizer = ConversationSummarizer()
buffer = ConversationBuffer(
    max_turns=30,
    max_tokens=6000,
    summarize_fn=summarizer,
)

# Long-term: remembers facts across conversations
long_term = LongTermMemory(persist_path="./data/analyst_memory.json")
long_term.store("User prefers concise bullet-point responses", category="preference", importance=0.9)

agent = Agent(
    config=config,
    llm=OpenAIClient(api_key="YOUR_API_KEY_HERE"),
    tools=registry,
    memory=buffer,
    guardrails=guardrails,
    event_handler=lambda e: print(f"  [{e.event_type}] {e.content}"),
)

# Single-turn interaction
result = agent.run("What's the current price of AAPL?")
print(result)

# Multi-turn (memory preserves context)
result2 = agent.run("How does that compare to MSFT?")
print(result2)

from src.planning.react import ReActPlanner

planner = ReActPlanner(
    agent_config=config,
    llm=OpenAIClient(api_key="YOUR_API_KEY_HERE"),
    tools=registry,
    max_iterations=8,
)
result = planner.solve("Compare AAPL, GOOGL, and MSFT prices and recommend the best value")
print(planner.format_trace())  # See the reasoning steps

from src.planning.plan_execute import PlanAndExecutePlanner

planner = PlanAndExecutePlanner(
    llm=OpenAIClient(api_key="YOUR_API_KEY_HERE"),
    tools=registry,
    max_replans=2,
)
result = planner.solve("Research the top 5 tech stocks, analyze their prices, and write a summary report")