interloper-api 0.90.0__tar.gz → 0.92.0__tar.gz

{interloper_api-0.90.0 → interloper_api-0.92.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: interloper-api
-Version: 0.90.0
+Version: 0.92.0
 Summary: Interloper FastAPI routes
 Author: Guillaume Onfroy
 Author-email: Guillaume Onfroy <guillaume@digitlcloud.com>
@@ -8,7 +8,7 @@ Requires-Dist: interloper-core
 Requires-Dist: interloper-db
 Requires-Dist: fastapi>=0.115.0
 Requires-Dist: google-auth>=2.0.0
-Requires-Dist: httpx>=0.28.0
+Requires-Dist: httpx2>=2.13.1
 Requires-Dist: psycopg2-binary>=2.9.0
 Requires-Dist: uvicorn[standard]>=0.41.0
 Requires-Dist: wsproto>=1.2.0

{interloper_api-0.90.0 → interloper_api-0.92.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "interloper-api"
-version = "0.90.0"
+version = "0.92.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -9,7 +9,7 @@ dependencies = [
     "interloper-db",
     "fastapi>=0.115.0",
     "google-auth>=2.0.0",
-    "httpx>=0.28.0",
+    "httpx2>=2.13.1",
     "psycopg2-binary>=2.9.0",
     "uvicorn[standard]>=0.41.0",
     "wsproto>=1.2.0",

{interloper_api-0.90.0 → interloper_api-0.92.0}/pyproject.toml.orig

@@ -3,7 +3,7 @@
 # ###############
 [project]
 name = "interloper-api"
-version = "0.90.0"
+version = "0.92.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 authors = [{ name = "Guillaume Onfroy", email = "guillaume@digitlcloud.com" }]
@@ -13,7 +13,7 @@ dependencies = [
     "interloper-db",
     "fastapi>=0.115.0",
     "google-auth>=2.0.0",
-    "httpx>=0.28.0",
+    "httpx2>=2.13.1",
     "psycopg2-binary>=2.9.0",
     "uvicorn[standard]>=0.41.0",
     "wsproto>=1.2.0",

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/app.py

@@ -15,6 +15,7 @@ from interloper_db import Store
 
 from interloper_api.dependencies import (
     set_admin_config,
+    set_agent,
     set_auth_config,
     set_catalog,
     set_features,
@@ -249,7 +250,11 @@ def _install_state(
         set_store(store)
     if catalog:
         set_catalog(catalog)
+    if agent_available:
+        from interloper.settings import AgentSettings
+        from interloper_agent import build_agent
 
+        set_agent(build_agent(settings.agent.model if settings else AgentSettings().model))
     set_features({"agent": agent_available})
 
     if settings:

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/dependencies/__init__.py

@@ -27,11 +27,13 @@ from interloper_api.dependencies.rbac import (
 )
 from interloper_api.dependencies.state import (
     AdminConfigDep,
+    AgentDep,
     AuthConfigDep,
     CatalogDep,
     QuotaDefaultsDep,
     StoreDep,
     get_admin_config,
+    get_agent,
     get_auth_config,
     get_catalog,
     get_features,
@@ -39,6 +41,7 @@ from interloper_api.dependencies.state import (
     get_smtp_config,
     get_store,
     set_admin_config,
+    set_agent,
     set_auth_config,
     set_catalog,
     set_features,
@@ -50,6 +53,7 @@ from interloper_api.dependencies.state import (
 __all__ = [
     "AdminConfigDep",
     "AdminDep",
+    "AgentDep",
     "AuthConfigDep",
     "CatalogDep",
     "CurrentUserDep",
@@ -61,6 +65,7 @@ __all__ = [
     "ViewerDep",
     "authorize_org_member",
     "get_admin_config",
+    "get_agent",
     "get_auth_config",
     "get_catalog",
     "get_current_org",
@@ -77,6 +82,7 @@ __all__ = [
     "require_super_admin",
     "require_viewer",
     "set_admin_config",
+    "set_agent",
     "set_auth_config",
     "set_catalog",
     "set_features",

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/dependencies/state.py

@@ -15,6 +15,7 @@ from interloper_db import Store
 
 _store: Store | None = None
 _catalog: Catalog | None = None
+_agent: Any | None = None
 _auth_config: Any | None = None
 _smtp_config: Any | None = None
 _features: dict[str, bool] = {}
@@ -42,6 +43,31 @@ def set_catalog(catalog: Catalog) -> None:
     _catalog = catalog
 
 
+def set_agent(agent: Any) -> None:
+    """Set the process-wide assistant.
+
+    Args:
+        agent: The built ``interloper_agent`` agent; typed loosely because the
+            agent extra is optional and this module must import without it.
+    """
+    global _agent
+    _agent = agent
+
+
+def get_agent() -> Any:
+    """Return the process-wide assistant.
+
+    Returns:
+        The agent the chat route runs.
+
+    Raises:
+        RuntimeError: If the agent has not been set.
+    """
+    if _agent is None:
+        raise RuntimeError("Agent not initialized. Call set_agent() first.")
+    return _agent
+
+
 def set_auth_config(auth_config: Any) -> None:
     """Set the global auth config.
 
@@ -176,6 +202,7 @@ def get_quota_defaults() -> Any:
 
 StoreDep = Annotated[Store, Depends(get_store)]
 CatalogDep = Annotated[Catalog, Depends(get_catalog)]
+AgentDep = Annotated[Any, Depends(get_agent)]
 AuthConfigDep = Annotated[Any, Depends(get_auth_config)]
 AdminConfigDep = Annotated[Any, Depends(get_admin_config)]
 QuotaDefaultsDep = Annotated[Any, Depends(get_quota_defaults)]

interloper_api-0.92.0/src/interloper_api/routes/agent.py

@@ -0,0 +1,296 @@
+"""Agent API: conversations with the assistant, streamed the Vercel AI SDK way.
+
+A conversation is a member's own: its history lives in the store and the
+server, not the client, is its source of truth. Each turn is one
+:meth:`~pydantic_ai.ui.vercel_ai.VercelAIAdapter.dispatch_request`: the
+client's request carries the new message (and any tool approvals or answers
+the app collected), the stored history is passed as ``message_history``, and
+the whole history is saved back when the run completes.
+
+Available when ``interloper-agent`` is installed.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import AsyncIterator
+from datetime import datetime
+from typing import Any
+from uuid import UUID
+
+from fastapi import APIRouter, Request, Response
+from interloper_agent import TURN_LIMITS
+from interloper_db.models import Conversation
+from interloper_toolkit import ToolkitContext
+from pydantic import BaseModel
+from pydantic_ai.agent import AgentRunResult
+from pydantic_ai.messages import ModelMessage, ModelMessagesTypeAdapter, ModelRequest, UserPromptPart
+from pydantic_ai.ui import UIEventStream
+from pydantic_ai.ui.vercel_ai import VercelAIAdapter, VercelAIEventStream
+from pydantic_ai.ui.vercel_ai.request_types import RequestData, UIMessage
+from pydantic_ai.ui.vercel_ai.response_types import BaseChunk
+
+from interloper_api.dependencies import AgentDep, CatalogDep, EditorDep, OrgIdDep, StoreDep, ViewerDep
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/agent", tags=["agent"])
+
+SDK_VERSION = 7
+"""The AI SDK major version the app speaks; tool approvals need at least 6."""
+
+
+class LoggedEventStream(VercelAIEventStream[ToolkitContext, Any]):
+    """The Vercel event stream, with a run's failure in the server log too.
+
+    The adapter answers a failed run with a 200 and an error chunk, which the
+    app renders as a generic message; without this, the cause would exist
+    nowhere on the server side.
+    """
+
+    async def on_error(self, error: Exception) -> AsyncIterator[BaseChunk]:
+        """Log the failure, then encode it for the client as the base class does.
+
+        Args:
+            error: The exception that ended the run.
+
+        Yields:
+            The protocol's error chunks.
+        """
+        logger.error("Agent turn failed: %s", error, exc_info=error)
+        async for chunk in super().on_error(error):
+            yield chunk
+
+
+class LoggedAdapter(VercelAIAdapter[ToolkitContext, Any]):
+    """The Vercel adapter, building :class:`LoggedEventStream`."""
+
+    def build_event_stream(self) -> UIEventStream[RequestData, BaseChunk, ToolkitContext, Any]:
+        """Build the event stream that also logs failures.
+
+        Returns:
+            The stream transformer for this request.
+        """
+        return LoggedEventStream(
+            self.run_input, accept=self.accept, sdk_version=self.sdk_version, server_message_id=self.server_message_id
+        )
+
+
+class ConversationResponse(BaseModel):
+    """A conversation as the list shows it."""
+
+    id: UUID
+    title: str | None
+    created_at: datetime | None
+    updated_at: datetime | None
+
+    @classmethod
+    def from_conversation(cls, conversation: Conversation) -> ConversationResponse:
+        """Project a conversation row.
+
+        Args:
+            conversation: The row.
+
+        Returns:
+            The response model.
+        """
+        return cls(
+            id=conversation.id,
+            title=conversation.title,
+            created_at=conversation.created_at,
+            updated_at=conversation.updated_at,
+        )
+
+
+class ConversationDetailResponse(ConversationResponse):
+    """A conversation with its history in the AI SDK's ``UIMessage`` shape."""
+
+    messages: list[dict[str, Any]]
+
+    @classmethod
+    def from_conversation(cls, conversation: Conversation) -> ConversationDetailResponse:
+        """Project a conversation row and render its history for the app.
+
+        Args:
+            conversation: The row.
+
+        Returns:
+            The response model, its messages as the app's ``useChat`` loads them.
+        """
+        history = ModelMessagesTypeAdapter.validate_python(conversation.messages)
+        messages = _fold_turns(VercelAIAdapter.dump_messages(history, sdk_version=SDK_VERSION))
+        return cls(
+            **ConversationResponse.from_conversation(conversation).model_dump(),
+            messages=[message.model_dump(by_alias=True, exclude_none=True) for message in messages],
+        )
+
+
+@router.post("/conversations", status_code=201)
+def create_conversation(user: EditorDep, org_id: OrgIdDep, store: StoreDep) -> ConversationResponse:
+    """Start a conversation in the active organisation.
+
+    Args:
+        user: The authenticated user, required to hold at least the ``editor`` role.
+        org_id: The active organisation's UUID.
+        store: The Store instance.
+
+    Returns:
+        The new, empty conversation.
+    """
+    return ConversationResponse.from_conversation(store.conversations.create(org_id, user.id))
+
+
+@router.get("/conversations")
+def list_conversations(user: ViewerDep, org_id: OrgIdDep, store: StoreDep) -> list[ConversationResponse]:
+    """List the caller's conversations in the active organisation, newest first.
+
+    Args:
+        user: The authenticated user, required to hold at least the ``viewer`` role.
+        org_id: The active organisation's UUID.
+        store: The Store instance.
+
+    Returns:
+        The conversations, as response models.
+    """
+    rows = store.conversations.list_all(org_id, user.id)
+    return [ConversationResponse.from_conversation(row) for row in rows]
+
+
+@router.get("/conversations/{conversation_id}")
+def get_conversation(
+    conversation_id: UUID, user: ViewerDep, org_id: OrgIdDep, store: StoreDep
+) -> ConversationDetailResponse:
+    """Read one of the caller's conversations with its history.
+
+    Args:
+        conversation_id: The conversation UUID.
+        user: The authenticated user, required to hold at least the ``viewer`` role.
+        org_id: The active organisation's UUID.
+        store: The Store instance.
+
+    Returns:
+        The conversation and its messages, as response models.
+    """
+    row = store.conversations.get(conversation_id, org_id=org_id, user_id=user.id)
+    return ConversationDetailResponse.from_conversation(row)
+
+
+@router.delete("/conversations/{conversation_id}", status_code=204)
+def delete_conversation(conversation_id: UUID, user: EditorDep, org_id: OrgIdDep, store: StoreDep) -> Response:
+    """Delete one of the caller's conversations.
+
+    Args:
+        conversation_id: The conversation UUID.
+        user: The authenticated user, required to hold at least the ``editor`` role.
+        org_id: The active organisation's UUID.
+        store: The Store instance.
+
+    Returns:
+        An empty response.
+    """
+    row = store.conversations.get(conversation_id, org_id=org_id, user_id=user.id)
+    store.conversations.delete(row.id)
+    return Response(status_code=204)
+
+
+@router.post("/conversations/{conversation_id}/chat")
+async def chat(
+    conversation_id: UUID,
+    request: Request,
+    user: EditorDep,
+    org_id: OrgIdDep,
+    store: StoreDep,
+    catalog: CatalogDep,
+    agent: AgentDep,
+) -> Response:
+    """Run one turn of a conversation and stream it as the AI SDK expects.
+
+    The request body is the AI SDK's: the client's message list, of which the
+    adapter takes the new user message and any approvals or tool answers.
+    Everything before comes from the stored history, saved back whole once
+    the run completes.
+
+    Args:
+        conversation_id: The conversation UUID.
+        request: The raw request, handed to the adapter.
+        user: The authenticated user, required to hold at least the ``editor`` role.
+        org_id: The active organisation's UUID.
+        store: The Store instance.
+        catalog: The Catalog instance.
+        agent: The assistant.
+
+    Returns:
+        The turn as a ``text/event-stream`` response.
+    """
+    conversation = store.conversations.get(conversation_id, org_id=org_id, user_id=user.id)
+    context = ToolkitContext(
+        store=store,
+        catalog=catalog.dump(),
+        org_id=org_id,
+        role=store.organisations.member_role(user.id, org_id) or "viewer",
+    )
+
+    def save(result: AgentRunResult[Any]) -> None:
+        messages = result.all_messages()
+        history = ModelMessagesTypeAdapter.dump_python(messages, mode="json")
+        store.conversations.save(conversation.id, history, title=_first_prompt(messages))
+        usage = result.usage
+        logger.info(
+            "Agent turn on conversation %s: %d requests, %d input tokens, %d output tokens, %d messages stored",
+            conversation.id,
+            usage.requests,
+            usage.input_tokens,
+            usage.output_tokens,
+            len(messages),
+        )
+
+    return await LoggedAdapter.dispatch_request(
+        request,
+        agent=agent,
+        sdk_version=SDK_VERSION,
+        deps=context,
+        message_history=ModelMessagesTypeAdapter.validate_python(conversation.messages),
+        conversation_id=str(conversation.id),
+        usage_limits=TURN_LIMITS,
+        on_complete=save,
+    )
+
+
+def _fold_turns(messages: list[UIMessage]) -> list[UIMessage]:
+    """Merge each turn's assistant messages into one, as the stream builds them.
+
+    ``dump_messages`` yields one assistant message per model response, so a
+    turn with several tool rounds restores as several messages; the app
+    renders each with its own avatar. Live, the SDK accumulates a turn into
+    one message, and a reload should read the same.
+
+    Args:
+        messages: The history as the adapter dumps it.
+
+    Returns:
+        The history with consecutive assistant messages folded into the first.
+    """
+    folded: list[UIMessage] = []
+    for message in messages:
+        last = folded[-1] if folded else None
+        if last is not None and last.role == "assistant" and message.role == "assistant":
+            last.parts.extend(message.parts)
+        else:
+            folded.append(message.model_copy(update={"parts": list(message.parts)}))
+    return folded
+
+
+def _first_prompt(messages: list[ModelMessage]) -> str | None:
+    """The first thing the user said, which titles the conversation.
+
+    Args:
+        messages: The conversation's history.
+
+    Returns:
+        The first user prompt's text, or ``None`` when there is none yet.
+    """
+    for message in messages:
+        if isinstance(message, ModelRequest):
+            for part in message.parts:
+                if isinstance(part, UserPromptPart) and isinstance(part.content, str):
+                    return part.content
+    return None

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/routes/auth.py

@@ -9,7 +9,7 @@ from urllib.parse import urlencode
 from uuid import UUID
 from zoneinfo import ZoneInfo
 
-import httpx
+import httpx2
 from fastapi import APIRouter, Cookie, HTTPException, Response
 from fastapi.responses import RedirectResponse
 from interloper.errors import NotFoundError
@@ -158,7 +158,7 @@ def google_callback(
     if not client_id or not client_secret:
         raise HTTPException(status_code=500, detail="Google OAuth not configured")
 
-    token_resp = httpx.post(
+    token_resp = httpx2.post(
         GOOGLE_TOKEN_URL,
         data={
             "code": code,
@@ -176,7 +176,7 @@ def google_callback(
     if not access_token:
         raise HTTPException(status_code=401, detail="No access token in response")
 
-    userinfo_resp = httpx.get(
+    userinfo_resp = httpx2.get(
         GOOGLE_USERINFO_URL,
         headers={"Authorization": f"Bearer {access_token}"},
     )

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/routes/components.py

@@ -22,7 +22,7 @@ import logging
 from typing import Annotated, Any, Literal
 from uuid import UUID
 
-import httpx
+import httpx2
 from fastapi import APIRouter, HTTPException, Query
 from interloper.component import KINDS
 from interloper.connection.base import Connection
@@ -676,7 +676,7 @@ def handle_error(error: Exception, context: str) -> None:
     """
     logger.error("Error %s: %s", context, error)
 
-    if isinstance(error, httpx.HTTPStatusError):
+    if isinstance(error, httpx2.HTTPStatusError):
         status = error.response.status_code
         if status in (401, 403):
             raise HTTPException(status_code=status, detail=f"Authorization failed while {context}.")
@@ -830,16 +830,16 @@ class CheckResponse(BaseModel):
 
         if isinstance(exception, ConnectionCheckError):
             return cls(ok=False, live=True, category="error", message=str(exception))
-        if isinstance(exception, httpx.HTTPStatusError):
+        if isinstance(exception, httpx2.HTTPStatusError):
             status = exception.response.status_code
             if status in (401, 403):
                 return cls(ok=False, live=True, category="auth", message="The provider rejected the credentials.")
             return cls(
                 ok=False, live=True, category="error", message=f"The provider responded with HTTP {status}."
             )
-        if isinstance(exception, (TimeoutError, httpx.TimeoutException)):
+        if isinstance(exception, (TimeoutError, httpx2.TimeoutException)):
             return cls(ok=False, live=True, category="network", message="The provider did not respond in time.")
-        if isinstance(exception, httpx.TransportError):
+        if isinstance(exception, httpx2.TransportError):
             return cls(ok=False, live=True, category="network", message="The provider could not be reached.")
         return cls(ok=False, live=True, category="error", message="The connection check failed unexpectedly.")
 

{interloper_api-0.90.0 → interloper_api-0.92.0}/src/interloper_api/routes/oauth.py

@@ -22,7 +22,7 @@ import logging
 import os
 from typing import Any
 
-import httpx
+import httpx2
 from fastapi import APIRouter, HTTPException
 from interloper.oauth import PROVIDERS, OAuthAppCredentials
 from pydantic import BaseModel
@@ -106,9 +106,10 @@ async def exchange_authorization_code(
 ) -> dict[str, Any]:
     """Exchange an authorization code for tokens. Requires authentication.
 
-    Returns only the provider's token response (e.g. ``refresh_token``); the
-    in-house OAuth credentials are never included — connections resolve them
-    from env at runtime.
+    Returns only the provider's token response (e.g. ``refresh_token``), read
+    through the provider's own parser so dialect envelopes never reach the
+    browser; the in-house OAuth credentials are never included — connections
+    resolve them from env at runtime.
 
     Args:
         provider: The registry key of the provider to exchange against.
@@ -117,11 +118,12 @@ async def exchange_authorization_code(
             identity itself is not used.
 
     Returns:
-        The provider's raw token response.
+        The provider's token response, credentials at the top level.
 
     Raises:
         HTTPException: 400 when the provider is unknown or has no credentials
-            configured, 500 when the exchange itself fails.
+            configured, 500 when the exchange itself fails — including a
+            rejection the provider reports inside a 200 body.
     """
     spec = PROVIDERS.get(provider)
     if spec is None:
@@ -139,12 +141,13 @@ async def exchange_authorization_code(
             client_id=config.client_id,
             client_secret=config.client_secret,
         )
-        async with httpx.AsyncClient(timeout=30, follow_redirects=True) as client:
+        async with httpx2.AsyncClient(timeout=30, follow_redirects=True) as client:
             response = await client.send(request)
         response.raise_for_status()
+        tokens = spec.parse_authorization_code_response(response.json())
         logger.info("Successfully exchanged auth code for provider %s", provider)
-        return response.json()
-    except httpx.HTTPStatusError as exception:
+        return tokens
+    except httpx2.HTTPStatusError as exception:
         detail = exception.response.text
         logger.error("Token exchange failed for %s: %s %s", provider, exception.response.status_code, detail)
         raise HTTPException(status_code=500, detail=f"Failed to exchange auth code: {detail}")

interloper_api-0.90.0/src/interloper_api/routes/agent.py

@@ -1,289 +0,0 @@
-"""Agent API: ADK-powered chat sessions with SSE streaming.
-
-Provides endpoints for creating agent chat sessions, sending messages,
-and streaming responses. The ADK Runner executes the interloper agent
-in-process, reusing the API's authenticated Store and catalog.
-
-Available when ``interloper-agent`` is installed.
-"""
-
-from __future__ import annotations
-
-import logging
-from collections.abc import AsyncIterator
-from typing import Any
-
-from fastapi import APIRouter, HTTPException, Response
-from fastapi.responses import StreamingResponse
-from google.adk.apps import App
-from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
-from google.adk.runners import Runner
-from google.adk.sessions.in_memory_session_service import InMemorySessionService
-from google.genai import types
-from interloper.catalog.base import Catalog
-from interloper_db import Store
-from pydantic import BaseModel
-
-from interloper_api.dependencies import (
-    CatalogDep,
-    EditorDep,
-    OrgIdDep,
-    StoreDep,
-    ViewerDep,
-)
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/agent", tags=["agent"])
-
-APP_NAME = "interloper_agent"
-
-# -- Lazy runner singleton -----------------------------------------------------
-
-_runner: Runner | None = None
-_session_service: InMemorySessionService | None = None
-
-
-def _get_session_service() -> InMemorySessionService:
-    """Return the shared session service, creating it on first call.
-
-    Returns:
-        The process-wide in-memory session service.
-    """
-    global _session_service
-    if _session_service is None:
-        _session_service = InMemorySessionService()
-    return _session_service
-
-
-def _get_runner(store: Store, catalog: Catalog) -> Runner:
-    """Return the shared Runner, creating it on first call.
-
-    On first call, injects the API's Store and catalog into the agent
-    context so that agent tools can access them.
-
-    Args:
-        store: The Store instance (from API dependencies).
-        catalog: The Catalog instance (from API dependencies).
-
-    Returns:
-        The process-wide ADK Runner.
-    """
-    global _runner
-    if _runner is None:
-        from interloper_agent.agent import root_agent
-        from interloper_agent.context import set_catalog, set_store
-
-        if store is not None:
-            set_store(store)
-        if catalog is not None:
-            set_catalog(catalog)
-
-        app = App(name=APP_NAME, root_agent=root_agent)
-        _runner = Runner(
-            app=app,
-            session_service=_get_session_service(),
-            artifact_service=InMemoryArtifactService(),
-        )
-        logger.info("Agent runner initialized")
-    return _runner
-
-
-# -- Request / response models -------------------------------------------------
-
-
-class ChatRequest(BaseModel):
-    """Request body for sending a chat message."""
-
-    message: str
-
-
-class SessionResponse(BaseModel):
-    """Response body for an agent session."""
-
-    id: str
-    user_id: str
-    app_name: str
-    state: dict[str, Any]
-    last_update_time: float
-    event_count: int
-
-    @classmethod
-    def from_session(cls, session: Any) -> SessionResponse:
-        """Convert an ADK Session to a response model.
-
-        Args:
-            session: The ADK Session object.
-
-        Returns:
-            The response model.
-        """
-        return cls(
-            id=session.id,
-            user_id=session.user_id,
-            app_name=session.app_name,
-            state=session.state,
-            last_update_time=session.last_update_time,
-            event_count=len(session.events),
-        )
-
-
-# -- Endpoints -----------------------------------------------------------------
-
-
-@router.post("/sessions")
-async def create_session(
-    user: EditorDep,
-    org_id: OrgIdDep,
-    store: StoreDep,
-    catalog: CatalogDep,
-) -> SessionResponse:
-    """Create a new agent chat session.
-
-    The active ``org_id`` and the user's role in it are stamped into the ADK
-    session state: the org scopes every tool, the role gates the writes.
-
-    Args:
-        user: The authenticated user, required to hold at least the ``editor`` role.
-        org_id: The active organisation's UUID.
-        store: The Store instance.
-        catalog: The Catalog instance.
-
-    Returns:
-        The created session, as a response model.
-    """
-    _get_runner(store=store, catalog=catalog)
-    session_service = _get_session_service()
-    session = await session_service.create_session(
-        app_name=APP_NAME,
-        user_id=str(user.id),
-        state={"org_id": str(org_id), "role": store.organisations.member_role(user.id, org_id)},
-    )
-    return SessionResponse.from_session(session)
-
-
-@router.get("/sessions")
-async def list_sessions(
-    user: ViewerDep,
-) -> list[SessionResponse]:
-    """List all agent sessions for the current user.
-
-    Args:
-        user: The authenticated user, required to hold at least the ``viewer`` role.
-
-    Returns:
-        The user's agent sessions, as response models.
-    """
-    session_service = _get_session_service()
-    result = await session_service.list_sessions(
-        app_name=APP_NAME,
-        user_id=str(user.id),
-    )
-    sessions = result.sessions if hasattr(result, "sessions") else result
-    return [SessionResponse.from_session(s) for s in sessions]
-
-
-@router.get("/sessions/{session_id}")
-async def get_session(
-    session_id: str,
-    user: ViewerDep,
-) -> Response:
-    """Get a session with its full event history.
-
-    Returns the session object including all events (messages and tool calls).
-
-    Args:
-        session_id: The ADK session ID.
-        user: The authenticated user, required to hold at least the ``viewer`` role.
-
-    Returns:
-        The session serialized by the ADK's own model, as raw JSON.
-
-    Raises:
-        HTTPException: 404 if the user has no session with that ID.
-    """
-    session_service = _get_session_service()
-    session = await session_service.get_session(
-        app_name=APP_NAME,
-        user_id=str(user.id),
-        session_id=session_id,
-    )
-    if not session:
-        raise HTTPException(status_code=404, detail="Session not found")
-    return Response(
-        content=session.model_dump_json(exclude_none=True, by_alias=True),
-        media_type="application/json",
-    )
-
-
-@router.delete("/sessions/{session_id}")
-async def delete_session(
-    session_id: str,
-    user: EditorDep,
-) -> dict[str, str]:
-    """Delete an agent session.
-
-    Args:
-        session_id: The ADK session ID.
-        user: The authenticated user, required to hold at least the ``editor`` role.
-
-    Returns:
-        A confirmation that the session was deleted.
-
-    Raises:
-        HTTPException: 404 if the user has no session with that ID.
-    """
-    session_service = _get_session_service()
-    session = await session_service.get_session(
-        app_name=APP_NAME,
-        user_id=str(user.id),
-        session_id=session_id,
-    )
-    if not session:
-        raise HTTPException(status_code=404, detail="Session not found")
-    await session_service.delete_session(
-        app_name=APP_NAME,
-        user_id=str(user.id),
-        session_id=session_id,
-    )
-    return {"status": "deleted"}
-
-
-@router.post("/sessions/{session_id}/chat")
-async def chat(
-    session_id: str,
-    body: ChatRequest,
-    user: EditorDep,
-    store: StoreDep,
-    catalog: CatalogDep,
-) -> StreamingResponse:
-    """Send a message and stream the agent's response as SSE.
-
-    Each SSE ``data`` line contains a JSON-serialized ADK Event.
-    Events with ``content.parts`` containing ``text`` are the agent's
-    text responses. Events with ``function_call`` or ``function_response``
-    parts represent tool invocations.
-
-    Args:
-        session_id: The ADK session ID to continue.
-        body: The chat message to send.
-        user: The authenticated user, required to hold at least the ``editor`` role.
-        store: The Store instance.
-        catalog: The Catalog instance.
-
-    Returns:
-        A ``text/event-stream`` response carrying the agent's events.
-    """
-    runner = _get_runner(store=store, catalog=catalog)
-    user_id = str(user.id)
-    message = types.Content(parts=[types.Part(text=body.message)], role="user")
-
-    async def event_stream() -> AsyncIterator[str]:
-        async for event in runner.run_async(
-            user_id=user_id,
-            session_id=session_id,
-            new_message=message,
-        ):
-            yield f"data: {event.model_dump_json(exclude_none=True, by_alias=True)}\n\n"
-
-    return StreamingResponse(event_stream(), media_type="text/event-stream")