databricks-agentbricks 0.2.0__py3-none-any.whl

databricks_agentbricks/templates/agent-langgraph/AGENTKIT_CONTRACT.md

@@ -0,0 +1,95 @@
+# Managed runtime integration contract for LangGraph
+
+This document owns the requirements shared by generated projects and existing agents adopting
+the managed runtime. The [README](README.md) owns commands and HTTP examples; adapter docstrings own API details.
+The adjacent template is an example, not a required graph architecture. Runtime internals live in
+the installed package's runtime guide.
+
+## Command requirements
+
+Agent Bricks CLI commands operate on an application directory; they do not rewrite its graph. Each capability
+needs runtime wiring as well as manifest configuration.
+
+| Command | Required integration |
+| --- | --- |
+| `dev`, `deploy` | Installable dependencies and an `app.yaml` command starting the application |
+| `tools add mcp`, `uc-function`, `genie`, `sandbox` | Load bindings into model definitions and tool execution |
+| `sessions bind` | Select the bound checkpointer and supply session/actor identity |
+| `memory bind` | Include bound, actor-scoped memory tools in definitions and execution |
+| `tracing bind`, `tracing unbind` | Initialize tracing and open a root span from resolved config |
+| `endpoint invoke` | An HTTP endpoint; the caller supplies its path and complete request body |
+
+### Project and startup
+
+Use `agent.toml` for framework, tool/store bindings, and tracing. The existing `.agentbricks/project.toml`
+file records framework and template provenance; keep it when working with projects that have it.
+Metadata alone does not integrate adapters. Install a compatible `databricks-agentbricks[langgraph]`
+distribution, supply the real command in `app.yaml`, load configuration before adapters, and listen
+on the app port. The Agent Bricks CLI and runtime find `agent.toml` from the working directory or
+`AGENTBRICKS_PROJECT_ROOT`. Keep credentials out of `app.yaml`.
+
+Store binding commands declare intent. `dev` and `deploy` resolve or provision declared stores and
+supply runtime config; deploy grants app access. The resolved Memory Store ID reaches the runtime
+as `AGENT_MEMORY_STORE`, rather than being stored as an ID in the manifest. Do not hardcode values
+that make later bindings ineffective.
+
+### Tools
+
+Use `databricks_agentkit.langgraph.mcp_tools()` for MCP, UC function, and sandbox bindings, combining
+them with existing servers without duplicates. It applies sandbox downscoping. Local Python tools
+belong in source; the template discovers `BaseTool` objects through
+[agent/tools/__init__.py](agent/tools/__init__.py).
+
+Feed selected tools into both model definitions and graph execution while preserving approval
+policy. New bindings must become effective on the next graph construction or restart without
+another source edit.
+
+### Sessions and memory
+
+Use `checkpointer()` for managed state and merge `thread_config(session_id, actor)` into every
+graph run. The helper selects the bound Session Store or an in-process saver; explicit arguments
+and environment overrides take precedence. It caches the saver per process, so restart after a
+binding change. The application state must be serializable by the selected saver.
+
+Include `memory_tools(actor)` in model and execution wiring. It returns no tools when unconfigured.
+Its closures capture actor identity, so never reuse them across users. The application owns trusted
+actor/tenant authentication; a payload field alone does not establish identity.
+
+### Tracing
+
+Call `configure_tracing()` after loading config, then wrap agent execution, including streams, in
+`start_trace(..., session_id=session_id)`. The root span lets framework autologging record children.
+The helper enables tracing when destination and experiment settings are present and disables it
+otherwise. Preserve existing tracing semantics when composing it.
+
+## Managed server adapter
+
+For the managed invocation protocol, construct `DurableAgentServer` in [runtime/main.py](runtime/main.py)
+and register [runtime/adapter.py](runtime/adapter.py) hooks. Keep framework-native execution in
+[agent/agent.py](agent/agent.py), independent of runtime request/context types.
+
+The invoke hook translates opaque application input, runs the graph, translates native events,
+calls `await context.emit(event)`, and returns JSON output. DurableAgentServer owns foreground/background
+transport, polling, and replay. Invocation UUIDs differ from stable application session IDs; the
+routing cookie is not the application session.
+
+The example assumes `messages` state and message/update events. Custom state, outputs, and
+interrupts require explicit mappings and must not be discarded to fit the example.
+
+### Recovery and durability
+
+Runtime Store persistence covers invocations and emitted events. Session Store persistence covers
+graph checkpoints and paused interrupts. A durable Runtime Store alone does not preserve graph
+state. `dev` uses process-local invocation storage; deployment attaches a Lakebase-backed
+Runtime Store.
+
+Register recovery when intended. Resume a checkpoint only when metadata associates it with the
+current invocation; otherwise replay original input. Use synchronous checkpoint durability before
+acknowledging progress. Recovery is at least once, so side effects must tolerate replay.
+
+## Optional chat app
+
+No CLI command requires the chat UI. The default overlay supplies it; `--disable-chat-app` omits
+it. When adopting it, inspect `CHAT_APP.md`, `runtime/ui.py`, and browser code. Adapt model choice,
+history, interrupts, and authentication to the actual graph. Its message-oriented assumptions must
+not silently change custom application behavior.

