reflex-agentkit 0.1.0rc1__py3-none-any.whl

reflex_agentkit/__init__.py

@@ -0,0 +1,68 @@
+"""reflex-agentkit: the production UI layer for Python AI agents, built on Reflex and AG-UI.
+
+Reflex-dependent names (``AgentState``, components) are re-exported lazily through a
+module-level ``__getattr__`` (PEP 562), so ``import reflex_agentkit.core`` never imports
+``reflex`` (API §1, Constitution Art. 5).
+"""
+
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+from reflex_agentkit.core import (
+    AgentClient,
+    AgentKitError,
+    AgentSource,
+    AGUIAgent,
+    ClientTool,
+    ConfigurationError,
+    ErrorCode,
+    HttpAGUIClient,
+    InProcessAGUIClient,
+    RunStatus,
+    ToolCallStatus,
+    client_tool,
+)
+
+if TYPE_CHECKING:  # type checkers see the lazy names; runtime imports them on first use
+    from reflex_agentkit.components.chat import agent_chat as agent_chat
+    from reflex_agentkit.state.agent_state import AgentState as AgentState
+
+__version__ = "0.1.0rc1"
+
+# Public name -> module that defines it (API §1, §3).
+_LAZY_EXPORTS: dict[str, str] = {
+    "AgentState": "reflex_agentkit.state.agent_state",
+    "agent_chat": "reflex_agentkit.components.chat",
+}
+
+__all__ = [
+    "AGUIAgent",
+    "AgentClient",
+    "AgentKitError",
+    "AgentSource",
+    "ClientTool",
+    "ConfigurationError",
+    "ErrorCode",
+    "HttpAGUIClient",
+    "InProcessAGUIClient",
+    "RunStatus",
+    "ToolCallStatus",
+    "__version__",
+    "client_tool",
+    *_LAZY_EXPORTS,
+]
+
+
+def __getattr__(name: str) -> Any:
+    module_name = _LAZY_EXPORTS.get(name)
+    if module_name is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(importlib.import_module(module_name), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *_LAZY_EXPORTS})

reflex_agentkit/adapters/__init__.py

@@ -0,0 +1 @@
+"""Optional framework adapters that translate into AG-UI."""

reflex_agentkit/adapters/_require.py

@@ -0,0 +1,27 @@
+"""Import guard for the optional adapters (REQ-031.3, API §7.7)."""
+
+from __future__ import annotations
+
+import importlib
+
+from reflex_agentkit.core.errors import AdapterNotInstalledError
+
+__all__ = ["require"]
+
+
+def require(extra: str, *modules: str) -> None:
+    """Import ``modules`` or raise ``AdapterNotInstalledError`` naming the extra to install.
+
+    Args:
+        extra: The package extra, e.g. ``"pydantic-ai"``; the adapter module is
+            ``reflex_agentkit.adapters.<extra with "_" for "-">``.
+        modules: The modules the adapter needs.
+    """
+    adapter = f"reflex_agentkit.adapters.{extra.replace('-', '_')}"
+    for module in modules:
+        try:
+            importlib.import_module(module)
+        except ImportError:
+            raise AdapterNotInstalledError(
+                f"{adapter} requires the '{extra}' extra: pip install 'reflex-agentkit[{extra}]'"
+            ) from None

reflex_agentkit/adapters/langgraph.py

