# The shape of an agent — about 30 lines, no framework.
def run(client, system, user, tools, max_steps=8):
    messages = [
        {"role": "system", "content": system},
        {"role": "user",   "content": user},
    ]
    for step in range(max_steps):
        reply = client.messages.create(
            model="gemini-3.7-flash",
            messages=messages, tools=tools,
        )
        if reply.stop_reason == "end_turn":
            return reply.content
        # Otherwise: the model asked to use a tool.
        results = [dispatch(c) for c in reply.content
                   if c.type == "tool_use"]
        messages.append({"role": "assistant", "content": reply.content})
        messages.append({"role": "user",      "content": results})
    raise StepLimitExceeded(max_steps)

from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="root_agent",
    model="gemini-3.7-flash",
    instruction="You are a helpful AI assistant.",
    tools=[get_current_server_time, get_weather],
)

from google.adk.agents import LlmAgent
from google.adk.models.lite_llm import LiteLlm

# Option 1 — direct string (Gemini via Vertex AI):
assistant = LlmAgent(
    name="personal_assistant",
    model="gemini-3.7-flash",
    instruction="You are a helpful personal assistant.",
)

# Option 2 — wrapper class (any LiteLlm-supported model):
local_assistant = LlmAgent(
    name="local_assistant",
    model=LiteLlm(model="ollama/llama3"),
    instruction="You are a local assistant.",
)

import random

def get_weather(city: str) -> str:
    """Get the current weather conditions for a given city.

    Args:
        city: The city to get the weather conditions for.

    Returns:
        A string with the simulated weather conditions.
    """
    temperature = random.randint(-10, 40)
    conditions = random.choice(["sunny", "cloudy", "rainy", "snowy"])
    return f"The weather in {city} is {temperature}°C and {conditions}."

from google.adk.agents import LlmAgent
from google.adk.tools import (
    google_search, code_executor, bigquery
)

researcher = LlmAgent(
    name="research_assistant",
    model="gemini-3.7-flash",
    instruction="Research questions thoroughly.",
    tools=[google_search, code_executor, bigquery],
)
# Caveats: only one built-in per agent; most need Gemini 2.0+;
# not allowed in sub-agents.

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

research_agent = LlmAgent(
    name="research_agent",
    model=model,
    instruction="You are a news researcher. Run a Google "
                "Search for each query in the SearchPlan. "
                "Return a compilation of the facts you find.",
    tools=[google_search],
)

from pydantic import BaseModel, Field
from google.adk.agents import LlmAgent

class SearchPlan(BaseModel):
    queries: list[str] = Field(
        description="2-3 specific Google Search queries."
    )

planner_agent = LlmAgent(
    name="planner_agent",
    model=model,
    instruction="...",
    output_schema=SearchPlan,
)

from pydantic import BaseModel, Field
from typing import Optional

class Citation(BaseModel):
    title: str
    url: str

class ArticleDraft(BaseModel):
    title: str
    teaser: str
    content: str

class Article(ArticleDraft):
    citations: list[Citation] = Field(default_factory=list)
    search_entry_point_html: Optional[str] = None

class NewspaperPage(BaseModel):
    articles: list[Article]

class TopicPlan(BaseModel):
    topics: list[str]

async def research_one(topic: str) -> dict:
    start = len(ctx.session.events)
    article = await ctx.run_node(researcher_agent, node_input=topic)
    end = len(ctx.session.events)

    citations, rendered = extract_citations_from_events(
        ctx.session.events[start:end]
    )
    article["citations"] = citations
    article["search_entry_point_html"] = rendered
    return article

from google.adk.agents import LlmAgent
from google.adk.workflow import Workflow
from utils.vector_store import search_archive

def search_news_archive(query: str, top_k: int = 5) -> list:
    return search_archive(query, top_k)

archive_reader_agent = LlmAgent(
    name="archive_reader_agent",
    model=model,
    instruction="You are an archival librarian. "
                "Always search the archive first.",
    tools=[search_news_archive],
    output_schema=NewspaperPage,
    output_key="compiled_news",
)

archive_workflow = Workflow(
    name="archive_workflow",
    edges=[("START", archive_reader_agent)],
)

from google.adk.events.event import Event
from google.adk.workflow import Workflow, node

@node
def router(node_input):
    text = _user_text(node_input).lower()
    if "archive" in text or "past" in text:
        return Event(output=node_input, route="archive")
    return Event(output=node_input, route="news")

root_agent = Workflow(
    name="news_workflow",
    edges=[
        ("START", router),
        (router, {"news": planner_agent,
                  "archive": archive_reader_agent}),
        (planner_agent, research_orchestrator),
        (research_orchestrator, compiler_agent),
    ],
)

from app.app_utils.telemetry import setup_telemetry
from app.app_utils.logging import log_event

setup_telemetry()  # no-op locally; ships to Cloud Trace in prod

# After each workflow run:
log_event({
    "event": "workflow_completed",
    "mode": mode,
    "session_id": session_id,
    "article_count": len(compiled_data["articles"]),
})

@app.route("/feedback", methods=["POST"])
def feedback():
    f = Feedback.model_validate(request.json)
    log_event(f.model_dump(), severity="INFO")
    return {"ok": True}

# A Workflow is NOT an Agent — expose it as a function tool
# that runs it through a Runner.
async def run_news_pipeline(topic: str) -> dict:
    """Research the news on a topic; return a NewspaperPage."""
    runner = Runner(
        app_name="news_tool",
        agent=news_workflow,        # Runner duck-types the Workflow
        session_service=InMemorySessionService(),
    )
    # ... drain runner.run_async, then read session state:
    return session.state.get("compiled_news", {})

concierge_agent = LlmAgent(
    name="concierge",
    model=model,
    instruction="Chat normally. Call run_news_pipeline when "
                "the user asks for news on a topic.",
    tools=[run_news_pipeline],      # auto-wrapped as a FunctionTool
)