databricks_agentbricks/templates/agent-langgraph/AGENTS.md

@@ -0,0 +1,31 @@
+# Agent Development Guide
+
+This project is a LangGraph workload hosted by `databricks_agentkit.DurableAgentServer`.
+
+Read [AGENTKIT_CONTRACT.md](AGENTKIT_CONTRACT.md) before changing integration points. It owns command
+requirements, tool/state/tracing wiring, and recovery. [README.md](README.md) owns setup and client
+examples. Keep this file as a development map rather than repeating those rules.
+
+## Commands
+
+```bash
+ab dev
+uv run pytest
+ab --profile <profile> deploy <name> --source .
+```
+
+## Code map
+
+| Change | File |
+| --- | --- |
+| Framework-native agent and `run_agent` | `agent/agent.py` |
+| Local tools | `agent/tools/` |
+| MCP servers | `agent/mcps.py` |
+| Managed runtime `invoke`/`recover` hooks and input/output translation | `runtime/adapter.py` |
+| `DurableAgentServer` construction and hook registration | `runtime/main.py` |
+| Browser and managed-state routes | `runtime/ui.py` |
+| Browser behavior | `ui/app.js` |
+
+Shared adapters come from `databricks_agentkit.langgraph` and `databricks_agentkit.runtime`. Consult
+their docstrings for API details. Update the shared contract and relevant tests when integration
+requirements change.

databricks_agentbricks/templates/agent-langgraph/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

databricks_agentbricks/templates/agent-langgraph/README.md