@@ -0,0 +1,277 @@
+"""LangGraph → AG-UI adapter (API §7.6, TD DD-012). Needs ``reflex-agentkit[langgraph]``.
+
+``LangGraphAGUIAgent`` subclasses the official ``ag_ui_langgraph.LangGraphAgent`` with
+AG-UI standard interrupts on. ``request_tool_approval`` is called inside a graph node or
+tool to pause for a human decision on a tool call, with the same payload contract as the
+PydanticAI adapter (API §7.4).
+"""
+
+from __future__ import annotations
+
+from reflex_agentkit.adapters._require import require
+
+require("langgraph", "langgraph", "ag_ui_langgraph")
+
+import dataclasses  # noqa: E402 - the guard must run before the optional imports
+import json  # noqa: E402
+import logging  # noqa: E402
+from collections.abc import AsyncIterator, Mapping  # noqa: E402
+from typing import Any, Self, cast  # noqa: E402
+
+from ag_ui.core import (  # noqa: E402
+    BaseEvent,
+    CustomEvent,
+    Interrupt,
+    ResumeEntry,
+    RunAgentInput,
+    RunFinishedEvent,
+    RunFinishedInterruptOutcome,
+)
+from ag_ui_langgraph import LangGraphAgent  # noqa: E402
+from ag_ui_langgraph.interrupts import (  # noqa: E402
+    DEFAULT_RESUME_SENTINEL_CANCELLED,
+    lg_interrupt_to_agui,
+)
+from langchain_core.runnables import RunnableConfig  # noqa: E402
+from langgraph.graph.state import CompiledStateGraph  # noqa: E402
+from langgraph.types import Command, interrupt  # noqa: E402
+from langgraph.types import Interrupt as LangGraphInterrupt  # noqa: E402
+
+from reflex_agentkit.core.errors import ConfigurationError  # noqa: E402
+
+__all__ = ["ApprovalDecision", "LangGraphAGUIAgent", "request_tool_approval"]
+
+APPROVAL_REASON = "tool_call"
+"""The interrupt reason that marks a tool approval (API §7.6)."""
+
+APPROVAL_RESPONSE_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "approved": {"type": "boolean"},
+        "editedArgs": {"type": "object"},
+        "reason": {"type": "string"},
+    },
+    "required": ["approved"],
+}
+"""The JSON Schema of an approval answer; the same one PydanticAI sends (API §7.4)."""
+
+CANCELLED_APPROVAL: dict[str, Any] = {"approved": False, "reason": "cancelled"}
+"""What a cancelled tool approval resumes with (DD-012)."""
+
+_HIDDEN_SNAPSHOT_KEYS = frozenset({"messages", "tools"})
+_LEGACY_EVENT = "on_interrupt"
+_LEGACY_PREFIX = "legacy-"
+_LEGACY_TOOL_PREFIX = "legacy-tool-"
+
+_log = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ApprovalDecision:
+    """A human decision on a tool call (API §7.6).
+
+    Attributes:
+        approved: Whether the tool may run.
+        args: The arguments to run it with: the edited ones when the user edited them,
+            otherwise the original ones.
+        reason: The rejection reason, ``"cancelled"`` when the run was cancelled while
+            waiting, or ``None``.
+    """
+
+    approved: bool
+    args: dict[str, Any]
+    reason: str | None = None
+
+
+def request_tool_approval(
+    tool_call_id: str, tool_name: str, args: dict[str, Any], *, message: str | None = None
+) -> ApprovalDecision:
+    """Pause the graph until the user approves, edits or rejects a tool call (REQ-034.3).
+
+    Call it inside a graph node or tool. It raises LangGraph's ``interrupt`` with the
+    keys that ag-ui-langgraph maps onto the AG-UI ``Interrupt``, so the call shows as a
+    ``pending_approval`` tool card. When the graph resumes, it returns the decision.
+
+    Args:
+        tool_call_id: The ID of the tool call in the assistant message.
+        tool_name: The tool's name.
+        args: The tool call's arguments.
+        message: The question shown to the user; defaults to ``"Approve <tool_name>?"``.
+    """
+    answer = interrupt(
+        {
+            "reason": APPROVAL_REASON,
+            "toolCallId": tool_call_id,
+            "toolName": tool_name,
+            "args": args,
+            "message": message if message is not None else f"Approve {tool_name}?",
+            "responseSchema": APPROVAL_RESPONSE_SCHEMA,
+        }
+    )
+    return _decision(answer, args)
+
+
+def _decision(answer: Any, args: dict[str, Any]) -> ApprovalDecision:
+    """Read the API §7.4 payload. Anything but ``approved: true`` is a rejection."""
+    if not isinstance(answer, Mapping):
+        return ApprovalDecision(approved=False, args=args)
+    reason = answer.get("reason")
+    reason = reason if isinstance(reason, str) else None
+    if answer.get("approved") is not True:
+        return ApprovalDecision(approved=False, args=args, reason=reason)
+    edited = answer.get("editedArgs")
+    return ApprovalDecision(
+        approved=True, args=dict(edited) if isinstance(edited, Mapping) else args
+    )
+
+
+class LangGraphAGUIAgent(LangGraphAgent):  # type: ignore[misc]  # untyped upstream base
+    """Run a compiled LangGraph graph as an ``AGUIAgent`` (REQ-034.1).
+
+    One instance can serve every session: each ``run()`` works on a fresh clone, because
+    the upstream agent keeps per-run state on the instance (DD-012).
+
+    Args:
+        graph: A compiled graph with a checkpointer (REQ-034.4).
+        name: The agent name reported to AG-UI.
+        config: The base ``RunnableConfig`` for every run.
+        legacy_interrupts: Read interrupts from the legacy ``on_interrupt`` CUSTOM event
+            and resume through ``forwarded_props`` (REQ-034.5, compatibility mode).
+
+    Raises:
+        ConfigurationError: ``graph`` is not a compiled graph, or it has no checkpointer.
+    """
+
+    def __init__(
+        self,
+        graph: CompiledStateGraph[Any, Any, Any, Any],
+        *,
+        name: str = "agent",
+        config: RunnableConfig | None = None,
+        legacy_interrupts: bool = False,
+    ) -> None:
+        if not isinstance(graph, CompiledStateGraph):
+            raise ConfigurationError(
+                f"LangGraphAGUIAgent needs a compiled graph, not {type(graph).__name__}"
+            )
+        if graph.checkpointer is None:
+            raise ConfigurationError(
+                "LangGraphAGUIAgent needs a graph compiled with a checkpointer, "
+                "for example graph.compile(checkpointer=InMemorySaver())"
+            )
+        self.legacy_interrupts = legacy_interrupts
+        super().__init__(
+            name=name,
+            graph=graph,
+            config=config,
+            emit_interrupt_outcome=not legacy_interrupts,
+            enable_legacy_on_interrupt_event=legacy_interrupts,
+            emit_raw_events=False,
+        )
+
+    def __repr__(self) -> str:
+        return f"LangGraphAGUIAgent(name={self.name!r})"
+
+    def clone(self) -> Self:
+        """A fresh copy with clean per-run state and the same settings."""
+        return type(self)(
+            self.graph,
+            name=self.name,
+            config=cast(RunnableConfig, dict(self.config)) if self.config else None,
+            legacy_interrupts=self.legacy_interrupts,
+        )
+
+    async def run(self, input: RunAgentInput) -> AsyncIterator[BaseEvent]:
+        """Stream one run as AG-UI events on a fresh clone (API §7.1)."""
+        worker = self.clone()
+        if not self.legacy_interrupts:
+            async for event in LangGraphAgent.run(worker, input):
+                yield event
+            return
+        legacy_values: list[Any] = []
+        async for event in LangGraphAgent.run(worker, _legacy_input(input)):
+            if isinstance(event, CustomEvent) and event.name == _LEGACY_EVENT:
+                legacy_values.append(_decode(event.value))
+                continue
+            if isinstance(event, RunFinishedEvent) and event.outcome is None and legacy_values:
+                event = _legacy_finish(event, legacy_values)
+            yield event
+
+    def get_state_snapshot(self, state: Any) -> Any:
+        """The upstream snapshot without ``messages`` and ``tools`` (DD-012)."""
+        snapshot = super().get_state_snapshot(state)
+        if not isinstance(snapshot, Mapping):
+            return snapshot
+        return {k: v for k, v in snapshot.items() if k not in _HIDDEN_SNAPSHOT_KEYS}
+
+    def _build_command_from_agui_resume(
+        self,
+        entries: list[ResumeEntry],
+        *,
+        open_interrupts: list[Interrupt] | None = None,
+    ) -> Command[Any]:
+        """Native LangGraph resumes (DD-012).
+
+        One entry resumes with its payload; several use ``{interrupt_id: payload}`` so each
+        interrupted node gets its own answer. A cancelled tool approval resumes as a
+        rejection with reason ``"cancelled"``; a cancelled generic interrupt keeps the
+        upstream ``__agui_cancelled__`` sentinel.
+        """
+        reasons = {i.id: i.reason for i in open_interrupts or ()}
+
+        def answer(entry: ResumeEntry) -> Any:
+            if entry.status == "resolved":
+                return entry.payload
+            is_approval = reasons.get(entry.interrupt_id) == APPROVAL_REASON
+            return _cancelled_answer(entry.interrupt_id, is_approval=is_approval)
+
+        if len(entries) == 1:
+            return Command(resume=answer(entries[0]))
+        return Command(resume={entry.interrupt_id: answer(entry) for entry in entries})
+
+
+# --- legacy interrupts (REQ-034.5, DD-012) ---------------------------------------------------
+
+
+def _cancelled_answer(interrupt_id: str, *, is_approval: bool) -> Any:
+    if is_approval:
+        return dict(CANCELLED_APPROVAL)
+    return {DEFAULT_RESUME_SENTINEL_CANCELLED: True, "interrupt_id": interrupt_id}
+
+
+def _legacy_input(run_input: RunAgentInput) -> RunAgentInput:
+    """Move a ``resume[]`` answer to ``forwarded_props.command.resume`` (DD-012)."""
+    if not run_input.resume:
+        return run_input
+    entry = run_input.resume[0]
+    if entry.status == "resolved":
+        answer = entry.payload
+    else:
+        is_approval = entry.interrupt_id.startswith(_LEGACY_TOOL_PREFIX)
+        answer = _cancelled_answer(entry.interrupt_id, is_approval=is_approval)
+    forwarded = dict(run_input.forwarded_props or {})
+    forwarded["command"] = {"resume": answer}
+    return run_input.model_copy(update={"resume": None, "forwarded_props": forwarded})
+
+
+def _decode(value: Any) -> Any:
+    """The legacy event carries a dict value as JSON text and a string as itself."""
+    if not isinstance(value, str):
+        return value
+    try:
+        return json.loads(value)
+    except ValueError:
+        return value
+
+
+def _legacy_finish(event: RunFinishedEvent, values: list[Any]) -> RunFinishedEvent:
+    """``RUN_FINISHED`` with the first legacy interrupt as a standard outcome."""
+    if len(values) > 1:
+        _log.warning("legacy interrupts: dropped %d extra interrupt(s)", len(values) - 1)
+    value = values[0]
+    is_approval = isinstance(value, Mapping) and value.get("reason") == APPROVAL_REASON
+    prefix = _LEGACY_TOOL_PREFIX if is_approval else _LEGACY_PREFIX
+    mapped = lg_interrupt_to_agui(LangGraphInterrupt(value=value, id=f"{prefix}{event.run_id}"))
+    mapped = mapped.model_copy(update={"metadata": {"langgraph": {"raw": value}}})
+    outcome = RunFinishedInterruptOutcome(type="interrupt", interrupts=[mapped])
+    return event.model_copy(update={"outcome": outcome})

