10xgraph-api 0.7.0__py3-none-any.whl

tenxgraph_api/src/app/routers/__init__.py

@@ -0,0 +1,4 @@
+from .setup_router import init_routes
+
+
+__all__ = ["init_routes"]

tenxgraph_api/src/app/routers/ag_ui/__init__.py

@@ -0,0 +1,10 @@
+"""AG-UI protocol endpoint (``POST /v1/ag-ui``).
+
+Needs the optional ``ag-ui-protocol`` package, so it is only imported when ``ag_ui.enabled``
+is set in 10xgraph.json.
+"""
+
+from .router import router
+
+
+__all__ = ["router"]

tenxgraph_api/src/app/routers/ag_ui/converter.py

@@ -0,0 +1,195 @@
+"""Turn an AG-UI ``RunAgentInput`` into 10xGraph graph input.
+
+AG-UI clients send the whole conversation on every run, while the thread's checkpoint already
+holds everything the graph has seen. Only the trailing user turn (or the tool results that
+answer a pending client-side tool call) is new, so that is all the graph receives. Messages the
+client claims came from the assistant, system or developer are never forwarded: the server's
+checkpoint is the record of what the model said and was told.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from ag_ui.core import RunAgentInput
+from pydantic import ValidationError
+from tenxgraph.core.state import (
+    AudioBlock,
+    DocumentBlock,
+    ImageBlock,
+    Message,
+    TextBlock,
+    ToolResultBlock,
+    VideoBlock,
+)
+from tenxgraph.core.state.message_block import MediaRef
+
+
+_MEDIA_BLOCKS = {
+    "image": ImageBlock,
+    "audio": AudioBlock,
+    "video": VideoBlock,
+    "document": DocumentBlock,
+}
+
+# Roles the graph accepts from a client. Assistant turns come from the checkpoint, and client
+# system/developer prompts would let a caller rewrite the agent's instructions.
+_CLIENT_ROLES = frozenset({"user", "tool"})
+
+
+def parse_run_input(body: Any) -> RunAgentInput:
+    """Validate a request body as ``RunAgentInput``.
+
+    Older AG-UI clients (CopilotKit up to at least 1.75) still send the legacy ``binary``
+    content part, which the 1.0 SDK rejects; it is rewritten to the matching media part first.
+
+    Raises:
+        ValueError: The body is not a valid ``RunAgentInput``.
+    """
+    if isinstance(body, dict) and isinstance(body.get("messages"), list):
+        body = {**body, "messages": [_upgrade_message(m) for m in body["messages"]]}
+    try:
+        return RunAgentInput.model_validate(body)
+    except ValidationError as exc:
+        raise ValueError(f"Invalid AG-UI RunAgentInput: {exc}") from exc
+
+
+# Limits on the tools an AG-UI client may bring to a run. The name rule matches what model
+# providers accept for function names.
+MAX_CLIENT_TOOLS = 64
+MAX_TOOL_DESCRIPTION_CHARS = 4096
+MAX_TOOL_SCHEMA_BYTES = 16 * 1024
+_TOOL_NAME = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+
+
+def check_client_tools(tools: list[Any]) -> None:
+    """Reject client tool lists that are malformed or oversized.
+
+    Client tools put client-written text (names, descriptions, schemas) in front of the model and
+    in every request to the provider, so they are bounded before anything runs.
+
+    Raises:
+        ValueError: A tool breaks one of the limits above.
+    """
+    if len(tools) > MAX_CLIENT_TOOLS:
+        raise ValueError(f"At most {MAX_CLIENT_TOOLS} client tools are allowed per run")
+    seen: set[str] = set()
+    for tool in tools:
+        if not _TOOL_NAME.match(tool.name or ""):
+            raise ValueError(
+                f"Invalid client tool name {tool.name!r}: use 1-64 letters, digits, '_' or '-'"
+            )
+        if tool.name in seen:
+            raise ValueError(f"Duplicate client tool name {tool.name!r}")
+        seen.add(tool.name)
+        if len(tool.description or "") > MAX_TOOL_DESCRIPTION_CHARS:
+            raise ValueError(
+                f"Client tool {tool.name!r}: description is longer than "
+                f"{MAX_TOOL_DESCRIPTION_CHARS} characters"
+            )
+        schema_size = len(json.dumps(tool.parameters or {}, default=str).encode())
+        if schema_size > MAX_TOOL_SCHEMA_BYTES:
+            raise ValueError(
+                f"Client tool {tool.name!r}: parameters schema is larger than "
+                f"{MAX_TOOL_SCHEMA_BYTES} bytes"
+            )
+
+
+def _upgrade_message(message: Any) -> Any:
+    if not isinstance(message, dict) or not isinstance(message.get("content"), list):
+        return message
+    return {**message, "content": [_upgrade_part(p) for p in message["content"]]}
+
+
+def _upgrade_part(part: Any) -> Any:
+    if not isinstance(part, dict) or part.get("type") != "binary":
+        return part
+    mime_type = part.get("mimeType") or part.get("mime_type") or ""
+    kind = mime_type.split("/", 1)[0]
+    part_type = kind if kind in ("image", "audio", "video") else "document"
+    if part.get("data"):
+        source = {"type": "data", "value": part["data"], "mimeType": mime_type}
+    elif part.get("url"):
+        source = {"type": "url", "value": part["url"], "mimeType": mime_type}
+    else:
+        source = {"type": "file", "value": part.get("id") or "", "mimeType": mime_type}
+    return {"type": part_type, "source": source}
+
+
+def select_new_messages(
+    messages: list[Any],
+    known_ids: set[str] | frozenset[str] = frozenset(),
+    answered_call_ids: set[str] | frozenset[str] = frozenset(),
+) -> list[Any]:
+    """The client messages the graph has not seen yet.
+
+    Args:
+        messages: ``RunAgentInput.messages``, the full client-side history.
+        known_ids: Message ids already in the thread's checkpoint.
+        answered_call_ids: Tool call ids the checkpoint already has a result for. Clients mint
+            a fresh id for each tool message, so results are matched by call id instead.
+    """
+    turn: list[Any] = []
+    for message in reversed(messages):
+        if message.role == "assistant":
+            break
+        turn.append(message)
+    turn.reverse()
+    return [
+        m
+        for m in turn
+        if m.role in _CLIENT_ROLES
+        and m.id not in known_ids
+        and not (m.role == "tool" and m.tool_call_id in answered_call_ids)
+    ]
+
+
+def to_tenxgraph_messages(messages: list[Any]) -> list[Message]:
+    """Convert AG-UI user and tool messages to 10xGraph messages, keeping their ids."""
+    converted: list[Message] = []
+    for message in messages:
+        if message.role == "user":
+            blocks = _content_blocks(message.content)
+            if blocks:
+                converted.append(Message(message_id=message.id, role="user", content=blocks))
+        elif message.role == "tool":
+            error = getattr(message, "error", None)
+            output = error or _text(message.content)
+            result = ToolResultBlock(
+                call_id=message.tool_call_id,
+                output=output,
+                is_error=bool(error),
+                status="failed" if error else "completed",
+            )
+            converted.append(Message(message_id=message.id, role="tool", content=[result]))
+    return converted
+
+
+def _content_blocks(content: Any) -> list[Any]:
+    if isinstance(content, str):
+        return [TextBlock(text=content)] if content else []
+    blocks: list[Any] = []
+    for part in content or []:
+        if part.type == "text":
+            if part.text:
+                blocks.append(TextBlock(text=part.text))
+        elif part.type in _MEDIA_BLOCKS:
+            blocks.append(_MEDIA_BLOCKS[part.type](media=_media_ref(part.source)))
+    return blocks
+
+
+def _media_ref(source: Any) -> MediaRef:
+    mime_type = getattr(source, "mime_type", None)
+    if source.type == "data":
+        return MediaRef(kind="data", data_base64=source.value, mime_type=mime_type)
+    if source.type == "url":
+        return MediaRef(kind="url", url=source.value, mime_type=mime_type)
+    return MediaRef(kind="file_id", file_id=source.value, mime_type=mime_type)
+
+
+def _text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    return "".join(part.text for part in content or [] if part.type == "text")

tenxgraph_api/src/app/routers/ag_ui/event_mapper.py

@@ -0,0 +1,353 @@
+"""Translate 10xGraph ``StreamChunk`` output into AG-UI protocol events.
+
+One mapper handles one run. It tracks which text, reasoning and step blocks are open so the
+event stream always follows the AG-UI ordering rules: ``RUN_STARTED`` first, every ``START``
+before its ``CONTENT`` and ``END``, everything closed before the single terminal
+``RUN_FINISHED`` or ``RUN_ERROR``.
+
+10xGraph emits a model turn either as a series of delta messages followed by a final message
+with a new id (streaming providers), or as one final message (plain function nodes). Text that
+was already streamed is not sent again from the final message. Tool calls are only complete in
+the final message, so ``TOOL_CALL_START/ARGS/END`` are sent from there in one go.
+
+A graph paused by ``interrupt()`` ends the run with ``RUN_FINISHED`` and an ``interrupt``
+outcome, which clients answer with ``RunAgentInput.resume``. Otherwise ``RUN_FINISHED`` carries no
+``outcome``: CopilotKit's pinned ``@ag-ui/core`` (0.0.59 in CopilotKit 1.75) rejects the
+``success`` outcome's newer fields and the ``cancelled`` outcome.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import ag_ui.core as agui
+from ag_ui.core import (
+    BaseEvent,
+    Interrupt,
+    ReasoningEndEvent,
+    ReasoningMessageContentEvent,
+    ReasoningMessageEndEvent,
+    ReasoningMessageStartEvent,
+    ReasoningStartEvent,
+    RunErrorEvent,
+    RunFinishedEvent,
+    RunFinishedInterruptOutcome,
+    RunStartedEvent,
+    StateSnapshotEvent,
+    StepFinishedEvent,
+    StepStartedEvent,
+    TextMessageContentEvent,
+    TextMessageEndEvent,
+    TextMessageStartEvent,
+    ToolCallArgsEvent,
+    ToolCallEndEvent,
+    ToolCallResultEvent,
+    ToolCallStartEvent,
+)
+from tenxgraph.core.state import AgentState, Message, StreamChunk, StreamEvent, ToolCallBlock
+from tenxgraph.core.state.message_block import RemoteToolCallBlock
+from tenxgraph.utils.constants import END, START
+
+
+# Graph bookkeeping nodes, not steps a user cares about.
+_HIDDEN_NODES = frozenset({START, END})
+
+# AgentState fields that are not application state: the conversation travels as messages,
+# and execution metadata is internal.
+_INTERNAL_STATE_FIELDS = frozenset({"context", "context_summary", "execution_meta"})
+
+
+def app_state(state: AgentState) -> dict[str, Any]:
+    """The application fields of ``state``, as JSON, for a ``STATE_SNAPSHOT``."""
+    return state.model_dump(mode="json", exclude=set(_INTERNAL_STATE_FIELDS))
+
+
+class AgUiEventMapper:
+    """Stateful translator for one AG-UI run.
+
+    Call :meth:`start` once, :meth:`map` for every chunk, then :meth:`finish`. After a
+    ``RUN_ERROR`` (from :meth:`fail` or an error chunk) every later call returns nothing.
+    """
+
+    def __init__(
+        self,
+        thread_id: str,
+        run_id: str,
+        initial_state: dict[str, Any] | None = None,
+    ) -> None:
+        self.thread_id = thread_id
+        self.run_id = run_id
+        self.finished = False
+        self._text_id: str | None = None
+        self._reasoning_id: str | None = None
+        # The text message the current model turn produced, as parent for its tool calls.
+        self._turn_text_id: str | None = None
+        self._turn_streamed = False
+        self._open_steps: list[str] = []
+        self._tool_calls: set[str] = set()
+        self._tool_results: set[str] = set()
+        self._last_state = initial_state or None
+        self._interrupt: dict[str, Any] | None = None
+
+    def start(self) -> list[BaseEvent]:
+        extra: dict[str, Any] = {}
+        protocol_version = getattr(agui, "PROTOCOL_VERSION", None)
+        if protocol_version and "protocol_version" in RunStartedEvent.model_fields:
+            extra["protocol_version"] = protocol_version
+        return [RunStartedEvent(thread_id=self.thread_id, run_id=self.run_id, **extra)]
+
+    def map(self, chunk: StreamChunk) -> list[BaseEvent]:
+        if self.finished:
+            return []
+        if chunk.event == StreamEvent.MESSAGE and chunk.message is not None:
+            return self._on_message(chunk.message)
+        if chunk.event == StreamEvent.UPDATES:
+            return self._on_update(chunk.data or {})
+        if chunk.event == StreamEvent.STATE and chunk.state is not None:
+            return self._on_state(chunk.state)
+        if chunk.event == StreamEvent.ERROR:
+            return self._on_error(chunk.data or {})
+        return []
+
+    def map_state(self, state: AgentState) -> list[BaseEvent]:
+        """A ``STATE_SNAPSHOT`` for ``state``, when it differs from what the client has."""
+        if self.finished:
+            return []
+        return self._on_state(state)
+
+    def report_interrupt(self, interrupt: dict[str, Any]) -> None:
+        """End the run as paused at ``interrupt`` (a ``tenxgraph`` ``Interrupt`` as JSON)."""
+        self._interrupt = interrupt
+
+    def finish(self) -> list[BaseEvent]:
+        if self.finished:
+            return []
+        events = self._close_all()
+        self.finished = True
+        extra: dict[str, Any] = {}
+        if self._interrupt is not None:
+            extra["outcome"] = RunFinishedInterruptOutcome(
+                interrupts=[_agui_interrupt(self._interrupt)]
+            )
+        events.append(RunFinishedEvent(thread_id=self.thread_id, run_id=self.run_id, **extra))
+        return events
+
+    def fail(self, message: str, code: str | None = None) -> list[BaseEvent]:
+        if self.finished:
+            return []
+        events = self._close_all()
+        self.finished = True
+        events.append(RunErrorEvent(message=message, code=code))
+        return events
+
+    # ------------------------------------------------------------------ messages
+
+    def _on_message(self, message: Message) -> list[BaseEvent]:
+        if message.role == "assistant":
+            return self._on_delta(message) if message.delta else self._on_final(message)
+        if message.role == "tool":
+            return self._on_tool_result(message)
+        return []  # the user's own message echoed back
+
+    def _on_delta(self, message: Message) -> list[BaseEvent]:
+        message_id = str(message.message_id)
+        events: list[BaseEvent] = []
+        for block in message.content:
+            if block.type == "reasoning" and block.summary:
+                events += self._reasoning(message_id, block.summary)
+            elif block.type == "text" and block.text:
+                events += self._text(message_id, block.text)
+        return events + self._on_tool_calls(message)
+
+    def _on_final(self, message: Message) -> list[BaseEvent]:
+        message_id = str(message.message_id)
+        events: list[BaseEvent] = []
+        if not self._turn_streamed:
+            reasoning = "\n\n".join(
+                b.summary for b in message.content if b.type == "reasoning" and b.summary
+            )
+            text = "".join(b.text for b in message.content if b.type == "text" and b.text)
+            if reasoning:
+                events += self._reasoning(message_id, reasoning)
+            if text:
+                events += self._text(message_id, text)
+        events += self._close_reasoning() + self._close_text()
+        events += self._on_tool_calls(message, fallback_parent=message_id)
+        self._turn_text_id = None
+        self._turn_streamed = False
+        return events
+
+    def _on_tool_calls(
+        self, message: Message, fallback_parent: str | None = None
+    ) -> list[BaseEvent]:
+        calls = [c for c in _tool_calls(message) if c[0] not in self._tool_calls]
+        if not calls:
+            return []
+        events = self._close_reasoning() + self._close_text()
+        parent = self._turn_text_id
+        if parent is None:
+            # Announce the parent message so the client has something to attach the call to.
+            parent = fallback_parent or str(message.message_id)
+            events += [
+                TextMessageStartEvent(message_id=parent, role="assistant"),
+                TextMessageEndEvent(message_id=parent),
+            ]
+            self._turn_text_id = parent
+        for call_id, name, arguments in calls:
+            self._tool_calls.add(call_id)
+            events += [
+                ToolCallStartEvent(
+                    tool_call_id=call_id, tool_call_name=name, parent_message_id=parent
+                ),
+                ToolCallArgsEvent(tool_call_id=call_id, delta=arguments),
+                ToolCallEndEvent(tool_call_id=call_id),
+            ]
+        return events
+
+    def _on_tool_result(self, message: Message) -> list[BaseEvent]:
+        events: list[BaseEvent] = []
+        for block in message.content:
+            if block.type != "tool_result" or block.call_id in self._tool_results:
+                continue
+            message_id = str(message.message_id)
+            if events:
+                message_id = f"{message_id}-{block.call_id}"
+            events.append(self._tool_result(message_id, block.call_id, _stringify(block.output)))
+        return events
+
+    def _tool_result(self, message_id: str, call_id: str, content: str) -> ToolCallResultEvent:
+        self._tool_results.add(call_id)
+        return ToolCallResultEvent(
+            message_id=message_id, tool_call_id=call_id, content=content, role="tool"
+        )
+
+    # --------------------------------------------------------- text and reasoning
+
+    def _text(self, message_id: str, delta: str) -> list[BaseEvent]:
+        events = self._close_reasoning()
+        if self._text_id != message_id:
+            events += self._close_text()
+            events.append(TextMessageStartEvent(message_id=message_id, role="assistant"))
+            self._text_id = message_id
+            self._turn_text_id = message_id
+        self._turn_streamed = True
+        events.append(TextMessageContentEvent(message_id=message_id, delta=delta))
+        return events
+
+    def _reasoning(self, message_id: str, delta: str) -> list[BaseEvent]:
+        reasoning_id = f"{message_id}-reasoning"
+        events = self._close_text()
+        if self._reasoning_id != reasoning_id:
+            events += self._close_reasoning()
+            events += [
+                ReasoningStartEvent(message_id=reasoning_id),
+                ReasoningMessageStartEvent(message_id=reasoning_id),
+            ]
+            self._reasoning_id = reasoning_id
+        self._turn_streamed = True
+        events.append(ReasoningMessageContentEvent(message_id=reasoning_id, delta=delta))
+        return events
+
+    def _close_text(self) -> list[BaseEvent]:
+        if self._text_id is None:
+            return []
+        events: list[BaseEvent] = [TextMessageEndEvent(message_id=self._text_id)]
+        self._text_id = None
+        return events
+
+    def _close_reasoning(self) -> list[BaseEvent]:
+        if self._reasoning_id is None:
+            return []
+        reasoning_id = self._reasoning_id
+        self._reasoning_id = None
+        return [
+            ReasoningMessageEndEvent(message_id=reasoning_id),
+            ReasoningEndEvent(message_id=reasoning_id),
+        ]
+
+    def _close_all(self) -> list[BaseEvent]:
+        events = self._close_reasoning() + self._close_text()
+        while self._open_steps:
+            events.append(StepFinishedEvent(step_name=self._open_steps.pop()))
+        return events
+
+    # ------------------------------------------------------ updates, state, errors
+
+    def _on_update(self, data: dict[str, Any]) -> list[BaseEvent]:
+        if data.get("status") == "interrupted" and isinstance(data.get("interrupt"), dict):
+            self.report_interrupt(data["interrupt"])
+            return []
+        node = data.get("node")
+        if not isinstance(node, str) or node in _HIDDEN_NODES:
+            return []
+        status = data.get("status")
+        if status == "invoking_node" and node not in self._open_steps:
+            self._open_steps.append(node)
+            return [StepStartedEvent(step_name=node)]
+        if status == "node_invoked" and node in self._open_steps:
+            self._open_steps.remove(node)
+            return [StepFinishedEvent(step_name=node)]
+        return []
+
+    def _on_state(self, state: AgentState) -> list[BaseEvent]:
+        snapshot = app_state(state)
+        if not snapshot or snapshot == self._last_state:
+            return []
+        self._last_state = snapshot
+        return [StateSnapshotEvent(snapshot=snapshot)]
+
+    def _on_error(self, data: dict[str, Any]) -> list[BaseEvent]:
+        if data.get("status") == "tool_failed":
+            # A failed tool is a result the model reacts to, not the end of the run.
+            call_id = data.get("tool_call_id")
+            if not call_id or call_id in self._tool_results:
+                return []
+            # ``error`` holds the tool's own message; ``reason`` is a generic summary.
+            reason = data.get("error") or data.get("reason") or "Tool failed"
+            return [self._tool_result(f"{call_id}-error", str(call_id), f"Error: {reason}")]
+        return self.fail(str(data.get("reason") or "Graph execution failed"), "GRAPH_ERROR")
+
+
+def _tool_calls(message: Message) -> list[tuple[str, str, str]]:
+    """``(id, name, JSON arguments)`` for each tool call in ``message``, without duplicates.
+
+    A call can appear both in ``tools_calls`` (OpenAI shape, drives execution) and as a
+    content block (drives rendering).
+    """
+    calls: dict[str, tuple[str, str, str]] = {}
+    for call in message.tools_calls or []:
+        if not isinstance(call, dict) or not call.get("id"):
+            continue
+        function = call.get("function") or {}
+        name = function.get("name") or call.get("name") or ""
+        arguments = function.get("arguments", call.get("args"))
+        if not isinstance(arguments, str):
+            arguments = json.dumps(arguments or {})
+        calls.setdefault(str(call["id"]), (str(call["id"]), str(name), arguments or "{}"))
+    for block in message.content:
+        if isinstance(block, ToolCallBlock | RemoteToolCallBlock) and block.id:
+            calls.setdefault(block.id, (block.id, block.name, json.dumps(block.args or {})))
+    return list(calls.values())
+
+
+def _agui_interrupt(interrupt: dict[str, Any]) -> Interrupt:
+    """An AG-UI ``Interrupt`` for a ``tenxgraph`` interrupt; its payload goes in metadata."""
+    return Interrupt(
+        id=str(interrupt.get("id")),
+        reason=str(interrupt.get("reason") or "input_required"),
+        message=interrupt.get("message"),
+        tool_call_id=interrupt.get("tool_call_id"),
+        response_schema=interrupt.get("response_schema"),
+        metadata={"value": interrupt.get("value"), "node": interrupt.get("node")},
+    )
+
+
+def _stringify(output: Any) -> str:
+    if output is None:
+        return ""
+    if isinstance(output, str):
+        return output
+    if hasattr(output, "model_dump"):
+        output = output.model_dump(mode="json")
+    return json.dumps(output, default=str)

