langgraph-agent-toolkit 0.9.0__tar.gz → 0.9.2__tar.gz

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/.dockerignore

@@ -164,3 +164,16 @@ venv
 
 # langgraph
 .langgraph_api
+
+# Build context trimming — the images only COPY pyproject.toml, uv.lock and
+# langgraph_agent_toolkit/, so exclude everything else from the build context.
+tests/
+docs/
+scripts/
+configs/
+.github/
+data/
+*.md
+Makefile
+docker-compose*.yaml
+.pre-commit-config.yaml

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/.env.example

@@ -113,4 +113,17 @@ MODEL_CONFIGS_PATH=
 # Amazon Bedrock Knowledge Base ID
 AWS_KB_ID=
 
+# Detect/resume interrupted runs (human-in-the-loop). Default true; set false to skip the per-request
+# checkpointer read when no agent uses interrupt().
 CHECK_INTERRUPTS=
+
+# Max non-text attachments (image/file/audio/video) per message. Empty = no toolkit limit
+# (the model provider still enforces its own per-model caps).
+MULTIMODAL_MAX_ATTACHMENTS=
+
+# Defaults for ClearIntermediateToolCallsMiddleware (opt-in token reduction). Global kill switch,
+# dedup key ("name_args" = collapse only identical repeat calls; "name" = collapse all repeats of a
+# tool), and how many most-recent results to keep per key in previous turns.
+CLEAR_INTERMEDIATE_TOOL_CALLS=
+CLEAR_INTERMEDIATE_TOOL_CALLS_BY=
+CLEAR_INTERMEDIATE_TOOL_CALLS_KEEP_LAST_N=

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/CHANGELOG.md

@@ -6,6 +6,84 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.2]
+
+### Fixed
+
+- `TrimMessagesMiddleware` / `TokenTrimMiddleware` no longer silently destroy
+  the model's view when the **latest turn does not fit the budget**.
+  `trim_messages` (`strategy="last"`, `start_on="human"`) returns `[]` whenever
+  the current turn exceeds the budget — e.g. a single user message larger than
+  the token budget, or a turn with more tool calls than the message budget —
+  which invoked the model with the system prompt only and made it answer with
+  the user's question dropped. Both middlewares now floor to the latest turn
+  (kept verbatim, over budget but answerable) rather than emptying it.
+  Regression tests cover an oversize user message, an oversize tool result, and
+  a 6+ tool-call burst.
+
+### Added
+
+- `TokenTrimMiddleware` — bounds the model's message view by a **token** budget
+  (the token-counting companion to `TrimMessagesMiddleware`, which bounds by
+  message count). View-only, so the full history stays in state and the system
+  prompt is preserved. The token counter is configurable (`token_counter`,
+  default `count_tokens_approximately` — no extra dependency; pass a
+  `tiktoken`-backed counter or the model for an exact count), and the budget
+  defaults to the new `DEFAULT_MAX_TOKENS_HISTORY_LENGTH` setting (unset by
+  default, since a sensible budget is model-specific). Compose it after
+  `TrimMessagesMiddleware` to cap both message count and token size.
+
+## [0.9.1]
+
+### Added
+
+- Reusable `create_agent` middleware that brings the custom `create_react_agent`
+  history features to native LangChain `create_agent`, using only public API:
+  `ImmediateGenerationMiddleware` (graceful model-call budget — on the last
+  allowed call it strips tools and asks the model to synthesize a direct answer
+  instead of stalling), `SanitizeHistoryMiddleware` (repair broken
+  tool-call/result pairing before the model call), and
+  `ClearIntermediateToolCallsMiddleware` (token reduction — keep only the most
+  recent result(s) per tool from earlier turns; configurable via constructor or
+  `CLEAR_INTERMEDIATE_TOOL_CALLS*` settings, with a safe `name_args` dedup key
+  that collapses only identical repeat calls by default), and
+  `TrimMessagesMiddleware` (view-only window bound — trims the model's input to
+  the last `DEFAULT_MAX_MESSAGE_HISTORY_LENGTH` messages while keeping full
+  state). Demonstrated in the `create_agent` blueprint
+- `hitl_agent` blueprint: human-in-the-loop tool approval on native
+  `create_agent` via `HumanInTheLoopMiddleware`. The executor bridges the resume
+  (`build_resume_command`): replying `approve` / `reject: <reason>` / free text
+  maps to the middleware's decision format, with custom `interrupt()` blueprints
+  unchanged
+- Multimodal input: `UserComplexInput.message` accepts LangChain content blocks
+  (text / image / file / audio / video, via URL or base64), with a configurable
+  per-message attachment cap (`MULTIMODAL_MAX_ATTACHMENTS`), and the Streamlit
+  chat supports file/image uploads
+
+### Changed
+
+- Dockerfiles (`docker/api`, `docker/app`) are now multi-stage with uv cache
+  mounts and dependency-before-source layering: faster rebuilds (a code change
+  no longer reinstalls dependencies), smaller images, and a trimmed build
+  context
+- Renamed and de-duplicated the ReAct example blueprints: `react_new` →
+  `create_agent`, `react_so` → `create_agent_structured`; removed `react_old` (a
+  duplicate of `react`) and `react_so_old`. Examples are now grouped by builder
+  (toolkit `create_react_agent` vs native `create_agent`)
+- `sanitize_chat_history` is now bidirectional: in addition to stripping
+  unanswered tool calls, it drops orphaned ToolMessages (a tool result whose
+  requesting tool call is gone, e.g. after trimming/summarization). Both the
+  custom `create_react_agent` and `SanitizeHistoryMiddleware` benefit
+- Refactored the Streamlit UI from a single `run_app.py` into a `ui/` package
+  (`main_page`, `components/`, `utils/`); `run_app.py` is now a thin entry point
+
+### Fixed
+
+- Human-in-the-loop interrupts now resume by default (`CHECK_INTERRUPTS`
+  defaults to `True`); previously the resume was silently skipped
+- Streaming now surfaces an agent's `structured_response` (`response_format`),
+  matching `invoke`
+
 ## [0.9.0]
 
 ### Added

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/CLAUDE.md

