# LangChain — build an agent, deploy via LangSmith or DIY
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

agent = create_agent(
    model="gpt-4o",
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)
result = agent.invoke({"messages": [...]})

# Deployment options: LangSmith Deployment (paid) or DIY.
# No built-in agent registry or A2A discovery protocol.
# Other teams can't discover your agent via a standard protocol.

# CrewAI — orchestration within CrewAI agents
from crewai import Agent, Task, Crew

researcher = Agent(
    role="Senior Researcher",
    goal="Research the topic thoroughly",
    backstory="You are an expert researcher.",
    llm="gpt-4o",
)
crew = Crew(agents=[researcher], tasks=[task])
result = crew.kickoff()

# Enterprise plan offers managed deployment.
# OSS version: agent is ephemeral, no registry or A2A discovery.
# Can't mix non-CrewAI agents (e.g., a LangChain agent) into a crew.

# AgentOven — register, deploy, discover, route, observe
from agentoven import Agent, Ingredient, AgentOvenClient

agent = Agent("research-bot", ingredients=[
    Ingredient.model("gpt-4o", provider="openai"),
    Ingredient.tool("web-search", protocol="mcp"),
])

client = AgentOvenClient()
client.register(agent)       # → Agent in registry with A2A card
client.bake(agent)            # → Deployed, health-checked, discoverable

$ agentoven agent register --name research-bot --framework langchain
✓ Agent 'research-bot' registered

$ agentoven agent bake research-bot
✓ Agent deployed → https://your-oven.dev/.well-known/agent.json

# CrewAI — different LLMs per agent, but all must be CrewAI agents
from crewai import Agent, Task, Crew

researcher = Agent(role="Researcher", llm="gpt-4o", ...)
writer = Agent(role="Writer", llm="claude-sonnet-4-20250514", ...)  # Different LLM ✅

# What if your best summarizer is a LangChain agent?
# What if another team built a validator with the OpenAI SDK?
# They can't join this crew — all agents must be CrewAI agents.

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process="sequential",
)

from agentoven import Recipe, Step, AgentOvenClient

recipe = Recipe("content-pipeline", steps=[
    # Step 1: LangChain researcher
    Step.agent("research", agent_ref="research-bot"),

    # Step 2: Human approval gate
    Step.human_gate("review", notify=["slack:#content-review"]),

    # Step 3: CrewAI writer (different framework, same workflow)
    Step.agent("write", agent_ref="content-writer"),

    # Step 4: OpenAI SDK validator (yet another framework)
    Step.agent("validate", agent_ref="quality-checker"),
])

client = AgentOvenClient()
run_id = client.bake_recipe(recipe, input={"topic": "AI in healthcare"})

# recipe.yaml — framework-agnostic DAG
name: content-pipeline
steps:
  - id: research
    agent: research-bot          # LangChain agent
  - id: review
    kind: human-gate
    notify: ["slack:#reviews"]
  - id: write
    agent: content-writer        # CrewAI agent
    depends_on: [review]
  - id: validate
    agent: quality-checker       # OpenAI SDK agent
    depends_on: [write]

# LangChain — basic fallback support via .with_fallbacks()
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

primary = ChatOpenAI(model="gpt-4o")
fallback = ChatAnthropic(model="claude-sonnet-4-20250514")
llm = primary.with_fallbacks([fallback])

# ✅ Basic failover works.
# ❌ No cost-optimized routing (pick cheapest provider).
# ❌ No latency-optimized routing (pick fastest).
# ❌ No round-robin load balancing.
# ❌ No A/B split testing between models.
# ❌ No per-request cost tracking at the infrastructure level.

from agentoven import Agent, Ingredient, AgentOvenClient

agent = Agent("smart-router", ingredients=[
    # Primary model
    Ingredient.model("gpt-4o", provider="openai", role="primary"),
    # Automatic failover
    Ingredient.model("claude-sonnet-4-20250514", provider="anthropic", role="fallback"),
    # Local fallback (zero cost)
    Ingredient.model("llama3", provider="ollama", role="fallback"),
])

client = AgentOvenClient()
client.register(agent)
client.bake(agent)

# The Model Router handles:
# ✅ Automatic failover if OpenAI is down
# ✅ Cost-optimized routing (picks cheapest provider)
# ✅ Latency-optimized routing (picks fastest)
# ✅ Round-robin load balancing
# ✅ A/B split testing between models
# ✅ Per-request cost tracking

# Register providers with the control plane
curl -X POST http://localhost:8080/api/v1/providers -d '{
  "name": "openai-primary",
  "kind": "openai",
  "model": "gpt-4o",
  "priority": 1,
  "cost_per_1k_input": 0.005
}'

