Google ADK

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import InMemoryRunner
from google.genai import types

import agentos
import agentos.asgi

ORDERS = {"A-1001": {"status": "delivered", "total": "49.90", "currency": "EUR"}}


def lookup_order(order_id: str) -> dict:
    """Look an order up by its id, e.g. A-1001."""
    return ORDERS.get(order_id, {"error": f"no order {order_id}"})


def refund(order_id: str, amount: str) -> str:
    """Moves the money. Called by our code, after a person approved, never by the model."""
    return f"refunded {amount} for order {order_id}"


async def ask_the_model(inv: agentos.Invocation, tools: list) -> str:
    model = LiteLlm(
        model="openai/" + inv.llm.model(),  # "openai/": the gateway speaks the OpenAI API, whatever the model
        api_base=inv.llm.base_url,
        api_key=inv.llm.api_key,
        extra_headers=inv.llm.headers,  # the run token
    )
    agent = Agent(name="support", model=model, instruction=inv.config["prompts"]["system"], tools=tools)
    runner = InMemoryRunner(agent=agent, app_name="support")
    session = await runner.session_service.create_session(app_name="support", user_id="customer")
    message = types.Content(role="user", parts=[types.Part(text=inv.input["message"])])
    answer = ""
    async for event in runner.run_async(user_id="customer", session_id=session.id, new_message=message):
        if event.is_final_response() and event.content and event.content.parts:
            answer = "".join(part.text or "" for part in event.content.parts)
    return answer


async def support(inv: agentos.Invocation):
    if inv.resume is None:
        requested = []

        def request_refund(order_id: str, amount: str) -> dict:
            """Request a refund for an order. The amount is text, e.g. "49.90". A person approves it later."""
            requested.append({"order_id": order_id, "amount": amount})
            return {"status": "requested: a person approves refunds before any money moves"}

        try:
            answer = await ask_the_model(inv, [lookup_order, request_refund])
        except Exception as error:
            if block := agentos.guardrail_block(error):  # a guardrail refused a model call
                raise block from error
            raise
        if not requested:
            return {"answer": answer}
        await inv.aask(
            "Approve a refund",
            [{"id": f"refund-{i}", "title": f"Refund {r['amount']} for order {r['order_id']}", "data": r}
             for i, r in enumerate(requested, 1)],
            actions=["approve", "edit", "reject"],
        )  # the run is held here; once a person decided, the handler runs again with inv.resume

    done = []
    for item in inv.resume.items:
        if item.action in ("approve", "edit"):
            done.append(refund(item.data["order_id"], item.data["amount"]))
        else:
            done.append(f"refund for order {item.data['order_id']} not approved: {item.comment or 'rejected'}")
    return {"answer": "; ".join(done)}


if __name__ == "__main__":
    import uvicorn

    # one long-lived event loop for ADK and LiteLLM (agentos.serve runs each async handler in a loop of its own)
    uvicorn.run(agentos.asgi.app({"support": support}), host="0.0.0.0", port=8080)

name: support-google-adk
title: Support agent (Google ADK)
description: Answers order questions with a lookup tool; refunds go through a person first.
runtime: stateless
port: 8080
capabilities:
  support:
    description: Handles a customer's message. A refund the model wants to issue waits for a person's approval.
    input:
      type: object
      properties: {message: {type: string, minLength: 1}}
      required: [message]
    output:
      type: object
      properties: {answer: {type: string}}
      required: [answer]
    timeout: 120s
config:
  models:
    main: anthropic/claude-sonnet-4-5    # a model from your Models page: <provider slug>/<model ID>
  prompts:
    system: >-
      You are a support agent for an online shop. Look orders up with lookup_order before you
      answer anything about an order. Ask for refunds with the request_refund tool. Never refund more than the order's total.

FROM python:3.13-slim
WORKDIR /app
# LiteLLM would download its model price list at import; agents reach nothing outside AgentOS by default
ENV LITELLM_LOCAL_MODEL_COST_MAP=True
COPY vendor/ vendor/
COPY requirements.txt .
RUN pip install --no-cache-dir "$(ls vendor/*.whl)[starlette]" -r requirements.txt
COPY app.py .
USER nobody
EXPOSE 8080
CMD ["python", "-u", "app.py"]

google-adk==2.13.0
litellm==1.105.5
uvicorn==0.54.0