@@ -60,8 +60,8 @@ langgraph_agent_toolkit/      # The package (all importable code)
   agents/
     agent.py                  # Agent dataclass (wraps a compiled LangGraph Pregel)
     agent_executor.py         # Loads agents from "module:obj" strings; invoke/stream
-    components/               # checkpoint/, creators/ (custom create_react_agent), tools, utils
-    blueprints/               # Example agent graphs: chatbot, react*, supervisor, etc.
+    components/               # checkpoint/, creators/ (custom create_react_agent), middlewares/, tools, utils
+    blueprints/               # Example agent graphs: react, create_agent*, chatbot, supervisor, etc.
   service/                    # FastAPI HTTP layer (factory, routes, handler, middleware, auth)
   client/client.py            # AgentClient SDK (httpx; sync + async)
   core/                       # Cross-cutting factories + settings
@@ -77,7 +77,7 @@ scripts/
   python/                     # 01–09 runnable usage examples (proxy, prompts, history)
 tests/                        # pytest suite (unit / in-process e2e / docker e2e)
 docs/                         # Sphinx docs (published to GitHub Pages)
-.github/workflows/            # CI/CD: test.yml, release.yml, deploy.yml, sphinx.yml
+.github/workflows/            # CI/CD: test.yml, release.yml, sphinx.yml
 pyproject.toml                # Project + tool config (ruff, pytest, extras)
 Makefile                      # uv / pre-commit / docker shortcuts
 langgraph.json                # LangGraph CLI deploy config
@@ -151,7 +151,7 @@ loaded from the nearest `.env`.
   points `load_dotenv()` the `.env` so those vars are present at runtime.
 - Notable defaults: `ENV_MODE=production`, `HOST/PORT=0.0.0.0/8080`,
   `MEMORY_BACKEND` unset (→ no persistence), `OBSERVABILITY_BACKEND` unset (→
-  `EMPTY` at runtime), `DEFAULT_AGENT=react-agent`, `CHECK_INTERRUPTS=False`,
+  `EMPTY` at runtime), `DEFAULT_AGENT=create-agent`, `CHECK_INTERRUPTS=True`,
   `CORS_ENABLED=False`, `AUTH_SECRET=None` (→ auth disabled).
 
 ## Architecture & core patterns
@@ -181,9 +181,33 @@ create `agents/blueprints/<name>/agent.py` exposing a compiled graph or `Agent`,
 then register its path in `AGENT_PATHS` (default list in `_base_settings.py`).
 ⚠️ `run_api.py` **hard-codes its own `AGENT_PATHS`** list, overriding the
 settings default — update it there too if the service entry point must load your