curl -X POST http://localhost:8080/api/v1/providers -d '{
  "name": "anthropic-fallback",
  "kind": "anthropic",
  "model": "claude-sonnet-4-20250514",
  "priority": 2,
  "cost_per_1k_input": 0.003
}'

# Route with strategy
curl http://localhost:8080/api/v1/models/route -d '{
  "strategy": "cost-optimized",
  "messages": [{"role": "user", "content": "Summarize this doc"}]
}'

# LangChain — rich tool ecosystem, but LangChain-specific format
from langchain.tools import tool

@tool
def search_docs(query: str) -> str:
    """Search internal documents."""
    return db.search(query)

# Great within LangChain — many built-in integrations.
# But this tool format is LangChain-specific.
# A CrewAI agent can use LangChain tools, but an OpenAI SDK
# agent or a custom Go agent would need an adapter.

# Register a tool once via MCP — every agent can use it
curl -X POST http://localhost:8080/api/v1/tools -d '{
  "name": "search-docs",
  "description": "Search internal documents",
  "input_schema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" }
    }
  }
}'

# Any agent, any framework, same tool
from agentoven import Agent, Ingredient

agent = Agent("doc-helper", ingredients=[
    Ingredient.model("gpt-4o", provider="openai"),
    Ingredient.tool("search-docs", protocol="mcp"),  # MCP tool
    Ingredient.tool("slack-notify", protocol="mcp"),  # Another MCP tool
])

# MCP tools are universal — they work with LangChain agents,
# CrewAI agents, OpenAI SDK agents, or your custom code.

# LangSmith — framework-agnostic observability (free tier available)
import os
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = "ls_xxx"

# ✅ Traces LangChain, CrewAI, OpenAI, Anthropic, AutoGen, and more
# ✅ Powerful evaluation and prompt engineering tools
# ⚠️  Free tier: 5k traces/month, 1 seat — unusable for teams
# ⚠️  Plus: $39/seat/month — 50-person team = $23,400/year just for observability
# ❌ Proprietary SaaS — not self-hostable on free/plus plans
# ❌ Per-seat pricing scales linearly with team size
# ❌ No built-in model routing or agent lifecycle management

# Every agent gets traces automatically — zero per-seat cost
# Self-hosted: your infra, your data. No per-seat SaaS fees.
$ agentoven trace get run-abc123

Run: run-abc123
Agent: research-bot
Status: ✅ completed
Duration: 2.3s
Tokens: 1,847 (in: 412, out: 1,435)
Cost: $0.0089
Provider: openai/gpt-4o (fallback from anthropic — 429 rate limit)

Steps:
  1. 📥 Input received              0ms
  2. 🔧 Tool: search-docs          180ms
  3. 🤖 LLM: gpt-4o               1,800ms
  4. 📤 Output returned            320ms

$ agentoven trace cost --kitchen prod --last 24h
Kitchen: prod
Period: last 24 hours
Total Cost: $12.47
  openai/gpt-4o:        $8.23 (66%)
  anthropic/claude:     $3.91 (31%)
  ollama/llama3:        $0.33  (3%)
Requests: 1,847
Avg latency: 1.2s

# LangChain — flexible RAG, but requires assembling multiple packages
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA

# Powerful and flexible, but each piece is a separate dependency.
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(docs, embeddings)
chain = RetrievalQA.from_chain_type(llm, retriever=vectorstore.as_retriever())
# You choose your own vector store, embedder, and retrieval chain.
# No built-in quality evaluation (RAGAS) or ingestion pipeline.

# 1. Embeddings auto-discovered from your providers — zero config
# 2. Ingest documents
curl -X POST http://localhost:8080/api/v1/rag/ingest -d '{
  "documents": [{"id": "doc1", "text": "..."}],
  "chunk_size": 512,
  "chunk_overlap": 50
}'

# 3. Query with 5 built-in retrieval strategies
curl -X POST http://localhost:8080/api/v1/rag/query -d '{
  "query": "How does agent deployment work?",
  "strategy": "hyde",
  "top_k": 5
}'

# 4. Built-in RAGAS evaluation — no extra setup
curl http://localhost:8080/api/v1/rag/evaluate -d '{
  "query": "How does deployment work?",
  "answer": "...",
  "contexts": ["..."]
}'
# → { "faithfulness": 0.92, "relevancy": 0.87, "precision": 0.95 }

# Every baked agent automatically gets an A2A Agent Card
$ curl https://your-oven.dev/.well-known/agent.json
{
  "name": "research-bot",
  "description": "Researches topics using web search and summarization",
  "url": "https://your-oven.dev/a2a/research-bot",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": ["web-search", "summarization"],
  "version": "1.0.0"
}

# Other agents (even from different orgs) can discover and call yours
$ curl -X POST https://your-oven.dev/a2a/research-bot -d '{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "message": {
      "role": "user",
      "parts": [{"text": "Research quantum computing trends"}]
    }
  }
}'