tenxgraph_api/src/app/routers/ag_ui/router.py

@@ -0,0 +1,90 @@
+from typing import Any
+
+from ag_ui.encoder import EventEncoder
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import StreamingResponse
+from injectq.integrations import InjectAPI
+
+from tenxgraph_api.src.app.core import logger
+from tenxgraph_api.src.app.core.auth.authorization import AuthorizationBackend
+from tenxgraph_api.src.app.core.auth.permissions import RequirePermission
+from tenxgraph_api.src.app.core.auth.request_config import normalize_thread_id
+from tenxgraph_api.src.app.core.config.graph_config import GraphConfig
+from tenxgraph_api.src.app.routers.graph.services.graph_service import GraphService
+
+from .converter import check_client_tools, parse_run_input
+from .service import stream_ag_ui
+
+
+router = APIRouter(
+    tags=["AG-UI"],
+)
+
+
+@router.post(
+    "/v1/ag-ui",
+    summary="Run the graph over the AG-UI protocol",
+    description=(
+        "Accepts an AG-UI RunAgentInput and streams the graph run as AG-UI events over "
+        "server-sent events, for AG-UI clients such as CopilotKit. Enabled with "
+        '"ag_ui": {"enabled": true} in 10xgraph.json.'
+    ),
+    openapi_extra={
+        "requestBody": {
+            "required": True,
+            "content": {"application/json": {"schema": {"type": "object"}}},
+        }
+    },
+)
+async def run_ag_ui(
+    request: Request,
+    service: GraphService = InjectAPI(GraphService),
+    user: dict[str, Any] = Depends(RequirePermission("graph", "stream")),
+    # Abstract type as the DI key, as in graph/router.py (see the mypy backlog in pyproject).
+    authz: AuthorizationBackend = InjectAPI(AuthorizationBackend),  # type: ignore[type-abstract]
+    config: GraphConfig = InjectAPI(GraphConfig),
+):
+    """
+    Stream one AG-UI run.
+
+    AG-UI names the thread ``threadId``, which the generic permission check does not read, so
+    thread ownership is checked here, the same way the WebSocket stream checks it: only when
+    auth is configured, since an unauthenticated server has no owners to tell apart.
+    """
+    try:
+        body = await request.json()
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail="Request body must be JSON") from exc
+    try:
+        run_input = parse_run_input(body)
+        check_client_tools(run_input.tools or [])
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+
+    thread_id = normalize_thread_id(run_input.thread_id)
+    if thread_id is None:
+        raise HTTPException(status_code=422, detail="threadId is required")
+    run_input.thread_id = thread_id
+    if config.auth_config() and not await authz.authorize(
+        user, "graph", "stream", resource_id=thread_id
+    ):
+        raise HTTPException(status_code=403, detail="Not allowed to access this thread")
+
+    logger.info("AG-UI run %s received for thread %s", run_input.run_id, thread_id)
+    encoder = EventEncoder(accept=request.headers.get("accept") or "")
+    return StreamingResponse(
+        stream_ag_ui(
+            service,
+            run_input,
+            user,
+            encoder,
+            allow_client_tools=config.ag_ui.allow_client_tools,
+        ),
+        media_type=encoder.get_content_type(),
+        headers={
+            "Cache-Control": "no-cache, no-transform",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no",  # Disable nginx buffering
+            "Content-Encoding": "identity",  # Disable any content encoding (bypasses GZip)
+        },
+    )