@@ -0,0 +1,141 @@
+# LangGraph agent template
+
+A LangGraph agent served by `databricks_agentkit.DurableAgentServer`. The managed runtime keeps invocation state and events in
+memory during `ab dev`. Deployment attaches a persistent Runtime Store, so invocation state and
+events survive process loss and interrupted work can be recovered.
+
+The generated project separates portable agent execution from the managed HTTP protocol:
+
+```text
+client -> runtime/main.py -> runtime/adapter.py -> agent/agent.py:run_agent
+```
+
+- `agent/agent.py` owns the framework-native agent, sessions, tools, MCP lifetime, and `run_agent`.
+- `runtime/adapter.py` owns the agent-author integration hooks: runtime input/output translation plus
+  `invoke` and `recover`.
+- `runtime/main.py` constructs the server and registers those hooks.
+
+To bring an existing LangGraph agent, run `ab init --framework langgraph --existing .` in its
+project and follow the generated prompt in your coding agent. The migration skill and this template share
+[AGENTKIT_CONTRACT.md](AGENTKIT_CONTRACT.md), which owns integration requirements. This README owns
+configuration and client examples; [AGENTS.md](AGENTS.md) provides the development map.
+
+## Run locally
+
+```bash
+ab dev
+```
+
+The API is available at `http://localhost:8000/api/invocations`. Every request supplies a UUID `id`.
+That ID is the invocation identifier and idempotency key. Agent-specific values live inside the
+opaque `input` object:
+
+```bash
+SESSION_ID=$(uuidgen)
+INVOCATION_ID=$(uuidgen)
+
+curl -sS http://localhost:8000/api/invocations \
+  -H 'Content-Type: application/json' \
+  -d "{\"id\":\"$INVOCATION_ID\",\"input\":{\"session_id\":\"$SESSION_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"What time is it? Use your tool.\"}]}}"
+```
+
+Reuse `SESSION_ID` for multi-turn conversation state. Generate a new `INVOCATION_ID` for each turn.
+Retrying the same request with the same invocation ID returns the persisted result; changing the
+request while reusing the ID returns `409`.
+
+## Invocation modes
+
+- Foreground: omit `background` and `stream`; the response contains the agent result under `output`.
+- Foreground streaming: set `stream: true`; the response is SSE backed by persisted events.
+- Background: set `background: true`; poll the returned `status_url`.
+- Background streaming: set both flags; the `202` response includes `status_url` and `events_url`.
+
+```bash
+INVOCATION_ID=$(uuidgen)
+curl -sN http://localhost:8000/api/invocations \
+  -H 'Content-Type: application/json' \
+  -d "{\"id\":\"$INVOCATION_ID\",\"input\":{\"session_id\":\"$SESSION_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"Count to three.\"}]},\"stream\":true}"
+
+INVOCATION_ID=$(uuidgen)
+curl -sS http://localhost:8000/api/invocations \
+  -H 'Content-Type: application/json' \
+  -d "{\"id\":\"$INVOCATION_ID\",\"input\":{\"session_id\":\"$SESSION_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"Summarize durable agents.\"}]},\"background\":true}" | jq
+curl -sS "http://localhost:8000/api/invocations/$INVOCATION_ID" | jq
+```
+
+SSE records contain events translated by `runtime/adapter.py`: token `delta`s, completed `message`s,
+and HITL `interrupt`s. Replay from a cursor with
+`GET /api/invocations/{id}/events?after={sequence}`.
+
+## Human approval
+
+`send_message` is gated by `HumanInTheLoopMiddleware`. Start a turn asking the agent to use that
+tool. When the output or event stream contains an `interrupt`, submit a new invocation with the same
+application session:
+
+```json
+{
+  "id": "<new-uuid>",
+  "input": {
+    "session_id": "<same-session-id>",
+    "resume": {"decisions": [{"type": "approve"}]}
+  }
+}
+```
+
+The default checkpointer is process-local. Bind a managed Session Store to preserve multi-turn and
+paused LangGraph state across restarts:
+
+```bash
+ab sessions bind my-agent-sessions
+```
+
+## Crash recovery
+
+Deployment with a Runtime Store supports invocation recovery after worker loss. Graph checkpoint
+persistence requires a Session Store separately. Recovery can replay work, so tools must tolerate
+repeated side effects. See [Recovery and durability](AGENTKIT_CONTRACT.md#recovery-and-durability).
+
+## Chat app
+
+The browser UI is included by default. It generates a stable application session ID in local
+storage, places it inside each invocation's `input`, and generates a fresh invocation UUID per turn.
+Use `ab init --framework langgraph --disable-chat-app` for API-only output.
+
+## Configure and deploy
+
+- Change the model, instructions, tools, graph, and framework-native execution in `agent/agent.py`.
+- Change `runtime/adapter.py` only to map a different application input/output contract.
+- Add local tools under `agent/tools/`; modules are auto-discovered.
+- Add MCP servers in `agent/mcps.py` or with `ab tools add mcp`.
+- Bind long-term memory with `ab memory bind <store>`.
+
+```bash
+ab --profile <profile> deploy agent-langgraph --source .
+```
+
+When deployment provisions a dedicated Runtime Store, only the app-owned
+`databricks_agentkit_runtime_<hash>` schema and runtime tables are added. Managed Runtime Store
+deployments use their own default schema.
+
+The `__Host-databricks-app-router` cookie may be supplied independently for sticky replica routing.
+It is not authentication and is not used as the template's application session ID.
+
+# Request-user authorization
+
+Declared tools in `agent.toml` select `auth = "user"` or `auth = "app"`; legacy missing auth
+continues to use the application/default identity. Deployed user tools require the request resolver
+and never fall back to application credentials. Model, memory-service, session-service, and custom
+MCP server credentials are unchanged.
+
+`runtime/main.py` derives the invocation policy after `configure()`. The runtime adapter namespaces
+public session IDs and actor values for the request owner, then passes only `workspace_client_for`
+to the framework-native agent. Internal session keys are never returned to clients.
+
+User-policy invocations use the existing Runtime for synchronous, streaming, and background calls,
+including status polling, event replay, and invocation-ID idempotency. The Runtime Store persists no
+credential; request-user authentication remains process-local for the active first attempt. A
+replacement attempt fails with `MCP_USER_AUTH_RECOVERY_UNSUPPORTED` before agent code runs. Approval
+interruptions remain unsupported and fail with `MCP_USER_AUTH_HITL_UNSUPPORTED`. The agent's
+existing namespaced memory, conversation store, and checkpointer behavior is unchanged; OBO does not
+add another saver.

databricks_agentbricks/templates/agent-langgraph/agent/agent.py

@@ -0,0 +1,177 @@
+import os
+from collections.abc import AsyncGenerator, Callable
+from typing import Any
+
+from databricks.sdk import WorkspaceClient
+from databricks_langchain import ChatDatabricks
+from langchain.agents import create_agent
+from langchain.agents.middleware import HumanInTheLoopMiddleware
+
+from agent.mcps import build_mcp_servers
+
+# Importing the tools package auto-registers every tool module.
+from agent.tools import all_tools
+from databricks_agentkit import workspace_client, workspace_headers
+from databricks_agentkit.langgraph import (
+    checkpointer,
+    configure_tracing,
+    genie_tools,
+    mcp_tools,
+    memory_tools,
+    start_trace,
+    thread_config,
+)
+from databricks_agentkit.langgraph.session_store import (
+    invocation_id_from_metadata,
+    invocation_metadata,
+)
+from databricks_agentkit.runtime.auth import AuthError
+
+# A Unity Catalog AI Gateway model service, served from the `system.ai` schema and queried through
+# the gateway (see `use_ai_gateway=True` below). Swap for any `system.ai.*` model service your
+# workspace exposes — the demo chat app's picker lists what's available.
+MODEL = "system.ai.claude-sonnet-4-5"
+
+# Tools that require human approval before they run. Map a tool name to True to allow every decision
+# (approve / edit / reject / respond), or to a config dict to restrict them (see HumanInTheLoopMiddleware).
+# When a listed tool is about to run, the agent pauses and emits an `interrupt` event; the client
+# resumes by sending `resume` with the same session id. Empty this dict to disable approval gating.
+REQUIRE_APPROVAL = {"send_message": True}
+
+
+class _RoutedChatDatabricks(ChatDatabricks):
+    """Forward account-host workspace routing to the underlying OpenAI clients."""
+
+    def _get_client_kwargs(self) -> dict[str, Any]:
+        kwargs = super()._get_client_kwargs()
+        if headers := workspace_headers():
+            kwargs["default_headers"] = headers
+        return kwargs
+
+
+def configure() -> None:
+    """Wire up global state; call once at server startup (not at import)."""
+    _check_databricks_auth()
+    configure_tracing()
+
+
+def _check_databricks_auth() -> None:
+    """Fail fast at startup with a clear message if Databricks auth isn't configured.
+
+    Without this, a missing/invalid profile only surfaces on the first model call — as a generic SDK
+    error buried in a request traceback. Resolving a WorkspaceClient here validates the same config
+    the model client uses, so the failure is immediate and actionable.
+    """
+    try:
+        workspace_client()
+    except Exception as e:
+        profile = os.getenv("DATABRICKS_CONFIG_PROFILE")
+        target = (
+            f"profile {profile!r}" if profile else "the DEFAULT profile / DATABRICKS_HOST+TOKEN"
+        )
+        raise RuntimeError(
+            f"Databricks auth is not configured — the agent can't call the model. Tried {target}.\n"
+            "Fix one of:\n"
+            "  • set DATABRICKS_CONFIG_PROFILE in .env to a profile from `databricks auth profiles`, or\n"
+            "  • run `databricks auth login --profile <name>` to create one, or\n"
+            "  • set DATABRICKS_HOST and DATABRICKS_TOKEN in .env.\n"
+            f"(underlying error: {e})"
+        ) from e
+
+
+async def create_agent_graph(
+    actor: str,
+    model: str | None = None,
+    *,
+    workspace_client_for: Callable[[str], WorkspaceClient] | None = None,
+):
+    """Build the LangGraph agent: local tools + long-term-memory tools + any MCP tools.
+
+    ``actor`` is the identity whose long-term memory the agent reads/writes; it's captured in the
+    memory tools' closures (never exposed to the model).
+
+    ``model`` selects the gateway model for this run; the chat UI passes the picker's choice and
+    everything else falls back to ``MODEL``. The agent is rebuilt per turn, so the model can vary
+    request to request.
+    """
+    mcp = await mcp_tools(build_mcp_servers(), workspace_client_for=workspace_client_for)
+    tools = [
+        *all_tools(),
+        *memory_tools(actor),
+        *genie_tools(workspace_client_for=workspace_client_for),
+        *mcp,
+    ]
+    middleware = (
+        [HumanInTheLoopMiddleware(interrupt_on=REQUIRE_APPROVAL)] if REQUIRE_APPROVAL else []
+    )
+    endpoint = model or MODEL
+    return create_agent(
+        # use_ai_gateway routes to the Unity Catalog AI Gateway (`<host>/ai-gateway/mlflow/v1`), so
+        # `endpoint` is a `system.ai.*` model name rather than a serving-endpoint name.
+        model=_RoutedChatDatabricks(
+            endpoint=endpoint, workspace_client=workspace_client(), use_ai_gateway=True
+        ),
+        tools=tools,
+        middleware=middleware,
+        checkpointer=checkpointer(),
+    )
+
+
+async def recovery_input(
+    agent_input: Any,
+    *,
+    session_id: str,
+    actor: str,
+    invocation_id: str,
+) -> Any:
+    """Return the input that should be passed to ``run_agent`` after worker loss.
+
+    A checkpoint tagged with this invocation means LangGraph can continue by receiving ``None``.
+    Otherwise recovery replays the original application input.
+    """
+    checkpoint = await checkpointer().aget_tuple(thread_config(session_id, actor))
+    current_invocation_checkpointed = bool(
+        checkpoint and invocation_id_from_metadata(checkpoint.metadata) == invocation_id
+    )
+    return None if current_invocation_checkpointed else agent_input
+
+
+async def run_agent(
+    agent_input: Any,
+    *,
+    session_id: str,
+    actor: str | None = None,
+    model: str | None = None,
+    invocation_id: str | None = None,
+    workspace_client_for: Callable[[str], WorkspaceClient] | None = None,
+) -> AsyncGenerator[Any, None]:
+    """Run the agent and yield native LangGraph stream events.
+
+    This is the framework-native entrypoint. It has no dependency on Agent Bricks request or context types,
+    so it can be called from another server, a notebook, or a test harness.
+    """
+    actor = actor or session_id
+    graph = await create_agent_graph(actor, model, workspace_client_for=workspace_client_for)
+    config = thread_config(session_id, actor)
+    if invocation_id:
+        config["metadata"] = invocation_metadata(invocation_id)
+
+    last_update: Any = None
+    with start_trace(name="invoke", inputs=agent_input, session_id=session_id) as span:
+        async for event in graph.astream(
+            input=agent_input,
+            config=config,
+            stream_mode=["updates", "messages"],
+            durability="sync",
+        ):
+            if event[0] == "updates":
+                last_update = event[1]
+                if workspace_client_for is not None and last_update.get("__interrupt__"):
+                    raise AuthError(
+                        "MCP_USER_AUTH_HITL_UNSUPPORTED",
+                        "Request-user invocations do not support paused approvals.",
+                        400,
+                    )
+            yield event
+        if span is not None and last_update is not None:
+            span.set_outputs(last_update)

databricks_agentbricks/templates/agent-langgraph/agent/mcps.py

@@ -0,0 +1,27 @@
+"""MCP servers to offer the agent — this is where you configure them.
+
+Empty by default: the agent runs with only the MCP servers declared in ``agent.toml``. Add servers
+to ``build_mcp_servers`` to offer more; ``agent.py`` passes them to ``mcp_tools``, which joins them
+with the ``agent.toml`` servers and fetches their tools each request.
+"""
+
+from databricks_langchain import DatabricksMCPServer
+
+
+def build_mcp_servers() -> list[DatabricksMCPServer]:
+    """Return the MCP servers to offer the agent. Empty by default — add your own.
+
+    Example (a Databricks-managed MCP, authed as the app service principal)::
+
+        from databricks.sdk import WorkspaceClient
+
+        host = WorkspaceClient().config.host
+        return [
+            DatabricksMCPServer(
+                name="system-ai",
+                url=f"{host}/api/2.0/mcp/functions/system/ai",
+                workspace_client=WorkspaceClient(),
+            ),
+        ]
+    """
+    return []

databricks_agentbricks/templates/agent-langgraph/agent/tools/__init__.py

@@ -0,0 +1,24 @@
+"""Agent tools package.
+
+Every module here is auto-imported, and every LangChain ``BaseTool`` it defines (via the
+``@tool`` decorator) is collected by ``all_tools()``. Drop a new ``*.py`` into this folder with a
+``@tool``-decorated function and it's picked up automatically — no wiring to edit.
+``create_agent_graph`` uses ``all_tools()``.
+"""
+
+import importlib
+import inspect
+import pkgutil
+
+from langchain_core.tools import BaseTool
+
+
+def all_tools() -> list[BaseTool]:
+    """Every BaseTool defined across the modules in this package."""
+    tools: list[BaseTool] = []
+    for module in pkgutil.iter_modules(__path__):
+        mod = importlib.import_module(f"{__name__}.{module.name}")
+        for _, obj in inspect.getmembers(mod, lambda o: isinstance(o, BaseTool)):
+            if obj not in tools:  # a tool imported into several modules is collected once
+                tools.append(obj)
+    return tools

databricks_agentbricks/templates/agent-langgraph/agent/tools/sample_tool.py

@@ -0,0 +1,15 @@
+"""Sample tool. A working example — add your own tools as new files in this package.
+
+Decorate a function with ``@tool`` (LangChain) and it becomes an agent tool; the package
+auto-collects it via ``all_tools()``, which ``create_agent_graph`` uses.
+"""
+
+from datetime import datetime
+
+from langchain_core.tools import tool
+
+
+@tool
+def get_current_time() -> str:
+    """Get the current date and time."""
+    return datetime.now().isoformat()

databricks_agentbricks/templates/agent-langgraph/agent/tools/send_message.py

@@ -0,0 +1,17 @@
+"""A side-effecting sample tool, gated by human approval.
+
+Unlike ``get_current_time`` (a harmless read), this tool stands in for an action with real
+consequences — sending a message. ``agent/agent.py`` lists it in ``REQUIRE_APPROVAL``, so before it
+runs the agent pauses and asks a human to approve / edit / reject the call. Swap the body for a real
+send; the approval gate is what the template is demonstrating.
+"""
+
+from langchain_core.tools import tool
+
+
+@tool
+def send_message(recipient: str, body: str) -> str:
+    """Send a message to a recipient. Use when the user asks to notify or message someone."""
+    # A real implementation would call an email/Slack/SMS API here. The point of this template is the
+    # human-approval gate in front of it (see REQUIRE_APPROVAL in agent/agent.py), not the delivery.
+    return f"Message sent to {recipient}: {body}"

databricks_agentbricks/templates/agent-langgraph/app.yaml

@@ -0,0 +1,15 @@
+command: ["uv", "run", "start-server"]
+# databricks apps listen by default on port 8000
+#
+# Agent Bricks injects the deployed Runtime Store endpoint. The LangGraph checkpointer remains
+# in-process unless a managed Session Store is bound. Tracing is bound with `ab tracing bind
+# --experiment-name <path>` (ab deploy then wires the env below; `ab dev` traces to a local
+# MLflow server). To set a deployment's tracing env by hand instead:
+#
+# env:
+#   # Tracing (set a destination + an experiment). Destination: MLFLOW_TRACKING_URI or
+#   # MLFLOW_TRACING_DESTINATION. Experiment: MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME.
+#   - name: MLFLOW_TRACKING_URI
+#     value: "databricks"
+#   - name: MLFLOW_EXPERIMENT_ID
+#     value: "<experiment-id>"

databricks_agentbricks/templates/agent-langgraph/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "agent-langgraph"
+version = "0.1.0"
+description = "LangGraph agent on the Agent Bricks durable runtime for Databricks Apps"
+readme = "README.md"
+authors = [
+    { name = "Agent Developer", email = "developer@example.com" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    # Agent Bricks includes the HTTP runtime; this extra adds the langgraph framework adapter.
+    "databricks-agentbricks[langgraph]>=0.2.0",
+    "uvicorn>=0.41.0",
+    "python-dotenv>=1.2.1",
+    "databricks-sdk>=0.124.0",
+    "databricks-agents>=1.9.3",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["agent", "runtime"]
+
+
+[dependency-groups]
+dev = [
+    "hatchling>=1.28.0",
+    "pytest>=9.0.2",
+    "pytest-asyncio>=1.3.0",
+]
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[project.scripts]
+start-server = "runtime.main:main"