-agent. Several `react*` blueprints (`react_old`, `react_so_old`) are legacy
-near-duplicates of `react` / `react_so`; confirm which variant is actually wired
-before editing one.
+agent.
+
+**ReAct example blueprints — two builders.** The toolkit ships two ways to build
+a tool-calling ReAct agent, shown side by side:
+
+- **`react`** — built with the toolkit's **custom `create_react_agent`**
+  (`components/creators/`), a fork of LangGraph's prebuilt agent that adds an
+  `immediate_generation` router, `sanitize_chat_history`, and an always-on
+  `pre_model_hook`. It pushes a Langfuse prompt at import (needs `LANGFUSE_*`).
+- **`create_agent`** (flagship) and **`create_agent_structured`** — built with
+  **LangChain's native `create_agent`** composed with middleware. The toolkit's
+  `components/middlewares/` reproduce the custom-agent features on the supported
+  path (all view-only `wrap_model_call`, so the full history stays in state):
+  `ImmediateGenerationMiddleware`, `SanitizeHistoryMiddleware`,
+  `ClearIntermediateToolCallsMiddleware` (token reduction, tunable via
+  `CLEAR_INTERMEDIATE_TOOL_CALLS*` settings), and `TrimMessagesMiddleware`
+  (view-only window bound, reuses `DEFAULT_MAX_MESSAGE_HISTORY_LENGTH`). The
+  flagship stack also uses the built-in `ContextEditingMiddleware` (window) and
+  `ToolRetryMiddleware` (resilience). `create_agent_structured` adds a
+  `response_format`. **This is the recommended pattern for new agents, and
+  `create-agent` is the default (`DEFAULT_AGENT=create-agent`).**
+- **`hitl_agent`** — human-in-the-loop tool approval on `create_agent` via
+  `HumanInTheLoopMiddleware`. Its resume goes through
+  `agent_executor.build_resume_command`, which maps an `approve` /
+  `reject: <reason>` / free-text reply to the middleware's decision format; raw
+  `interrupt()` blueprints (`interrupt_agent`) are unaffected (they still get
+  `Command(resume=<input>)`).
 
 **Service.** `service/handler.py:create_app()` is the FastAPI factory; an async
 `lifespan` boots observability + memory checkpointer + `AgentExecutor` onto

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-agent-toolkit
-Version: 0.9.0
+Version: 0.9.2
 Summary: Full toolkit for running an AI agent service built with LangGraph, FastAPI and Streamlit
 Project-URL: documentation, https://kryvokhyzha.github.io/langgraph-agent-toolkit
 Project-URL: repository, https://github.com/kryvokhyzha/langgraph-agent-toolkit
@@ -226,6 +226,8 @@ For detailed installation instructions and available extras, see the
 
    - FastAPI with streaming and non-streaming endpoints
    - Streaming over Server-Sent Events (SSE) or JSON Lines (NDJSON)
+   - Multimodal input (images, files/PDF, audio, video) via LangChain content
+     blocks
    - Support for both token-based and message-based streaming
    - Multiple agent support with URL path routing
    - Available agents and models listed at `/info` endpoint

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/README.md

@@ -130,6 +130,8 @@ For detailed installation instructions and available extras, see the
 
    - FastAPI with streaming and non-streaming endpoints
    - Streaming over Server-Sent Events (SSE) or JSON Lines (NDJSON)
+   - Multimodal input (images, files/PDF, audio, video) via LangChain content
+     blocks
    - Support for both token-based and message-based streaming
    - Multiple agent support with URL path routing
    - Available agents and models listed at `/info` endpoint

langgraph_agent_toolkit-0.9.2/docker/api/Dockerfile