reflex_agentkit/adapters/pydantic_ai.py

@@ -0,0 +1,93 @@
+"""PydanticAI → AG-UI adapter (API §7.5, TD DD-011). Needs ``reflex-agentkit[pydantic-ai]``."""
+
+from __future__ import annotations
+
+from reflex_agentkit.adapters._require import require
+
+require("pydantic-ai", "pydantic_ai", "pydantic_ai.ui.ag_ui")
+
+import inspect  # noqa: E402 - the guard must run before the optional imports
+from collections.abc import AsyncIterator, Awaitable, Callable, Sequence  # noqa: E402
+from typing import Any  # noqa: E402
+
+from ag_ui.core import BaseEvent, RunAgentInput  # noqa: E402
+from pydantic_ai import DeferredToolRequests  # noqa: E402
+from pydantic_ai.agent import AbstractAgent  # noqa: E402
+from pydantic_ai.ui.ag_ui import AGUIAdapter  # noqa: E402
+
+from reflex_agentkit.core.errors import ConfigurationError  # noqa: E402
+
+__all__ = ["PydanticAIAgent"]
+
+DepsFactory = Callable[[RunAgentInput], Any | Awaitable[Any]]
+
+
+class PydanticAIAgent:
+    """Run a PydanticAI agent as an ``AGUIAgent`` (REQ-022.1).
+
+    Approval-required tools pause with an AG-UI interrupt with no configuration: when
+    the agent's ``output_type`` lacks ``DeferredToolRequests`` it is added for the run
+    (DD-011). Resumes follow PydanticAI's native payload contract (API §7.4).
+
+    Args:
+        agent: The PydanticAI agent.
+        deps: Dependencies passed to every run.
+        deps_factory: Builds the dependencies of one run from its input (sync or async).
+            Mutually exclusive with ``deps``.
+        run_kwargs: Forwarded to ``AGUIAdapter.run_stream`` (``model_settings``,
+            ``usage_limits``, ``model``, ...).
+    """
+
+    def __init__(
+        self,
+        agent: AbstractAgent[Any, Any],
+        *,
+        deps: Any = None,
+        deps_factory: DepsFactory | None = None,
+        **run_kwargs: Any,
+    ) -> None:
+        if not isinstance(agent, AbstractAgent):
+            raise ConfigurationError(
+                f"PydanticAIAgent needs a pydantic_ai Agent, not {type(agent).__name__}"
+            )
+        if deps is not None and deps_factory is not None:
+            raise ConfigurationError("PydanticAIAgent takes deps or deps_factory, not both")
+        self._agent = agent
+        self._deps = deps
+        self._deps_factory = deps_factory
+        self._run_kwargs = run_kwargs
+        self._output_type = _with_deferred(agent.output_type)
+
+    def __repr__(self) -> str:
+        return f"PydanticAIAgent({self._agent.name or type(self._agent).__name__!s})"
+
+    async def run(self, run_input: RunAgentInput) -> AsyncIterator[BaseEvent]:
+        """Stream one run as AG-UI events (API §7.1)."""
+        deps = self._deps
+        if self._deps_factory is not None:
+            deps = self._deps_factory(run_input)
+            if inspect.isawaitable(deps):
+                deps = await deps
+        kwargs = dict(self._run_kwargs)
+        if self._output_type is not None:
+            kwargs.setdefault("output_type", self._output_type)
+        adapter = AGUIAdapter(agent=self._agent, run_input=run_input)
+        stream = adapter.run_stream(deps=deps, **kwargs)
+        try:
+            async for event in stream:
+                yield event
+        finally:
+            closer = getattr(stream, "aclose", None)
+            if closer is not None:
+                await closer()
+
+
+def _with_deferred(output_type: Any) -> list[Any] | None:
+    """``[*output types, DeferredToolRequests]``, or ``None`` if it is already there."""
+    if isinstance(output_type, Sequence) and not isinstance(output_type, str | bytes):
+        types = list(output_type)
+    else:
+        types = [output_type]
+    if any(t is DeferredToolRequests for t in types):
+        return None
+    return [*types, DeferredToolRequests]

reflex_agentkit/components/__init__.py

@@ -0,0 +1,21 @@
+"""Chat components built from Reflex built-ins only (API §10, Constitution Art. 2)."""
+
+from reflex_agentkit.components.approval import InterruptRenderer, approval_dialog
+from reflex_agentkit.components.chat import agent_chat
+from reflex_agentkit.components.composer import composer
+from reflex_agentkit.components.messages import message_list
+from reflex_agentkit.components.shared_state import shared_state_panel
+from reflex_agentkit.components.status import run_status_bar
+from reflex_agentkit.components.tools import ToolRenderer, tool_call_card
+
+__all__ = [
+    "InterruptRenderer",
+    "ToolRenderer",
+    "agent_chat",
+    "approval_dialog",
+    "composer",
+    "message_list",
+    "run_status_bar",
+    "shared_state_panel",
+    "tool_call_card",
+]

reflex_agentkit/components/approval.py

@@ -0,0 +1,123 @@
+"""``approval_dialog``: tool approvals and generic interrupts (API §10, REQ-023.5)."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+import reflex as rx
+
+from reflex_agentkit.core.models import PendingInterrupt, ToolCall
+
+__all__ = ["InterruptRenderer", "approval_dialog"]
+
+InterruptRenderer = Callable[[rx.Var[PendingInterrupt], type[Any]], rx.Component]
+
+
+def _approval(state: type[Any], call: rx.Var[ToolCall]) -> rx.Component:
+    """Approve, approve with edited arguments, or reject one pending call."""
+    return rx.vstack(
+        rx.dialog.title(rx.text("Approve ", call.name, "?")),
+        rx.el.pre(call.args_text, style={"white_space": "pre-wrap"}),
+        rx.hstack(
+            rx.button(
+                "Approve",
+                on_click=state.approve_tool(call.id),
+                aria_label="Approve tool call",
+            ),
+            width="100%",
+        ),
+        rx.el.details(
+            rx.el.summary("Edit arguments"),
+            rx.form(
+                rx.vstack(
+                    rx.text_area(
+                        name="edited_args",
+                        default_value=call.args_text,
+                        aria_label="Edited arguments",
+                        width="100%",
+                        rows="6",
+                    ),
+                    rx.button("Approve with edits", type="submit", aria_label="Approve with edits"),
+                ),
+                on_submit=lambda form: state.approve_tool(call.id, form.to(dict)["edited_args"]),
+            ),
+        ),
+        rx.form(
+            rx.hstack(
+                rx.input(name="reason", placeholder="Reason (optional)", aria_label="Reason"),
+                rx.button(
+                    "Reject", type="submit", color_scheme="red", aria_label="Reject tool call"
+                ),
+                width="100%",
+            ),
+            on_submit=lambda form: state.reject_tool(call.id, form.to(dict)["reason"]),
+            reset_on_submit=True,
+        ),
+        spacing="3",
+        width="100%",
+    )
+
+
+def _default_interrupt(interrupt: rx.Var[PendingInterrupt], state: type[Any]) -> rx.Component:
+    """The interrupt message and a JSON (or text) payload editor (REQ-023.5)."""
+    return rx.form(
+        rx.vstack(
+            rx.text(interrupt.message),
+            rx.text_area(
+                name="payload",
+                placeholder="Response (JSON or text)",
+                aria_label="Response",
+                width="100%",
+                rows="4",
+            ),
+            rx.button("Send response", type="submit", aria_label="Send response"),
+            spacing="2",
+            width="100%",
+        ),
+        on_submit=lambda form: state.respond_to_interrupt(form.to(dict)["payload"]),
+        reset_on_submit=True,
+    )
+
+
+def _interrupt(state: type[Any], renderers: Mapping[str, InterruptRenderer]) -> rx.Component:
+    interrupt = state.pending_interrupt
+    if renderers:
+        body = rx.match(
+            interrupt.reason,
+            *((reason, render(interrupt, state)) for reason, render in renderers.items()),
+            _default_interrupt(interrupt, state),
+        )
+    else:
+        body = _default_interrupt(interrupt, state)
+    return rx.vstack(
+        rx.dialog.title(interrupt.reason),
+        rx.text("Question ", interrupt.queue_position, " of ", interrupt.queue_size, size="1"),
+        body,
+        spacing="3",
+        width="100%",
+    )
+
+
+def approval_dialog(
+    state: type[Any],
+    *,
+    interrupt_renderers: Mapping[str, InterruptRenderer] | None = None,
+    **props: Any,
+) -> rx.Component:
+    """A dialog open while an approval or a generic interrupt waits; approvals come first."""
+    renderers = dict(interrupt_renderers or {})
+    has_approval = state.pending_approvals.length() > 0
+    open_ = has_approval | (state.pending_interrupt.is_not_none())
+    return rx.dialog.root(
+        rx.dialog.content(
+            rx.cond(
+                has_approval,
+                _approval(state, state.pending_approvals[0]),
+                rx.cond(state.pending_interrupt, _interrupt(state, renderers)),
+            ),
+            rx.dialog.description("The agent is waiting for your answer.", size="1"),
+            **props,
+        ),
+        open=open_,
+    )

reflex_agentkit/components/chat.py

@@ -0,0 +1,42 @@
+"""``agent_chat``: the full chat UI bound to an ``AgentState`` (API §10, REQ-023.1)."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import reflex as rx
+
+from reflex_agentkit.components.approval import InterruptRenderer, approval_dialog
+from reflex_agentkit.components.composer import composer
+from reflex_agentkit.components.messages import message_list
+from reflex_agentkit.components.shared_state import shared_state_panel
+from reflex_agentkit.components.status import run_status_bar
+from reflex_agentkit.components.tools import ToolRenderer
+
+__all__ = ["agent_chat"]
+
+
+def agent_chat(
+    state: type[Any],
+    *,
+    tool_renderers: Mapping[str, ToolRenderer] | None = None,
+    interrupt_renderers: Mapping[str, InterruptRenderer] | None = None,
+    show_shared_state: bool = False,
+    placeholder: str = "Send a message…",
+    **props: Any,
+) -> rx.Component:
+    """Messages, tool cards, the status bar, the composer and the approval dialog."""
+    props.setdefault("width", "100%")
+    props.setdefault("max_width", "48rem")
+    props.setdefault("margin_x", "auto")
+    props.setdefault("padding", "1em")
+    parts: list[rx.Component] = [message_list(state, tool_renderers=tool_renderers)]
+    if show_shared_state:
+        parts.append(shared_state_panel(state))
+    parts += [
+        run_status_bar(state),
+        composer(state, placeholder=placeholder),
+        approval_dialog(state, interrupt_renderers=interrupt_renderers),
+    ]
+    return rx.vstack(*parts, spacing="4", **props)