@@ -0,0 +1,69 @@
+# syntax=docker/dockerfile:1
+
+# ---------------------------------------------------------------------------
+# Builder: resolve + install dependencies into an isolated venv. Kept out of
+# the final image so the uv binary and build cache never ship to production.
+# ---------------------------------------------------------------------------
+FROM python:3.13-slim AS builder
+
+ENV UV_COMPILE_BYTECODE=1 \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=0 \
+    UV_PROJECT_ENVIRONMENT=/opt/venv
+
+COPY --from=ghcr.io/astral-sh/uv:0.11 /uv /bin/uv
+
+WORKDIR /app
+
+# Only the manifest + lockfile are needed to install dependencies. Copying them
+# before the source keeps this expensive layer cached across code changes; the
+# cache mount reuses uv's download/wheel cache across builds.
+COPY pyproject.toml uv.lock ./
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-install-project --no-dev \
+    --extra gunicorn-backend --extra all-observability --extra openai
+
+# ---------------------------------------------------------------------------
+# Runtime: minimal image with just the venv + application source.
+# ---------------------------------------------------------------------------
+FROM python:3.13-slim AS runtime
+
+ENV PYTHONPATH=/app \
+    PYTHONUNBUFFERED=1 \
+    PATH=/opt/venv/bin:$PATH
+
+# curl is used by the container healthcheck (GET /health/ready).
+RUN apt-get update && apt-get install -y --no-install-recommends curl \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY --from=builder /opt/venv /opt/venv
+COPY langgraph_agent_toolkit/ ./langgraph_agent_toolkit/
+
+# Run as a non-root user.
+RUN useradd --create-home --shell /bin/bash appuser && chown -R appuser:appuser /app
+USER appuser
+
+EXPOSE 8080
+
+# Gunicorn worker management (see run_api.py):
+# --workers          N worker processes (recommend 2-4 per CPU core)
+# --preload_app      load the app once before forking — faster worker startup,
+#                    shared memory, agents initialized once (best for prod)
+# --timeout          kill workers that don't respond in N s (> slowest request)
+# --graceful_timeout time for in-flight requests to finish before a worker is killed
+# --max_requests[_jitter]  recycle workers after N requests to bound memory growth
+CMD ["python", "langgraph_agent_toolkit/run_api.py", "run_api", \
+    "--runner_type", "gunicorn", \
+    "--workers", "1", \
+    "--preload_app", \
+    "--timeout", "120", \
+    "--graceful_timeout", "30"]
+
+# ====================================================
+# Health check endpoints for Kubernetes:
+# - /health/live    - Liveness probe (is process alive?)
+# - /health/ready   - Readiness probe (can accept traffic?)
+# - /health/startup - Startup probe (has initialization completed?)
+# - /health/db      - Database pool health (for monitoring)
+# ====================================================

langgraph_agent_toolkit-0.9.2/docker/app/Dockerfile

@@ -0,0 +1,45 @@
+# syntax=docker/dockerfile:1
+
+# ---------------------------------------------------------------------------
+# Builder: install the minimal Streamlit client deps into an isolated venv.
+# ---------------------------------------------------------------------------
+FROM python:3.13-slim AS builder
+
+ENV UV_COMPILE_BYTECODE=1 \
+    UV_LINK_MODE=copy \
+    UV_PYTHON_DOWNLOADS=0 \
+    UV_PROJECT_ENVIRONMENT=/opt/venv
+
+COPY --from=ghcr.io/astral-sh/uv:0.11 /uv /bin/uv
+
+WORKDIR /app
+
+COPY pyproject.toml uv.lock ./
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-install-project --only-group client
+
+# ---------------------------------------------------------------------------
+# Runtime: minimal image with just the venv + application source.
+# ---------------------------------------------------------------------------
+FROM python:3.13-slim AS runtime
+
+ENV PYTHONPATH=/app \
+    PYTHONUNBUFFERED=1 \
+    PATH=/opt/venv/bin:$PATH
+
+WORKDIR /app
+COPY --from=builder /opt/venv /opt/venv
+COPY langgraph_agent_toolkit/ ./langgraph_agent_toolkit/
+
+# Run as a non-root user.
+RUN useradd --create-home --shell /bin/bash appuser && chown -R appuser:appuser /app
+USER appuser
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "langgraph_agent_toolkit/run_app.py", \
+    "--server.headless=true", \
+    "--server.address=0.0.0.0", \
+    "--server.port=8501", \
+    "--server.fileWatcherType=none", \
+    "--browser.gatherUsageStats=false"]

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/docs/usage.rst

@@ -22,7 +22,8 @@ To customize the agent:
 
 1. Add your agent to ``langgraph_agent_toolkit/agents/blueprints/``
 2. Register it in ``AGENT_PATHS`` list in ``langgraph_agent_toolkit/core/settings.py``
-3. Optionally customize the Streamlit interface in ``run_app.py``
+3. Optionally customize the Streamlit interface under ``langgraph_agent_toolkit/ui/``
+   (``main_page.py``, ``components/``, ``utils/``); ``run_app.py`` is just the entry point
 
 Docker Setup
 ------------
@@ -91,6 +92,14 @@ The toolkit includes ``AgentClient`` for interacting with the agent service:
    for chunk in client.stream_jsonl({"message": "Tell me a brief joke?"}):
        print(chunk)
 
+   # Multimodal input: ``message`` can be a list of LangChain content blocks
+   # (text / image / file / audio / video, by URL or base64). The chosen model must
+   # support the modality; LangChain translates blocks to the provider's format.
+   client.invoke({"message": [
+       {"type": "text", "text": "Describe this image."},
+       {"type": "image", "url": "https://example.com/image.jpg"},
+   ]})
+
 See ``langgraph_agent_toolkit/run_client.py`` for more examples.
 
 Development with LangGraph Studio
@@ -143,6 +152,7 @@ Key Features
 
 - FastAPI with streaming and non-streaming endpoints
 - Streaming over Server-Sent Events (SSE) or JSON Lines (NDJSON)
+- Multimodal input (images, files/PDF, audio, video) via LangChain content blocks
 - Support for both token-based and message-based streaming
 - Multiple agent support with URL path routing
 - Available agents and models listed at ``/info`` endpoint

{langgraph_agent_toolkit-0.9.0 → langgraph_agent_toolkit-0.9.2}/langgraph_agent_toolkit/agents/agent_executor.py

@@ -28,6 +28,64 @@ from langgraph_agent_toolkit.helper.utils import (
 from langgraph_agent_toolkit.schema import AgentInfo, ChatMessage
 
 
+_HITL_APPROVE = {"approve", "yes", "y", "ok", "accept", "approved"}
+_HITL_REJECT = {"reject", "no", "n", "deny", "rejected"}
+
+
+def interrupt_value_to_content(value: Any) -> Any:
+    """Render an interrupt payload as valid ``AIMessage`` content (a string).
+
+    Custom ``interrupt()`` blueprints pass a string (used as-is). ``HumanInTheLoopMiddleware`` passes
+    a request dict (``{"action_requests": [...]}``); its per-action ``description`` already holds a
+    readable approval prompt, so join those and append a hint on how to reply. This keeps the dict
+    out of ``AIMessage(content=...)``, which only accepts a string or content-block list.
+    """
+    if isinstance(value, (str, list)):
+        return value
+    if isinstance(value, dict) and value.get("action_requests"):
+        lines = []
+        for req in value["action_requests"]:
+            description = req.get("description")
+            lines.append(
+                str(description) if description else f"Approve `{req.get('name')}` with args {req.get('args')}?"
+            )
+        lines.append("\nReply 'approve' to proceed, 'reject: <reason>' to decline, or send other instructions.")
+        return "\n".join(lines)
+    return str(value)
+
+
+def build_resume_command(interrupted_tasks: list, user_input: Dict[str, Any]) -> Command:
+    """Build the ``Command(resume=...)`` for an interrupted run.
+
+    ``HumanInTheLoopMiddleware`` expects ``{"decisions": [...]}``; other interrupts (custom
+    ``interrupt()`` blueprints) read the raw input dict (e.g. ``resume_value["message"]``). When the
+    pending interrupt is a HITL tool-approval request, translate the user's reply into one decision
+    per pending tool call: ``approve``/``yes`` -> approve, ``reject[: reason]``/``no`` -> reject, any
+    other text -> respond (sent to the model). Otherwise resume with the raw input unchanged.
+    """
+    interrupt_value = None
+    try:
+        interrupt_value = interrupted_tasks[0].interrupts[0].value
+    except (IndexError, AttributeError, TypeError):
+        pass
+
+    if isinstance(interrupt_value, dict) and interrupt_value.get("action_requests"):
+        count = len(interrupt_value["action_requests"]) or 1
+        raw = user_input.get("message")
+        message = raw.strip() if isinstance(raw, str) else ""
+        lowered = message.lower()
+        if lowered in _HITL_APPROVE:
+            decision: Dict[str, Any] = {"type": "approve"}
+        elif lowered in _HITL_REJECT or lowered.startswith("reject"):
+            reason = message.split(":", 1)[1].strip() if ":" in message else "User rejected the action."
+            decision = {"type": "reject", "message": reason}
+        else:
+            decision = {"type": "respond", "message": message}
+        return Command(resume={"decisions": [decision] * count})
+
+    return Command(resume=user_input)
+
+
 T = TypeVar("T")
 
 
@@ -276,8 +334,10 @@ class AgentExecutor:
                 pass
 
         if interrupted_tasks:
-            # User input is a response to resume agent execution from interrupt
-            input_data = Command(resume=_input)
+            # User input resumes an interrupted run. For HumanInTheLoopMiddleware the reply is mapped
+            # to a decision; custom interrupt() blueprints receive the raw input dict and read the
+            # field they need (e.g. resume_value["message"]).
+            input_data = build_resume_command(interrupted_tasks, _input)
         else:
             if "message" in _input:
                 message = _input.pop("message", "") or ""
@@ -360,13 +420,11 @@ class AgentExecutor:
                 # Normal response, the agent completed successfully
                 output = langchain_to_chat_message(generated_message)
             elif response_type == "values" and "__interrupt__" in response:
-                # The last thing to occur was an interrupt
-                # Return the value of the first interrupt as an AIMessage
-                output = langchain_to_chat_message(AIMessage(content=response["__interrupt__"][0].value))
-            elif response_type == "updates" and "__interrupt__" in response:
-                # The last thing to occur was an interrupt
-                # Return the value of the first interrupt as an AIMessage
-                output = langchain_to_chat_message(AIMessage(content=response["__interrupt__"][0].value))
+                # The agent paused on an interrupt. ainvoke(stream_mode=["values"]) surfaces it in the
+                # final values event; return the first interrupt's value as an AIMessage.
+                output = langchain_to_chat_message(
+                    AIMessage(content=interrupt_value_to_content(response["__interrupt__"][0].value))
+                )
             else:
                 raise ValueError(f"Unexpected response type: {response_type}")
 
@@ -445,7 +503,7 @@ class AgentExecutor:
                         if node == "__interrupt__":
                             interrupt: Interrupt
                             for interrupt in updates:
-                                new_messages.append(AIMessage(content=interrupt.value))
+                                new_messages.append(AIMessage(content=interrupt_value_to_content(interrupt.value)))
                             continue
 
                         update_messages = (updates or {}).get("messages", [])
@@ -469,6 +527,12 @@ class AgentExecutor:
                                 update_messages = [msg]
                         new_messages.extend(update_messages)
 
+                        # Surface structured output (response_format) so streaming matches invoke,
+                        # which returns structured_response. Yielded as a ChatMessage with dict content.
+                        structured_response = (updates or {}).get("structured_response")
+                        if structured_response is not None:
+                            new_messages.append(structured_response)
+
                 elif stream_mode == "custom":
                     new_messages = [event]
 
@@ -510,12 +574,21 @@ class AgentExecutor:
                     try:
                         chat_message = langchain_to_chat_message(msg)
                         chat_message.run_id = str(run_id)
-                        # Skip the input message if it's repeated by LangGraph
-                        if chat_message.type == "human" and chat_message.content == msg:
+                        # Don't echo human messages back in the response stream: the client already
+                        # has its input, and LangGraph can re-surface it. (The previous
+                        # `content == msg` check compared a str to a message object and never matched.)
+                        if chat_message.type == "human":
                             continue
                         # Track the latest AI message to record as the trace output
                         if chat_message.type == "ai" and chat_message.content:
-                            final_output = convert_message_content_to_string(chat_message.content)
+                            _content = chat_message.content
+                            final_output = (
+                                _content
+                                if isinstance(_content, str)
+                                else convert_message_content_to_string(_content)
+                                if isinstance(_content, list)
+                                else str(_content)  # structured-output dict, etc.
+                            )
                         yield chat_message
                     except Exception as e:
                         logger.error(f"Error parsing message: {e}")

langgraph_agent_toolkit-0.9.2/langgraph_agent_toolkit/agents/blueprints/create_agent/agent.py

@@ -0,0 +1,91 @@
+"""Example agent built with LangChain's native ``create_agent`` (the recommended modern pattern).
+
+A ``create_agent`` tool-calling loop composed with middleware. It reproduces the toolkit's custom
+``create_react_agent`` behavior using only public LangChain middleware:
+
+- ``ContextEditingMiddleware`` — bound the context window non-destructively: once tokens pass the
+  trigger, clear OLD tool outputs (keeping the most recent), reclaiming tokens while keeping the
+  conversation text. Chosen over ``SummarizationMiddleware`` (which destructively replaces history
+  with a summary).
+- ``ImmediateGenerationMiddleware`` — the graceful loop bound: near the recursion limit, drop tools
+  and ask the model to answer from what it already gathered, instead of stalling or erroring (ports
+  the custom router's ``immediate_generation``). This is the loop bound — a separate hard tool-call
+  cap is intentionally omitted, since it would end abruptly and preempt this graceful synthesis.
+- ``ClearIntermediateToolCallsMiddleware`` — token reduction: keep only the latest result per tool
+  from earlier turns (configurable via the ``CLEAR_INTERMEDIATE_TOOL_CALLS*`` settings).
+- ``SanitizeHistoryMiddleware`` — repair broken tool-call/result pairing (interrupted runs, post
+  trim/clear orphans).
+- ``ToolRetryMiddleware`` — resilience: retry a failed tool call with backoff, and after retries are
+  exhausted return the error as a ToolMessage so a single flaky tool (e.g. a search timeout) doesn't
+  abort the whole run.
+
+Compare with ``blueprints/react``: the same agent built with the toolkit's ``create_react_agent``.
+"""
+
+from langchain.agents import AgentState, create_agent
+from langchain.agents.middleware import ClearToolUsesEdit, ContextEditingMiddleware, ToolRetryMiddleware
+from langchain_community.tools import DuckDuckGoSearchResults
+from langgraph.checkpoint.memory import MemorySaver
+
+from langgraph_agent_toolkit.agents.agent import Agent
+from langgraph_agent_toolkit.agents.components.middlewares import (
+    ClearIntermediateToolCallsMiddleware,
+    ImmediateGenerationMiddleware,
+    SanitizeHistoryMiddleware,
+)
+from langgraph_agent_toolkit.agents.components.tools import add, multiply
+from langgraph_agent_toolkit.core import settings
+from langgraph_agent_toolkit.core.models.factory import CompletionModelFactory
+from langgraph_agent_toolkit.schema.models import ModelProvider
+
+
+model = CompletionModelFactory.create(
+    model_provider=ModelProvider.OPENAI,
+    model_name=settings.OPENAI_MODEL_NAME,
+    config_prefix="",
+    configurable_fields=(),
+    model_parameter_values=(("temperature", 0.2), ("top_p", 0.95), ("streaming", False)),
+    openai_api_base=settings.OPENAI_API_BASE_URL,
+    openai_api_key=settings.OPENAI_API_KEY,
+)
+
+react_agent = Agent(
+    name="create-agent",
+    description="A tool-calling ReAct agent built with LangChain's native create_agent + middleware.",
+    graph=create_agent(
+        model=model,
+        tools=[add, multiply, DuckDuckGoSearchResults()],
+        # Middleware compose in list order. The wrap_model_call-based ones (Immediate /
+        # ClearIntermediate / Sanitize) wrap the model node rather than adding graph nodes;
+        # SanitizeHistory is placed last so it cleans the final request sent to the model.
+        middleware=[
+            # Bound the context window without summarizing: once the conversation passes the token
+            # trigger, clear OLD tool outputs (keeping the most recent `keep`), reclaiming tokens
+            # while preserving conversation text. Tune `trigger` to the model's context window.
+            ContextEditingMiddleware(edits=[ClearToolUsesEdit(trigger=100_000, keep=3)]),
+            # Graceful loop bound near the recursion limit: on the last allowed model call, strip
+            # tools and ask the model to answer from what it already gathered (ports the custom
+            # create_react_agent's immediate_generation router). Default budget ~= recursion_limit/2.
+            # No separate hard tool-call cap — it would end abruptly and preempt this synthesis.
+            ImmediateGenerationMiddleware(),
+            # Token reduction: keep only the latest result per tool from earlier turns (current turn
+            # untouched). Defaults from CLEAR_INTERMEDIATE_TOOL_CALLS* settings (safe name_args key).
+            ClearIntermediateToolCallsMiddleware(),
+            # Repair broken tool-call/result pairing before the model call (interrupted runs, post
+            # trim/summarize orphans).
+            SanitizeHistoryMiddleware(),
+            # Resilience: retry a failed tool call (backoff), then on_failure="continue" (the default)
+            # returns the error as a ToolMessage so one flaky search timeout doesn't abort the run.
+            ToolRetryMiddleware(max_retries=2),
+        ],
+        system_prompt=(
+            "You are a team support agent that can perform calculations and search the web. "
+            "You can use the tools provided to help you with your tasks. "
+            "You can also ask clarifying questions to the user. "
+        ),
+        state_schema=AgentState,
+        checkpointer=MemorySaver(),
+    ),
+)
+
+__all__ = ["react_agent"]