Skip to content

The agent engineering platform.

feat: refactor tests coverage (#33927)

Sydney Runkle637bb1cbbc93
diff --git a/libs/langchain_v1/Makefile b/libs/langchain_v1/Makefile
index 032ffeeee6..38416fccd3 100644
--- a/libs/langchain_v1/Makefile
+++ b/libs/langchain_v1/Makefile
@@ -1,4 +1,4 @@
-.PHONY: all start_services stop_services coverage test test_fast extended_tests test_watch test_watch_extended integration_tests check_imports lint format lint_diff format_diff lint_package lint_tests help
+.PHONY: all start_services stop_services coverage coverage_agents test test_fast extended_tests test_watch test_watch_extended integration_tests check_imports lint format lint_diff format_diff lint_package lint_tests help
# Default target executed when no arguments are given to make.
all: help
@@ -27,8 +27,17 @@ coverage:
--cov-report term-missing:skip-covered \
$(TEST_FILE)
+# Run middleware and agent tests with coverage report.
+coverage_agents:
+ uv run --group test pytest \
+ tests/unit_tests/agents/middleware/ \
+ tests/unit_tests/agents/test_*.py \
+ --cov=langchain.agents \
+ --cov-report=term-missing \
+ --cov-report=html:htmlcov \
+
test:
- make start_services && LANGGRAPH_TEST_FAST=0 uv run --no-sync --active --group test pytest -n auto --disable-socket --allow-unix-socket $(TEST_FILE) --cov-report term-missing:skip-covered; \
+ make start_services && LANGGRAPH_TEST_FAST=0 uv run --no-sync --active --group test pytest -n auto --disable-socket --allow-unix-socket $(TEST_FILE) --cov-report term-missing:skip-covered --snapshot-update; \
EXIT_CODE=$$?; \
make stop_services; \
exit $$EXIT_CODE
@@ -93,6 +102,7 @@ help:
@echo 'lint - run linters'
@echo '-- TESTS --'
@echo 'coverage - run unit tests and generate coverage report'
+ @echo 'coverage_agents - run middleware and agent tests with coverage report'
@echo 'test - run unit tests with all services'
@echo 'test_fast - run unit tests with in-memory services only'
@echo 'tests - run unit tests (alias for "make test")'
diff --git a/libs/langchain_v1/tests/unit_tests/agents/__snapshots__/test_middleware_framework.ambr b/libs/langchain_v1/tests/unit_tests/agents/__snapshots__/test_middleware_framework.ambr
new file mode 100644
index 0000000000..dc1e91174c
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/__snapshots__/test_middleware_framework.ambr
@@ -0,0 +1,212 @@
+# serializer version: 1
+# name: test_agent_graph_with_jump_to_end_as_after_agent
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopZero\2ebefore_agent(NoopZero.before_agent)
+ NoopOne\2eafter_agent(NoopOne.after_agent)
+ NoopTwo\2eafter_agent(NoopTwo.after_agent)
+ __end__([<p>__end__</p>]):::last
+ NoopTwo\2eafter_agent --> NoopOne\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> NoopTwo\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> model;
+ __start__ --> NoopZero\2ebefore_agent;
+ model -.-> NoopTwo\2eafter_agent;
+ model -.-> tools;
+ tools -.-> model;
+ NoopOne\2eafter_agent --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[memory]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pipe]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pool]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[sqlite]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_simple_agent_graph
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model -.-> __end__;
+ model -.-> tools;
+ tools -.-> model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_decorators.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_decorators.ambr
new file mode 100644
index 0000000000..4da1944b9a
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_decorators.ambr
@@ -0,0 +1,95 @@
+# serializer version: 1
+# name: test_async_middleware_with_can_jump_to_graph_snapshot
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_before_with_jump\2ebefore_model(async_before_with_jump.before_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> async_before_with_jump\2ebefore_model;
+ async_before_with_jump\2ebefore_model -.-> __end__;
+ async_before_with_jump\2ebefore_model -.-> model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.1
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_after_with_jump\2eafter_model(async_after_with_jump.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ async_after_with_jump\2eafter_model -.-> __end__;
+ async_after_with_jump\2eafter_model -.-> model;
+ model --> async_after_with_jump\2eafter_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.2
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_before_early_exit\2ebefore_model(async_before_early_exit.before_model)
+ async_after_retry\2eafter_model(async_after_retry.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> async_before_early_exit\2ebefore_model;
+ async_after_retry\2eafter_model -.-> __end__;
+ async_after_retry\2eafter_model -.-> async_before_early_exit\2ebefore_model;
+ async_before_early_exit\2ebefore_model -.-> __end__;
+ async_before_early_exit\2ebefore_model -.-> model;
+ model --> async_after_retry\2eafter_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.3
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ sync_before_with_jump\2ebefore_model(sync_before_with_jump.before_model)
+ async_after_with_jumps\2eafter_model(async_after_with_jumps.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> sync_before_with_jump\2ebefore_model;
+ async_after_with_jumps\2eafter_model -.-> __end__;
+ async_after_with_jumps\2eafter_model -.-> sync_before_with_jump\2ebefore_model;
+ model --> async_after_with_jumps\2eafter_model;
+ sync_before_with_jump\2ebefore_model -.-> __end__;
+ sync_before_with_jump\2ebefore_model -.-> model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_diagram.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_diagram.ambr
new file mode 100644
index 0000000000..9a02da355d
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_diagram.ambr
@@ -0,0 +1,289 @@
+# serializer version: 1
+# name: test_create_agent_diagram
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.1
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.10
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopTen\2ebefore_model(NoopTen.before_model)
+ NoopTen\2eafter_model(NoopTen.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopTen\2ebefore_model --> model;
+ __start__ --> NoopTen\2ebefore_model;
+ model --> NoopTen\2eafter_model;
+ NoopTen\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.11
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopTen\2ebefore_model(NoopTen.before_model)
+ NoopTen\2eafter_model(NoopTen.after_model)
+ NoopEleven\2ebefore_model(NoopEleven.before_model)
+ NoopEleven\2eafter_model(NoopEleven.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEleven\2eafter_model --> NoopTen\2eafter_model;
+ NoopEleven\2ebefore_model --> model;
+ NoopTen\2ebefore_model --> NoopEleven\2ebefore_model;
+ __start__ --> NoopTen\2ebefore_model;
+ model --> NoopEleven\2eafter_model;
+ NoopTen\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.2
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ NoopTwo\2ebefore_model(NoopTwo.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> NoopTwo\2ebefore_model;
+ NoopTwo\2ebefore_model --> model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.3
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ NoopTwo\2ebefore_model(NoopTwo.before_model)
+ NoopThree\2ebefore_model(NoopThree.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> NoopTwo\2ebefore_model;
+ NoopThree\2ebefore_model --> model;
+ NoopTwo\2ebefore_model --> NoopThree\2ebefore_model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.4
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model --> NoopFour\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.5
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ NoopFive\2eafter_model(NoopFive.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopFive\2eafter_model --> NoopFour\2eafter_model;
+ __start__ --> model;
+ model --> NoopFive\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.6
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ NoopFive\2eafter_model(NoopFive.after_model)
+ NoopSix\2eafter_model(NoopSix.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopFive\2eafter_model --> NoopFour\2eafter_model;
+ NoopSix\2eafter_model --> NoopFive\2eafter_model;
+ __start__ --> model;
+ model --> NoopSix\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.7
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopSeven\2ebefore_model --> model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopSeven\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.8
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model --> model;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.9
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ NoopNine\2ebefore_model(NoopNine.before_model)
+ NoopNine\2eafter_model(NoopNine.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model --> NoopNine\2ebefore_model;
+ NoopNine\2eafter_model --> NoopEight\2eafter_model;
+ NoopNine\2ebefore_model --> model;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopNine\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_framework.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_framework.ambr
new file mode 100644
index 0000000000..dc1e91174c
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/__snapshots__/test_middleware_framework.ambr
@@ -0,0 +1,212 @@
+# serializer version: 1
+# name: test_agent_graph_with_jump_to_end_as_after_agent
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopZero\2ebefore_agent(NoopZero.before_agent)
+ NoopOne\2eafter_agent(NoopOne.after_agent)
+ NoopTwo\2eafter_agent(NoopTwo.after_agent)
+ __end__([<p>__end__</p>]):::last
+ NoopTwo\2eafter_agent --> NoopOne\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> NoopTwo\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> model;
+ __start__ --> NoopZero\2ebefore_agent;
+ model -.-> NoopTwo\2eafter_agent;
+ model -.-> tools;
+ tools -.-> model;
+ NoopOne\2eafter_agent --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[memory]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pipe]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pool]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[sqlite]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_simple_agent_graph
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model -.-> __end__;
+ model -.-> tools;
+ tools -.-> model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__init__.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_decorators.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_decorators.ambr
new file mode 100644
index 0000000000..4da1944b9a
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_decorators.ambr
@@ -0,0 +1,95 @@
+# serializer version: 1
+# name: test_async_middleware_with_can_jump_to_graph_snapshot
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_before_with_jump\2ebefore_model(async_before_with_jump.before_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> async_before_with_jump\2ebefore_model;
+ async_before_with_jump\2ebefore_model -.-> __end__;
+ async_before_with_jump\2ebefore_model -.-> model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.1
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_after_with_jump\2eafter_model(async_after_with_jump.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ async_after_with_jump\2eafter_model -.-> __end__;
+ async_after_with_jump\2eafter_model -.-> model;
+ model --> async_after_with_jump\2eafter_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.2
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ async_before_early_exit\2ebefore_model(async_before_early_exit.before_model)
+ async_after_retry\2eafter_model(async_after_retry.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> async_before_early_exit\2ebefore_model;
+ async_after_retry\2eafter_model -.-> __end__;
+ async_after_retry\2eafter_model -.-> async_before_early_exit\2ebefore_model;
+ async_before_early_exit\2ebefore_model -.-> __end__;
+ async_before_early_exit\2ebefore_model -.-> model;
+ model --> async_after_retry\2eafter_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_async_middleware_with_can_jump_to_graph_snapshot.3
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ sync_before_with_jump\2ebefore_model(sync_before_with_jump.before_model)
+ async_after_with_jumps\2eafter_model(async_after_with_jumps.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> sync_before_with_jump\2ebefore_model;
+ async_after_with_jumps\2eafter_model -.-> __end__;
+ async_after_with_jumps\2eafter_model -.-> sync_before_with_jump\2ebefore_model;
+ model --> async_after_with_jumps\2eafter_model;
+ sync_before_with_jump\2ebefore_model -.-> __end__;
+ sync_before_with_jump\2ebefore_model -.-> model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_diagram.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_diagram.ambr
new file mode 100644
index 0000000000..9a02da355d
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_diagram.ambr
@@ -0,0 +1,289 @@
+# serializer version: 1
+# name: test_create_agent_diagram
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.1
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.10
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopTen\2ebefore_model(NoopTen.before_model)
+ NoopTen\2eafter_model(NoopTen.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopTen\2ebefore_model --> model;
+ __start__ --> NoopTen\2ebefore_model;
+ model --> NoopTen\2eafter_model;
+ NoopTen\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.11
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopTen\2ebefore_model(NoopTen.before_model)
+ NoopTen\2eafter_model(NoopTen.after_model)
+ NoopEleven\2ebefore_model(NoopEleven.before_model)
+ NoopEleven\2eafter_model(NoopEleven.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEleven\2eafter_model --> NoopTen\2eafter_model;
+ NoopEleven\2ebefore_model --> model;
+ NoopTen\2ebefore_model --> NoopEleven\2ebefore_model;
+ __start__ --> NoopTen\2ebefore_model;
+ model --> NoopEleven\2eafter_model;
+ NoopTen\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.2
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ NoopTwo\2ebefore_model(NoopTwo.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> NoopTwo\2ebefore_model;
+ NoopTwo\2ebefore_model --> model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.3
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopOne\2ebefore_model(NoopOne.before_model)
+ NoopTwo\2ebefore_model(NoopTwo.before_model)
+ NoopThree\2ebefore_model(NoopThree.before_model)
+ __end__([<p>__end__</p>]):::last
+ NoopOne\2ebefore_model --> NoopTwo\2ebefore_model;
+ NoopThree\2ebefore_model --> model;
+ NoopTwo\2ebefore_model --> NoopThree\2ebefore_model;
+ __start__ --> NoopOne\2ebefore_model;
+ model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.4
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model --> NoopFour\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.5
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ NoopFive\2eafter_model(NoopFive.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopFive\2eafter_model --> NoopFour\2eafter_model;
+ __start__ --> model;
+ model --> NoopFive\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.6
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopFour\2eafter_model(NoopFour.after_model)
+ NoopFive\2eafter_model(NoopFive.after_model)
+ NoopSix\2eafter_model(NoopSix.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopFive\2eafter_model --> NoopFour\2eafter_model;
+ NoopSix\2eafter_model --> NoopFive\2eafter_model;
+ __start__ --> model;
+ model --> NoopSix\2eafter_model;
+ NoopFour\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.7
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopSeven\2ebefore_model --> model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopSeven\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.8
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model --> model;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_diagram.9
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ NoopNine\2ebefore_model(NoopNine.before_model)
+ NoopNine\2eafter_model(NoopNine.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model --> NoopNine\2ebefore_model;
+ NoopNine\2eafter_model --> NoopEight\2eafter_model;
+ NoopNine\2ebefore_model --> model;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopNine\2eafter_model;
+ NoopSeven\2eafter_model --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_framework.ambr b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_framework.ambr
new file mode 100644
index 0000000000..dc1e91174c
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/__snapshots__/test_framework.ambr
@@ -0,0 +1,212 @@
+# serializer version: 1
+# name: test_agent_graph_with_jump_to_end_as_after_agent
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopZero\2ebefore_agent(NoopZero.before_agent)
+ NoopOne\2eafter_agent(NoopOne.after_agent)
+ NoopTwo\2eafter_agent(NoopTwo.after_agent)
+ __end__([<p>__end__</p>]):::last
+ NoopTwo\2eafter_agent --> NoopOne\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> NoopTwo\2eafter_agent;
+ NoopZero\2ebefore_agent -.-> model;
+ __start__ --> NoopZero\2ebefore_agent;
+ model -.-> NoopTwo\2eafter_agent;
+ model -.-> tools;
+ tools -.-> model;
+ NoopOne\2eafter_agent --> __end__;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[memory]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pipe]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[postgres_pool]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_create_agent_jump[sqlite]
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ NoopSeven\2ebefore_model(NoopSeven.before_model)
+ NoopSeven\2eafter_model(NoopSeven.after_model)
+ NoopEight\2ebefore_model(NoopEight.before_model)
+ NoopEight\2eafter_model(NoopEight.after_model)
+ __end__([<p>__end__</p>]):::last
+ NoopEight\2eafter_model --> NoopSeven\2eafter_model;
+ NoopEight\2ebefore_model -.-> __end__;
+ NoopEight\2ebefore_model -.-> model;
+ NoopSeven\2eafter_model -.-> NoopSeven\2ebefore_model;
+ NoopSeven\2eafter_model -.-> __end__;
+ NoopSeven\2eafter_model -.-> tools;
+ NoopSeven\2ebefore_model --> NoopEight\2ebefore_model;
+ __start__ --> NoopSeven\2ebefore_model;
+ model --> NoopEight\2eafter_model;
+ tools -.-> NoopSeven\2ebefore_model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
+# name: test_simple_agent_graph
+ '''
+ ---
+ config:
+ flowchart:
+ curve: linear
+ ---
+ graph TD;
+ __start__([<p>__start__</p>]):::first
+ model(model)
+ tools(tools)
+ __end__([<p>__end__</p>]):::last
+ __start__ --> model;
+ model -.-> __end__;
+ model -.-> tools;
+ tools -.-> model;
+ classDef default fill:#f2f0ff,line-height:1.2
+ classDef first fill-opacity:0
+ classDef last fill:#bfb6fc
+
+ '''
+# ---
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_composition.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_composition.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_decorators.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_decorators.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/test_middleware_decorators.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_decorators.py
index b8969bcaa2..98765954f6 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_decorators.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_decorators.py
@@ -22,7 +22,7 @@ from langchain.agents.middleware.types import (
hook_config,
)
from langchain.agents.factory import create_agent, _get_can_jump_to
-from .model import FakeToolCallingModel
+from ...model import FakeToolCallingModel
class CustomState(AgentState):
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_diagram.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_diagram.py
new file mode 100644
index 0000000000..f2cc289dda
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_diagram.py
@@ -0,0 +1,193 @@
+from collections.abc import Callable
+
+from syrupy.assertion import SnapshotAssertion
+
+from langchain.agents.factory import create_agent
+from langchain.agents.middleware.types import AgentMiddleware, ModelRequest
+from langchain_core.messages import AIMessage
+
+from ...model import FakeToolCallingModel
+
+
+def test_create_agent_diagram(
+ snapshot: SnapshotAssertion,
+):
+ class NoopOne(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ class NoopTwo(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ class NoopThree(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ class NoopFour(AgentMiddleware):
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopFive(AgentMiddleware):
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopSix(AgentMiddleware):
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopSeven(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopEight(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopNine(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopTen(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ pass
+
+ class NoopEleven(AgentMiddleware):
+ def before_model(self, state, runtime):
+ pass
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ pass
+
+ agent_zero = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ )
+
+ assert agent_zero.get_graph().draw_mermaid() == snapshot
+
+ agent_one = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopOne()],
+ )
+
+ assert agent_one.get_graph().draw_mermaid() == snapshot
+
+ agent_two = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopOne(), NoopTwo()],
+ )
+
+ assert agent_two.get_graph().draw_mermaid() == snapshot
+
+ agent_three = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopOne(), NoopTwo(), NoopThree()],
+ )
+
+ assert agent_three.get_graph().draw_mermaid() == snapshot
+
+ agent_four = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopFour()],
+ )
+
+ assert agent_four.get_graph().draw_mermaid() == snapshot
+
+ agent_five = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopFour(), NoopFive()],
+ )
+
+ assert agent_five.get_graph().draw_mermaid() == snapshot
+
+ agent_six = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopFour(), NoopFive(), NoopSix()],
+ )
+
+ assert agent_six.get_graph().draw_mermaid() == snapshot
+
+ agent_seven = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopSeven()],
+ )
+
+ assert agent_seven.get_graph().draw_mermaid() == snapshot
+
+ agent_eight = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopSeven(), NoopEight()],
+ )
+
+ assert agent_eight.get_graph().draw_mermaid() == snapshot
+
+ agent_nine = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopSeven(), NoopEight(), NoopNine()],
+ )
+
+ assert agent_nine.get_graph().draw_mermaid() == snapshot
+
+ agent_ten = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopTen()],
+ )
+
+ assert agent_ten.get_graph().draw_mermaid() == snapshot
+
+ agent_eleven = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopTen(), NoopEleven()],
+ )
+
+ assert agent_eleven.get_graph().draw_mermaid() == snapshot
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_framework.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_framework.py
new file mode 100644
index 0000000000..5a4d27ca6f
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_framework.py
@@ -0,0 +1,1051 @@
+import sys
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage, ToolCall, ToolMessage
+from langchain_core.tools import InjectedToolCallId, tool
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.checkpoint.memory import InMemorySaver
+from pydantic import BaseModel, Field
+from syrupy.assertion import SnapshotAssertion
+from typing_extensions import Annotated
+
+from langchain.agents.factory import create_agent
+from langchain.agents.middleware.types import (
+ AgentMiddleware,
+ AgentState,
+ hook_config,
+ ModelRequest,
+ OmitFromInput,
+ OmitFromOutput,
+ PrivateStateAttr,
+)
+from langchain.agents.structured_output import ToolStrategy
+from langchain.tools import InjectedState
+
+from ...messages import _AnyIdHumanMessage, _AnyIdToolMessage
+from ...model import FakeToolCallingModel
+
+
+def test_create_agent_invoke(
+ snapshot: SnapshotAssertion,
+ sync_checkpointer: BaseCheckpointSaver,
+):
+ calls = []
+
+ class NoopSeven(AgentMiddleware):
+ def before_model(self, state, runtime):
+ calls.append("NoopSeven.before_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("NoopSeven.wrap_model_call")
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ calls.append("NoopSeven.after_model")
+
+ class NoopEight(AgentMiddleware):
+ def before_model(self, state, runtime):
+ calls.append("NoopEight.before_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("NoopEight.wrap_model_call")
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ calls.append("NoopEight.after_model")
+
+ @tool
+ def my_tool(input: str) -> str:
+ """A great tool"""
+ calls.append("my_tool")
+ return input.upper()
+
+ agent_one = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[
+ [
+ {"args": {"input": "yo"}, "id": "1", "name": "my_tool"},
+ ],
+ [],
+ ]
+ ),
+ tools=[my_tool],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopSeven(), NoopEight()],
+ checkpointer=sync_checkpointer,
+ )
+
+ thread1 = {"configurable": {"thread_id": "1"}}
+ assert agent_one.invoke({"messages": ["hello"]}, thread1) == {
+ "messages": [
+ _AnyIdHumanMessage(content="hello"),
+ AIMessage(
+ content="You are a helpful assistant.-hello",
+ additional_kwargs={},
+ response_metadata={},
+ id="0",
+ tool_calls=[
+ {
+ "name": "my_tool",
+ "args": {"input": "yo"},
+ "id": "1",
+ "type": "tool_call",
+ }
+ ],
+ ),
+ _AnyIdToolMessage(content="YO", name="my_tool", tool_call_id="1"),
+ AIMessage(
+ content="You are a helpful assistant.-hello-You are a helpful assistant.-hello-YO",
+ additional_kwargs={},
+ response_metadata={},
+ id="1",
+ ),
+ ],
+ }
+ assert calls == [
+ "NoopSeven.before_model",
+ "NoopEight.before_model",
+ "NoopSeven.wrap_model_call",
+ "NoopEight.wrap_model_call",
+ "NoopEight.after_model",
+ "NoopSeven.after_model",
+ "my_tool",
+ "NoopSeven.before_model",
+ "NoopEight.before_model",
+ "NoopSeven.wrap_model_call",
+ "NoopEight.wrap_model_call",
+ "NoopEight.after_model",
+ "NoopSeven.after_model",
+ ]
+
+
+def test_create_agent_jump(
+ snapshot: SnapshotAssertion,
+ sync_checkpointer: BaseCheckpointSaver,
+):
+ calls = []
+
+ class NoopSeven(AgentMiddleware):
+ def before_model(self, state, runtime):
+ calls.append("NoopSeven.before_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("NoopSeven.wrap_model_call")
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ calls.append("NoopSeven.after_model")
+
+ class NoopEight(AgentMiddleware):
+ @hook_config(can_jump_to=["end"])
+ def before_model(self, state, runtime) -> dict[str, Any]:
+ calls.append("NoopEight.before_model")
+ return {"jump_to": "end"}
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("NoopEight.wrap_model_call")
+ return handler(request)
+
+ def after_model(self, state, runtime):
+ calls.append("NoopEight.after_model")
+
+ @tool
+ def my_tool(input: str) -> str:
+ """A great tool"""
+ calls.append("my_tool")
+ return input.upper()
+
+ agent_one = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
+ ),
+ tools=[my_tool],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopSeven(), NoopEight()],
+ checkpointer=sync_checkpointer,
+ )
+
+ if isinstance(sync_checkpointer, InMemorySaver):
+ assert agent_one.get_graph().draw_mermaid() == snapshot
+
+ thread1 = {"configurable": {"thread_id": "1"}}
+ assert agent_one.invoke({"messages": []}, thread1) == {"messages": []}
+ assert calls == ["NoopSeven.before_model", "NoopEight.before_model"]
+
+
+def test_simple_agent_graph(snapshot: SnapshotAssertion) -> None:
+ @tool
+ def my_tool(input_string: str) -> str:
+ """A great tool."""
+ return input_string
+
+ agent_one = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
+ ),
+ tools=[my_tool],
+ system_prompt="You are a helpful assistant.",
+ )
+
+ assert agent_one.get_graph().draw_mermaid() == snapshot
+
+
+def test_agent_graph_with_jump_to_end_as_after_agent(snapshot: SnapshotAssertion) -> None:
+ @tool
+ def my_tool(input_string: str) -> str:
+ """A great tool."""
+ return input_string
+
+ class NoopZero(AgentMiddleware):
+ @hook_config(can_jump_to=["end"])
+ def before_agent(self, state, runtime) -> None:
+ return None
+
+ class NoopOne(AgentMiddleware):
+ def after_agent(self, state, runtime) -> None:
+ return None
+
+ class NoopTwo(AgentMiddleware):
+ def after_agent(self, state, runtime) -> None:
+ return None
+
+ agent_one = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
+ ),
+ tools=[my_tool],
+ system_prompt="You are a helpful assistant.",
+ middleware=[NoopZero(), NoopOne(), NoopTwo()],
+ )
+
+ assert agent_one.get_graph().draw_mermaid() == snapshot
+
+
+def test_on_model_call() -> None:
+ class ModifyMiddleware(AgentMiddleware):
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ request.messages.append(HumanMessage("remember to be nice!"))
+ return handler(request)
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[ModifyMiddleware()],
+ )
+
+ result = agent.invoke({"messages": [HumanMessage("Hello")]})
+ assert result["messages"][0].content == "Hello"
+ assert result["messages"][1].content == "remember to be nice!"
+ assert (
+ result["messages"][2].content == "You are a helpful assistant.-Hello-remember to be nice!"
+ )
+
+
+def test_tools_to_model_edge_with_structured_and_regular_tool_calls():
+ """Test that when there are both structured and regular tool calls, we execute regular and jump to END."""
+
+ class WeatherResponse(BaseModel):
+ """Weather response."""
+
+ temperature: float = Field(description="Temperature in fahrenheit")
+ condition: str = Field(description="Weather condition")
+
+ @tool
+ def regular_tool(query: str) -> str:
+ """A regular tool that returns a string."""
+ return f"Regular tool result for: {query}"
+
+ # Create a fake model that returns both structured and regular tool calls
+ class FakeModelWithBothToolCalls(FakeToolCallingModel):
+ def __init__(self):
+ super().__init__()
+ self.tool_calls = [
+ [
+ ToolCall(
+ name="WeatherResponse",
+ args={"temperature": 72.0, "condition": "sunny"},
+ id="structured_call_1",
+ ),
+ ToolCall(
+ name="regular_tool", args={"query": "test query"}, id="regular_call_1"
+ ),
+ ]
+ ]
+
+ # Create agent with both structured output and regular tools
+ agent = create_agent(
+ model=FakeModelWithBothToolCalls(),
+ tools=[regular_tool],
+ response_format=ToolStrategy(schema=WeatherResponse),
+ )
+
+ # Invoke the agent (already compiled)
+ result = agent.invoke(
+ {"messages": [HumanMessage("What's the weather and help me with a query?")]}
+ )
+
+ # Verify that we have the expected messages:
+ # 1. Human message
+ # 2. AI message with both tool calls
+ # 3. Tool message from structured tool call
+ # 4. Tool message from regular tool call
+
+ messages = result["messages"]
+ assert len(messages) >= 4
+
+ # Check that we have the AI message with both tool calls
+ ai_message = messages[1]
+ assert isinstance(ai_message, AIMessage)
+ assert len(ai_message.tool_calls) == 2
+
+ # Check that we have a tool message from the regular tool
+ tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
+ assert len(tool_messages) >= 1
+
+ # The regular tool should have been executed
+ regular_tool_message = next((m for m in tool_messages if m.name == "regular_tool"), None)
+ assert regular_tool_message is not None
+ assert "Regular tool result for: test query" in regular_tool_message.content
+
+ # Verify that the structured response is available in the result
+ assert "structured_response" in result
+ assert result["structured_response"] is not None
+ assert hasattr(result["structured_response"], "temperature")
+ assert result["structured_response"].temperature == 72.0
+ assert result["structured_response"].condition == "sunny"
+
+
+def test_public_private_state_for_custom_middleware() -> None:
+ """Test public and private state for custom middleware."""
+
+ class CustomState(AgentState):
+ omit_input: Annotated[str, OmitFromInput]
+ omit_output: Annotated[str, OmitFromOutput]
+ private_state: Annotated[str, PrivateStateAttr]
+
+ class CustomMiddleware(AgentMiddleware[CustomState]):
+ state_schema: type[CustomState] = CustomState
+
+ def before_model(self, state: CustomState) -> dict[str, Any]:
+ assert "omit_input" not in state
+ assert "omit_output" in state
+ assert "private_state" not in state
+ return {"omit_input": "test", "omit_output": "test", "private_state": "test"}
+
+ agent = create_agent(model=FakeToolCallingModel(), middleware=[CustomMiddleware()])
+ result = agent.invoke(
+ {
+ "messages": [HumanMessage("Hello")],
+ "omit_input": "test in",
+ "private_state": "test in",
+ "omit_output": "test in",
+ }
+ )
+ assert "omit_input" in result
+ assert "omit_output" not in result
+ assert "private_state" not in result
+
+
+def test_runtime_injected_into_middleware() -> None:
+ """Test that the runtime is injected into the middleware."""
+ from langgraph.runtime import Runtime
+
+ class CustomMiddleware(AgentMiddleware):
+ def before_model(self, state: AgentState, runtime: Runtime) -> None:
+ assert runtime is not None
+ return None
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ assert request.runtime is not None
+ return handler(request)
+
+ def after_model(self, state: AgentState, runtime: Runtime) -> None:
+ assert runtime is not None
+ return None
+
+ middleware = CustomMiddleware()
+
+ agent = create_agent(model=FakeToolCallingModel(), middleware=[CustomMiddleware()])
+ agent.invoke({"messages": [HumanMessage("Hello")]})
+
+
+# test setup defined at this scope bc of pydantic issues inferring the namespace of
+# custom state w/in a function
+
+
+class CustomState(AgentState):
+ custom_state: str
+
+
+@tool(description="Test the state")
+def test_state_tool(
+ state: Annotated[CustomState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId]
+) -> str:
+ """Test tool that accesses injected state."""
+ assert "custom_state" in state
+ return "success"
+
+
+class CustomMiddleware(AgentMiddleware):
+ state_schema = CustomState
+
+
+agent = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[
+ [{"args": {}, "id": "test_call_1", "name": "test_state_tool"}],
+ [],
+ ]
+ ),
+ tools=[test_state_tool],
+ system_prompt="You are a helpful assistant.",
+ middleware=[CustomMiddleware()],
+)
+
+
+ sys.version_info >= (3, 14), reason="pydantic 2.12 namespace management not working w/ 3.14"
+)
+def test_injected_state_in_middleware_agent() -> None:
+ """Test that custom state is properly injected into tools when using middleware."""
+
+ result = agent.invoke(
+ {"custom_state": "I love pizza", "messages": [HumanMessage("Call the test state tool")]}
+ )
+
+ messages = result["messages"]
+ assert len(messages) == 4 # Human message, AI message with tool call, tool message, AI message
+
+ # Find the tool message
+ tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
+ assert len(tool_messages) == 1
+
+ tool_message = tool_messages[0]
+ assert tool_message.name == "test_state_tool"
+ assert "success" in tool_message.content
+ assert tool_message.tool_call_id == "test_call_1"
+
+
+def test_jump_to_is_ephemeral() -> None:
+ class MyMiddleware(AgentMiddleware):
+ def before_model(self, state: AgentState) -> dict[str, Any]:
+ assert "jump_to" not in state
+ return {"jump_to": "model"}
+
+ def after_model(self, state: AgentState) -> dict[str, Any]:
+ assert "jump_to" not in state
+ return {"jump_to": "model"}
+
+ agent = create_agent(model=FakeToolCallingModel(), middleware=[MyMiddleware()])
+ result = agent.invoke({"messages": [HumanMessage("Hello")]})
+ assert "jump_to" not in result
+
+
+def test_create_agent_sync_invoke_with_only_async_middleware_raises_error() -> None:
+ """Test that sync invoke with only async middleware works via run_in_executor."""
+ from collections.abc import Awaitable
+
+ class AsyncOnlyMiddleware(AgentMiddleware):
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ return await handler(request)
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[AsyncOnlyMiddleware()],
+ )
+
+ with pytest.raises(NotImplementedError):
+ agent.invoke({"messages": [HumanMessage("hello")]})
+
+
+def test_create_agent_sync_invoke_with_mixed_middleware() -> None:
+ """Test that sync invoke works with mixed sync/async middleware when sync versions exist."""
+ from collections.abc import Awaitable
+
+ calls = []
+
+ class MixedMiddleware(AgentMiddleware):
+ def before_model(self, state, runtime) -> None:
+ calls.append("MixedMiddleware.before_model")
+
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("MixedMiddleware.abefore_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("MixedMiddleware.wrap_model_call")
+ return handler(request)
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("MixedMiddleware.awrap_model_call")
+ return await handler(request)
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[MixedMiddleware()],
+ )
+
+ result = agent.invoke({"messages": [HumanMessage("hello")]})
+
+ # In sync mode, only sync methods should be called
+ assert calls == [
+ "MixedMiddleware.before_model",
+ "MixedMiddleware.wrap_model_call",
+ ]
+
+
+# =============================================================================
+# Async Middleware Tests
+# =============================================================================
+
+
+async def test_create_agent_async_invoke() -> None:
+ """Test async invoke with async middleware hooks."""
+ from collections.abc import Awaitable, Callable
+
+ calls = []
+
+ class AsyncMiddleware(AgentMiddleware):
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddleware.abefore_model")
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("AsyncMiddleware.awrap_model_call")
+ request.messages.append(HumanMessage("async middleware message"))
+ return await handler(request)
+
+ async def aafter_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddleware.aafter_model")
+
+ @tool
+ def my_tool_async(input: str) -> str:
+ """A great tool"""
+ calls.append("my_tool_async")
+ return input.upper()
+
+ agent = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[
+ [{"args": {"input": "yo"}, "id": "1", "name": "my_tool_async"}],
+ [],
+ ]
+ ),
+ tools=[my_tool_async],
+ system_prompt="You are a helpful assistant.",
+ middleware=[AsyncMiddleware()],
+ )
+
+ result = await agent.ainvoke({"messages": [HumanMessage("hello")]})
+
+ # Should have:
+ # 1. Original hello message
+ # 2. Async middleware message (first invoke)
+ # 3. AI message with tool call
+ # 4. Tool message
+ # 5. Async middleware message (second invoke)
+ # 6. Final AI message
+ assert len(result["messages"]) == 6
+ assert result["messages"][0].content == "hello"
+ assert result["messages"][1].content == "async middleware message"
+ assert calls == [
+ "AsyncMiddleware.abefore_model",
+ "AsyncMiddleware.awrap_model_call",
+ "AsyncMiddleware.aafter_model",
+ "my_tool_async",
+ "AsyncMiddleware.abefore_model",
+ "AsyncMiddleware.awrap_model_call",
+ "AsyncMiddleware.aafter_model",
+ ]
+
+
+async def test_create_agent_async_invoke_multiple_middleware() -> None:
+ """Test async invoke with multiple async middleware hooks."""
+ from collections.abc import Awaitable, Callable
+
+ calls = []
+
+ class AsyncMiddlewareOne(AgentMiddleware):
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddlewareOne.abefore_model")
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("AsyncMiddlewareOne.awrap_model_call")
+ return await handler(request)
+
+ async def aafter_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddlewareOne.aafter_model")
+
+ class AsyncMiddlewareTwo(AgentMiddleware):
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddlewareTwo.abefore_model")
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("AsyncMiddlewareTwo.awrap_model_call")
+ return await handler(request)
+
+ async def aafter_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddlewareTwo.aafter_model")
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[AsyncMiddlewareOne(), AsyncMiddlewareTwo()],
+ )
+
+ result = await agent.ainvoke({"messages": [HumanMessage("hello")]})
+
+ assert calls == [
+ "AsyncMiddlewareOne.abefore_model",
+ "AsyncMiddlewareTwo.abefore_model",
+ "AsyncMiddlewareOne.awrap_model_call",
+ "AsyncMiddlewareTwo.awrap_model_call",
+ "AsyncMiddlewareTwo.aafter_model",
+ "AsyncMiddlewareOne.aafter_model",
+ ]
+
+
+async def test_create_agent_async_jump() -> None:
+ """Test async invoke with async middleware using jump_to."""
+ from typing import Any
+
+ calls = []
+
+ class AsyncMiddlewareOne(AgentMiddleware):
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddlewareOne.abefore_model")
+
+ class AsyncMiddlewareTwo(AgentMiddleware):
+ @hook_config(can_jump_to=["end"])
+ async def abefore_model(self, state, runtime) -> dict[str, Any]:
+ calls.append("AsyncMiddlewareTwo.abefore_model")
+ return {"jump_to": "end"}
+
+ @tool
+ def my_tool_jump(input: str) -> str:
+ """A great tool"""
+ calls.append("my_tool_jump")
+ return input.upper()
+
+ agent = create_agent(
+ model=FakeToolCallingModel(
+ tool_calls=[[ToolCall(id="1", name="my_tool_jump", args={"input": "yo"})]],
+ ),
+ tools=[my_tool_jump],
+ system_prompt="You are a helpful assistant.",
+ middleware=[AsyncMiddlewareOne(), AsyncMiddlewareTwo()],
+ )
+
+ result = await agent.ainvoke({"messages": []})
+
+ assert result == {"messages": []}
+ assert calls == ["AsyncMiddlewareOne.abefore_model", "AsyncMiddlewareTwo.abefore_model"]
+
+
+async def test_create_agent_mixed_sync_async_middleware_async_invoke() -> None:
+ """Test async invoke with mixed sync and async middleware."""
+ from collections.abc import Awaitable, Callable
+
+ from langchain.agents.middleware.types import ModelCallResult, ModelResponse
+
+ calls = []
+
+ class MostlySyncMiddleware(AgentMiddleware):
+ def before_model(self, state, runtime) -> None:
+ calls.append("MostlySyncMiddleware.before_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("MostlySyncMiddleware.wrap_model_call")
+ return handler(request)
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+ ) -> ModelCallResult:
+ calls.append("MostlySyncMiddleware.awrap_model_call")
+ return await handler(request)
+
+ def after_model(self, state, runtime) -> None:
+ calls.append("MostlySyncMiddleware.after_model")
+
+ class AsyncMiddleware(AgentMiddleware):
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddleware.abefore_model")
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("AsyncMiddleware.awrap_model_call")
+ return await handler(request)
+
+ async def aafter_model(self, state, runtime) -> None:
+ calls.append("AsyncMiddleware.aafter_model")
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[MostlySyncMiddleware(), AsyncMiddleware()],
+ )
+
+ await agent.ainvoke({"messages": [HumanMessage("hello")]})
+
+ # In async mode, both sync and async middleware should work
+ # Note: Sync wrap_model_call is not called when running in async mode,
+ # as the async version is preferred
+ assert calls == [
+ "MostlySyncMiddleware.before_model",
+ "AsyncMiddleware.abefore_model",
+ "MostlySyncMiddleware.awrap_model_call",
+ "AsyncMiddleware.awrap_model_call",
+ "AsyncMiddleware.aafter_model",
+ "MostlySyncMiddleware.after_model",
+ ]
+
+
+# =============================================================================
+# Before/After Agent Hook Tests
+# =============================================================================
+
+
+class TestAgentMiddlewareHooks:
+ """Test before_agent and after_agent middleware hooks."""
+
+ @pytest.mark.parametrize("is_async", [False, True])
+ @pytest.mark.parametrize("hook_type", ["before", "after"])
+ async def test_hook_execution(self, is_async: bool, hook_type: str) -> None:
+ """Test that agent hooks are called in both sync and async modes."""
+ from langchain.agents.middleware import after_agent, before_agent
+
+ execution_log: list[str] = []
+
+ if is_async:
+ if hook_type == "before":
+
+ @before_agent
+ async def log_hook(state: AgentState, runtime) -> dict[str, Any] | None:
+ execution_log.append(f"{hook_type}_agent_called")
+ execution_log.append(f"message_count: {len(state['messages'])}")
+ return None
+ else:
+
+ @after_agent
+ async def log_hook(state: AgentState, runtime) -> dict[str, Any] | None:
+ execution_log.append(f"{hook_type}_agent_called")
+ execution_log.append(f"message_count: {len(state['messages'])}")
+ return None
+ else:
+ if hook_type == "before":
+
+ @before_agent
+ def log_hook(state: AgentState, runtime) -> dict[str, Any] | None:
+ execution_log.append(f"{hook_type}_agent_called")
+ execution_log.append(f"message_count: {len(state['messages'])}")
+ return None
+ else:
+
+ @after_agent
+ def log_hook(state: AgentState, runtime) -> dict[str, Any] | None:
+ execution_log.append(f"{hook_type}_agent_called")
+ execution_log.append(f"message_count: {len(state['messages'])}")
+ return None
+
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, tools=[], middleware=[log_hook])
+
+ if is_async:
+ await agent.ainvoke({"messages": [HumanMessage("Hi")]})
+ else:
+ agent.invoke({"messages": [HumanMessage("Hi")]})
+
+ assert f"{hook_type}_agent_called" in execution_log
+ assert any("message_count:" in log for log in execution_log)
+
+ @pytest.mark.parametrize("is_async", [False, True])
+ @pytest.mark.parametrize("hook_type", ["before", "after"])
+ async def test_hook_with_class_inheritance(self, is_async: bool, hook_type: str) -> None:
+ """Test agent hooks using class inheritance in both sync and async modes."""
+ execution_log: list[str] = []
+
+ if is_async:
+
+ class CustomMiddleware(AgentMiddleware):
+ async def abefore_agent(self, state: AgentState, runtime) -> dict[str, Any] | None:
+ if hook_type == "before":
+ execution_log.append("hook_called")
+ return None
+
+ async def aafter_agent(self, state: AgentState, runtime) -> dict[str, Any] | None:
+ if hook_type == "after":
+ execution_log.append("hook_called")
+ return None
+ else:
+
+ class CustomMiddleware(AgentMiddleware):
+ def before_agent(self, state: AgentState, runtime) -> dict[str, Any] | None:
+ if hook_type == "before":
+ execution_log.append("hook_called")
+ return None
+
+ def after_agent(self, state: AgentState, runtime) -> dict[str, Any] | None:
+ if hook_type == "after":
+ execution_log.append("hook_called")
+ return None
+
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ middleware = CustomMiddleware()
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, tools=[], middleware=[middleware])
+
+ if is_async:
+ await agent.ainvoke({"messages": [HumanMessage("Test")]})
+ else:
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert "hook_called" in execution_log
+
+
+class TestAgentHooksCombined:
+ """Test before_agent and after_agent hooks working together."""
+
+ @pytest.mark.parametrize("is_async", [False, True])
+ async def test_execution_order(self, is_async: bool) -> None:
+ """Test that before_agent executes before after_agent in both sync and async modes."""
+ from langchain.agents.middleware import after_agent, before_agent
+
+ execution_log: list[str] = []
+
+ if is_async:
+
+ @before_agent
+ async def log_before(state: AgentState, runtime) -> None:
+ execution_log.append("before")
+
+ @after_agent
+ async def log_after(state: AgentState, runtime) -> None:
+ execution_log.append("after")
+ else:
+
+ @before_agent
+ def log_before(state: AgentState, runtime) -> None:
+ execution_log.append("before")
+
+ @after_agent
+ def log_after(state: AgentState, runtime) -> None:
+ execution_log.append("after")
+
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, tools=[], middleware=[log_before, log_after])
+
+ if is_async:
+ await agent.ainvoke({"messages": [HumanMessage("Test")]})
+ else:
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert execution_log == ["before", "after"]
+
+ def test_state_passthrough(self) -> None:
+ """Test that state modifications in before_agent are visible to after_agent."""
+ from langchain.agents.middleware import before_agent
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ @before_agent
+ def modify_in_before(state: AgentState, runtime) -> dict[str, Any]:
+ return {"messages": [HumanMessage("Added by before_agent")]}
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, tools=[], middleware=[modify_in_before])
+ result = agent.invoke({"messages": [HumanMessage("Original")]})
+
+ message_contents = [msg.content for msg in result["messages"]]
+ assert message_contents[1] == "Added by before_agent"
+
+ def test_multiple_middleware_instances(self) -> None:
+ """Test multiple before_agent and after_agent middleware instances."""
+ from langchain.agents.middleware import after_agent, before_agent
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ execution_log = []
+
+ @before_agent
+ def before_one(state: AgentState, runtime) -> None:
+ execution_log.append("before_1")
+
+ @before_agent
+ def before_two(state: AgentState, runtime) -> None:
+ execution_log.append("before_2")
+
+ @after_agent
+ def after_one(state: AgentState, runtime) -> None:
+ execution_log.append("after_1")
+
+ @after_agent
+ def after_two(state: AgentState, runtime) -> None:
+ execution_log.append("after_2")
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(
+ model=model, tools=[], middleware=[before_one, before_two, after_one, after_two]
+ )
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert execution_log == ["before_1", "before_2", "after_2", "after_1"]
+
+ def test_agent_hooks_run_once_with_multiple_model_calls(self) -> None:
+ """Test that before_agent and after_agent run only once per thread.
+
+ This test verifies that agent-level hooks (before_agent, after_agent) execute
+ exactly once per agent invocation, regardless of how many tool calling loops occur.
+ This is different from model-level hooks (before_model, after_model) which run
+ on every model invocation within the tool calling loop.
+ """
+ from langchain.agents.middleware import (
+ after_agent,
+ after_model,
+ before_agent,
+ before_model,
+ )
+ from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+
+ execution_log = []
+
+ @tool
+ def sample_tool_agent(query: str) -> str:
+ """A sample tool for testing."""
+ return f"Result for: {query}"
+
+ @before_agent
+ def log_before_agent(state: AgentState, runtime) -> None:
+ execution_log.append("before_agent")
+
+ @before_model
+ def log_before_model(state: AgentState, runtime) -> None:
+ execution_log.append("before_model")
+
+ @after_agent
+ def log_after_agent(state: AgentState, runtime) -> None:
+ execution_log.append("after_agent")
+
+ @after_model
+ def log_after_model(state: AgentState, runtime) -> None:
+ execution_log.append("after_model")
+
+ # Model will call a tool twice, then respond with final answer
+ # This creates 3 model invocations total, but agent hooks should still run once
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [{"name": "sample_tool_agent", "args": {"query": "first"}, "id": "1"}],
+ [{"name": "sample_tool_agent", "args": {"query": "second"}, "id": "2"}],
+ [], # Third call returns no tool calls (final answer)
+ ]
+ )
+
+ agent = create_agent(
+ model=model,
+ tools=[sample_tool_agent],
+ middleware=[log_before_agent, log_before_model, log_after_model, log_after_agent],
+ )
+
+ agent.invoke(
+ {"messages": [HumanMessage("Test")]}, config={"configurable": {"thread_id": "abc"}}
+ )
+
+ assert execution_log == [
+ "before_agent",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "after_agent",
+ ]
+
+ agent.invoke(
+ {"messages": [HumanMessage("Test")]}, config={"configurable": {"thread_id": "abc"}}
+ )
+
+ assert execution_log == [
+ "before_agent",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "after_agent",
+ "before_agent",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "before_model",
+ "after_model",
+ "after_agent",
+ ]
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_override_methods.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_overrides.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_override_methods.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_overrides.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_sync_async_tool_wrapper_composition.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_sync_async_wrappers.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/test_sync_async_tool_wrapper_composition.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_sync_async_wrappers.py
index c565719d3f..24a3218cb5 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_sync_async_tool_wrapper_composition.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_sync_async_wrappers.py
@@ -14,7 +14,7 @@ from langgraph.checkpoint.memory import InMemorySaver
from langchain.agents.factory import create_agent
from langchain.agents.middleware.types import AgentMiddleware, wrap_tool_call
from langchain.agents.middleware.types import ToolCallRequest
-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
@tool
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_tools.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/test_middleware_tools.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py
index 3bccc7ba34..7cf988b4ca 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_tools.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py
@@ -9,7 +9,7 @@ from langchain.agents.middleware.types import AgentMiddleware, AgentState, Model
from langgraph.prebuilt.tool_node import ToolNode
from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
from langchain_core.tools import tool
-from .model import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
def test_model_request_tools_are_base_tools() -> None:
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_model_call.py
similarity index 60%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_middleware.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_model_call.py
index 52b5d613a4..93e1ba0707 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_middleware.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_model_call.py
@@ -1,18 +1,30 @@
-"""Unit tests for wrap_model_call middleware generator protocol."""
+"""Unit tests for wrap_model_call hook and @wrap_model_call decorator.
+
+This module tests the wrap_model_call functionality in three forms:
+1. As a middleware method (AgentMiddleware.wrap_model_call)
+2. As a decorator (@wrap_model_call)
+3. Async variant (AgentMiddleware.awrap_model_call)
+"""
+
+from collections.abc import Awaitable, Callable
import pytest
+from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
from langchain.agents import create_agent
from langchain.agents.middleware.types import (
AgentMiddleware,
- AgentState,
ModelRequest,
+ wrap_model_call,
)
+from ...model import FakeToolCallingModel
+
-class TestBasicOnModelCall:
+class TestBasicWrapModelCall:
"""Test basic wrap_model_call functionality."""
def test_passthrough_middleware(self) -> None:
@@ -70,7 +82,7 @@ class TestBasicOnModelCall:
assert counter.call_count == 1
-class TestRetryMiddleware:
+class TestRetryLogic:
"""Test retry logic with wrap_model_call."""
def test_simple_retry_on_error(self) -> None:
@@ -91,12 +103,10 @@ class TestRetryMiddleware:
def wrap_model_call(self, request, handler):
try:
- result = handler(request)
- return result
+ return handler(request)
except Exception:
self.retry_count += 1
- result = handler(request)
- return result
+ return handler(request)
retry_middleware = RetryOnceMiddleware()
model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
@@ -125,8 +135,7 @@ class TestRetryMiddleware:
for attempt in range(self.max_retries):
self.attempts.append(attempt + 1)
try:
- result = handler(request)
- return result
+ return handler(request)
except Exception as e:
last_exception = e
continue
@@ -143,6 +152,75 @@ class TestRetryMiddleware:
assert retry_middleware.attempts == [1, 2, 3]
+ def test_no_retry_propagates_error(self) -> None:
+ """Test that error is propagated when middleware doesn't retry."""
+
+ class FailingModel(BaseChatModel):
+ """Model that always fails."""
+
+ def _generate(self, messages, **kwargs):
+ raise ValueError("Model error")
+
+ @property
+ def _llm_type(self):
+ return "failing"
+
+ class NoRetryMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ return handler(request)
+
+ agent = create_agent(model=FailingModel(), middleware=[NoRetryMiddleware()])
+
+ with pytest.raises(ValueError, match="Model error"):
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ def test_max_attempts_limit(self) -> None:
+ """Test that middleware controls termination via retry limits."""
+
+ class AlwaysFailingModel(BaseChatModel):
+ """Model that always fails."""
+
+ def _generate(self, messages, **kwargs):
+ raise ValueError("Always fails")
+
+ @property
+ def _llm_type(self):
+ return "always_failing"
+
+ class LimitedRetryMiddleware(AgentMiddleware):
+ """Middleware that limits its own retries."""
+
+ def __init__(self, max_retries: int = 10):
+ super().__init__()
+ self.max_retries = max_retries
+ self.attempt_count = 0
+
+ def wrap_model_call(self, request, handler):
+ last_exception = None
+ for attempt in range(self.max_retries):
+ self.attempt_count += 1
+ try:
+ return handler(request)
+ except Exception as e:
+ last_exception = e
+ # Continue to retry
+
+ # All retries exhausted, re-raise the last error
+ if last_exception:
+ raise last_exception
+
+ model = AlwaysFailingModel()
+ middleware = LimitedRetryMiddleware(max_retries=10)
+
+ agent = create_agent(model=model, middleware=[middleware])
+
+ # Should fail with the model's error after middleware stops retrying
+ with pytest.raises(ValueError, match="Always fails"):
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ # Should have attempted exactly 10 times as configured
+ assert middleware.attempt_count == 10
+
class TestResponseRewriting:
"""Test response content rewriting with wrap_model_call."""
@@ -185,6 +263,28 @@ class TestResponseRewriting:
assert result["messages"][1].content == "[BOT]: Response"
+ def test_multi_stage_transformation(self) -> None:
+ """Test middleware applying multiple transformations."""
+
+ class MultiTransformMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ result = handler(request)
+ # result is ModelResponse, extract AIMessage from it
+ ai_message = result.result[0]
+
+ # First transformation: uppercase
+ content = ai_message.content.upper()
+ # Second transformation: add prefix and suffix
+ content = f"[START] {content} [END]"
+ return AIMessage(content=content)
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="hello")]))
+ agent = create_agent(model=model, middleware=[MultiTransformMiddleware()])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert result["messages"][1].content == "[START] HELLO [END]"
+
class TestErrorHandling:
"""Test error handling with wrap_model_call."""
@@ -200,9 +300,8 @@ class TestErrorHandling:
def wrap_model_call(self, request, handler):
try:
return handler(request)
- except Exception:
- fallback = AIMessage(content="Error handled gracefully")
- return fallback
+ except Exception as e:
+ return AIMessage(content=f"Error occurred: {e}. Using fallback response.")
model = AlwaysFailModel(messages=iter([]))
agent = create_agent(model=model, middleware=[ErrorToSuccessMiddleware()])
@@ -210,7 +309,8 @@ class TestErrorHandling:
# Should not raise, middleware converts error to response
result = agent.invoke({"messages": [HumanMessage("Test")]})
- assert "Error handled gracefully" in result["messages"][1].content
+ assert "Error occurred" in result["messages"][1].content
+ assert "fallback response" in result["messages"][1].content
def test_selective_error_handling(self) -> None:
"""Test middleware that only handles specific errors."""
@@ -224,8 +324,7 @@ class TestErrorHandling:
try:
return handler(request)
except ConnectionError:
- fallback = AIMessage(content="Network issue, try again later")
- return fallback
+ return AIMessage(content="Network issue, try again later")
model = SpecificErrorModel(messages=iter([]))
agent = create_agent(model=model, middleware=[SelectiveErrorMiddleware()])
@@ -247,8 +346,7 @@ class TestErrorHandling:
return result
except Exception:
call_log.append("caught-error")
- fallback = AIMessage(content="Recovered from error")
- return fallback
+ return AIMessage(content="Recovered from error")
# Test 1: Success path
call_log.clear()
@@ -403,7 +501,6 @@ class TestStateAndRuntime:
for attempt in range(max_retries):
try:
return handler(request)
- break # Success
except Exception:
if attempt == max_retries - 1:
raise
@@ -460,6 +557,49 @@ class TestMiddlewareComposition:
"outer-after",
]
+ def test_three_middleware_composition(self) -> None:
+ """Test composition of three middleware."""
+ execution_order = []
+
+ class FirstMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ execution_order.append("first-before")
+ response = handler(request)
+ execution_order.append("first-after")
+ return response
+
+ class SecondMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ execution_order.append("second-before")
+ response = handler(request)
+ execution_order.append("second-after")
+ return response
+
+ class ThirdMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ execution_order.append("third-before")
+ response = handler(request)
+ execution_order.append("third-after")
+ return response
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(
+ model=model,
+ middleware=[FirstMiddleware(), SecondMiddleware(), ThirdMiddleware()],
+ )
+
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ # First wraps Second wraps Third: 1-before, 2-before, 3-before, model, 3-after, 2-after, 1-after
+ assert execution_order == [
+ "first-before",
+ "second-before",
+ "third-before",
+ "third-after",
+ "second-after",
+ "first-after",
+ ]
+
def test_retry_with_logging(self) -> None:
"""Test retry middleware composed with logging middleware."""
call_count = {"value": 0}
@@ -549,11 +689,9 @@ class TestMiddlewareComposition:
class RetryMiddleware(AgentMiddleware):
def wrap_model_call(self, request, handler):
try:
- result = handler(request)
- return result
+ return handler(request)
except Exception:
- result = handler(request)
- return result
+ return handler(request)
class UppercaseMiddleware(AgentMiddleware):
def wrap_model_call(self, request, handler):
@@ -571,49 +709,6 @@ class TestMiddlewareComposition:
# Should retry and uppercase the result
assert result["messages"][1].content == "SUCCESS"
- def test_three_middleware_composition(self) -> None:
- """Test composition of three middleware."""
- execution_order = []
-
- class FirstMiddleware(AgentMiddleware):
- def wrap_model_call(self, request, handler):
- execution_order.append("first-before")
- response = handler(request)
- execution_order.append("first-after")
- return response
-
- class SecondMiddleware(AgentMiddleware):
- def wrap_model_call(self, request, handler):
- execution_order.append("second-before")
- response = handler(request)
- execution_order.append("second-after")
- return response
-
- class ThirdMiddleware(AgentMiddleware):
- def wrap_model_call(self, request, handler):
- execution_order.append("third-before")
- response = handler(request)
- execution_order.append("third-after")
- return response
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(
- model=model,
- middleware=[FirstMiddleware(), SecondMiddleware(), ThirdMiddleware()],
- )
-
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- # First wraps Second wraps Third: 1-before, 2-before, 3-before, model, 3-after, 2-after, 1-after
- assert execution_order == [
- "first-before",
- "second-before",
- "third-before",
- "third-after",
- "second-after",
- "first-after",
- ]
-
def test_middle_retry_middleware(self) -> None:
"""Test that middle middleware doing retry causes inner to execute twice."""
execution_order = []
@@ -674,7 +769,306 @@ class TestMiddlewareComposition:
assert len(model_calls) == 2
-class TestAsyncOnModelCall:
+class TestWrapModelCallDecorator:
+ """Test the @wrap_model_call decorator for creating middleware."""
+
+ def test_basic_decorator_usage(self) -> None:
+ """Test basic decorator usage without parameters."""
+
+ @wrap_model_call
+ def passthrough_middleware(request, handler):
+ return handler(request)
+
+ # Should return an AgentMiddleware instance
+ assert isinstance(passthrough_middleware, AgentMiddleware)
+
+ # Should work in agent
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Hello")]))
+ agent = create_agent(model=model, middleware=[passthrough_middleware])
+
+ result = agent.invoke({"messages": [HumanMessage("Hi")]})
+ assert len(result["messages"]) == 2
+ assert result["messages"][1].content == "Hello"
+
+ def test_decorator_with_custom_name(self) -> None:
+ """Test decorator with custom middleware name."""
+
+ @wrap_model_call(name="CustomMiddleware")
+ def my_middleware(request, handler):
+ return handler(request)
+
+ assert isinstance(my_middleware, AgentMiddleware)
+ assert my_middleware.__class__.__name__ == "CustomMiddleware"
+
+ def test_decorator_retry_logic(self) -> None:
+ """Test decorator for implementing retry logic."""
+ call_count = {"value": 0}
+
+ class FailOnceThenSucceed(GenericFakeChatModel):
+ def _generate(self, messages, **kwargs):
+ call_count["value"] += 1
+ if call_count["value"] == 1:
+ raise ValueError("First call fails")
+ return super()._generate(messages, **kwargs)
+
+ @wrap_model_call
+ def retry_once(request, handler):
+ try:
+ return handler(request)
+ except Exception:
+ # Retry once
+ return handler(request)
+
+ model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
+ agent = create_agent(model=model, middleware=[retry_once])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert call_count["value"] == 2
+ assert result["messages"][1].content == "Success"
+
+ def test_decorator_response_rewriting(self) -> None:
+ """Test decorator for rewriting responses."""
+
+ @wrap_model_call
+ def uppercase_responses(request, handler):
+ result = handler(request)
+ # result is ModelResponse, extract AIMessage from it
+ ai_message = result.result[0]
+ return AIMessage(content=ai_message.content.upper())
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="hello world")]))
+ agent = create_agent(model=model, middleware=[uppercase_responses])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert result["messages"][1].content == "HELLO WORLD"
+
+ def test_decorator_error_handling(self) -> None:
+ """Test decorator for error recovery."""
+
+ class AlwaysFailModel(GenericFakeChatModel):
+ def _generate(self, messages, **kwargs):
+ raise ValueError("Model error")
+
+ @wrap_model_call
+ def error_to_fallback(request, handler):
+ try:
+ return handler(request)
+ except Exception:
+ return AIMessage(content="Fallback response")
+
+ model = AlwaysFailModel(messages=iter([]))
+ agent = create_agent(model=model, middleware=[error_to_fallback])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert result["messages"][1].content == "Fallback response"
+
+ def test_decorator_with_state_access(self) -> None:
+ """Test decorator accessing agent state."""
+ state_values = []
+
+ @wrap_model_call
+ def log_state(request, handler):
+ state_values.append(request.state.get("messages"))
+ return handler(request)
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, middleware=[log_state])
+
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ # State should contain the user message
+ assert len(state_values) == 1
+ assert len(state_values[0]) == 1
+ assert state_values[0][0].content == "Test"
+
+ def test_multiple_decorated_middleware(self) -> None:
+ """Test composition of multiple decorated middleware."""
+ execution_order = []
+
+ @wrap_model_call
+ def outer_middleware(request, handler):
+ execution_order.append("outer-before")
+ result = handler(request)
+ execution_order.append("outer-after")
+ return result
+
+ @wrap_model_call
+ def inner_middleware(request, handler):
+ execution_order.append("inner-before")
+ result = handler(request)
+ execution_order.append("inner-after")
+ return result
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, middleware=[outer_middleware, inner_middleware])
+
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert execution_order == [
+ "outer-before",
+ "inner-before",
+ "inner-after",
+ "outer-after",
+ ]
+
+ def test_decorator_with_custom_state_schema(self) -> None:
+ """Test decorator with custom state schema."""
+ from typing_extensions import TypedDict
+
+ class CustomState(TypedDict):
+ messages: list
+ custom_field: str
+
+ @wrap_model_call(state_schema=CustomState)
+ def middleware_with_schema(request, handler):
+ return handler(request)
+
+ assert isinstance(middleware_with_schema, AgentMiddleware)
+ # Custom state schema should be set
+ assert middleware_with_schema.state_schema == CustomState
+
+ def test_decorator_with_tools_parameter(self) -> None:
+ """Test decorator with tools parameter."""
+ from langchain_core.tools import tool
+
+ @tool
+ def test_tool(query: str) -> str:
+ """A test tool."""
+ return f"Result: {query}"
+
+ @wrap_model_call(tools=[test_tool])
+ def middleware_with_tools(request, handler):
+ return handler(request)
+
+ assert isinstance(middleware_with_tools, AgentMiddleware)
+ assert len(middleware_with_tools.tools) == 1
+ assert middleware_with_tools.tools[0].name == "test_tool"
+
+ def test_decorator_parentheses_optional(self) -> None:
+ """Test that decorator works both with and without parentheses."""
+
+ # Without parentheses
+ @wrap_model_call
+ def middleware_no_parens(request, handler):
+ return handler(request)
+
+ # With parentheses
+ @wrap_model_call()
+ def middleware_with_parens(request, handler):
+ return handler(request)
+
+ assert isinstance(middleware_no_parens, AgentMiddleware)
+ assert isinstance(middleware_with_parens, AgentMiddleware)
+
+ def test_decorator_preserves_function_name(self) -> None:
+ """Test that decorator uses function name for class name."""
+
+ @wrap_model_call
+ def my_custom_middleware(request, handler):
+ return handler(request)
+
+ assert my_custom_middleware.__class__.__name__ == "my_custom_middleware"
+
+ def test_decorator_mixed_with_class_middleware(self) -> None:
+ """Test decorated middleware mixed with class-based middleware."""
+ execution_order = []
+
+ @wrap_model_call
+ def decorated_middleware(request, handler):
+ execution_order.append("decorated-before")
+ result = handler(request)
+ execution_order.append("decorated-after")
+ return result
+
+ class ClassMiddleware(AgentMiddleware):
+ def wrap_model_call(self, request, handler):
+ execution_order.append("class-before")
+ result = handler(request)
+ execution_order.append("class-after")
+ return result
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(
+ model=model,
+ middleware=[decorated_middleware, ClassMiddleware()],
+ )
+
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ # Decorated is outer, class-based is inner
+ assert execution_order == [
+ "decorated-before",
+ "class-before",
+ "class-after",
+ "decorated-after",
+ ]
+
+ def test_decorator_complex_retry_logic(self) -> None:
+ """Test decorator with complex retry logic and backoff."""
+ attempts = []
+ call_count = {"value": 0}
+
+ class UnreliableModel(GenericFakeChatModel):
+ def _generate(self, messages, **kwargs):
+ call_count["value"] += 1
+ if call_count["value"] <= 2:
+ raise ValueError(f"Attempt {call_count['value']} failed")
+ return super()._generate(messages, **kwargs)
+
+ @wrap_model_call
+ def retry_with_tracking(request, handler):
+ max_retries = 3
+ for attempt in range(max_retries):
+ attempts.append(attempt + 1)
+ try:
+ return handler(request)
+ except Exception:
+ # On error, continue to next attempt
+ if attempt < max_retries - 1:
+ continue # Retry
+ else:
+ raise # All retries failed
+
+ model = UnreliableModel(messages=iter([AIMessage(content="Finally worked")]))
+ agent = create_agent(model=model, middleware=[retry_with_tracking])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert attempts == [1, 2, 3]
+ assert result["messages"][1].content == "Finally worked"
+
+ def test_decorator_request_modification(self) -> None:
+ """Test decorator modifying request before execution."""
+ modified_prompts = []
+
+ @wrap_model_call
+ def add_system_prompt(request, handler):
+ # Modify request to add system prompt
+ modified_request = ModelRequest(
+ messages=request.messages,
+ model=request.model,
+ system_prompt="You are a helpful assistant",
+ tool_choice=request.tool_choice,
+ tools=request.tools,
+ response_format=request.response_format,
+ state={},
+ runtime=None,
+ )
+ modified_prompts.append(modified_request.system_prompt)
+ return handler(modified_request)
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
+ agent = create_agent(model=model, middleware=[add_system_prompt])
+
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+ assert modified_prompts == ["You are a helpful assistant"]
+
+
+class TestAsyncWrapModelCall:
"""Test async execution with wrap_model_call."""
async def test_async_model_with_middleware(self) -> None:
@@ -686,7 +1080,6 @@ class TestAsyncOnModelCall:
log.append("before")
result = await handler(request)
log.append("after")
-
return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))
@@ -723,6 +1116,92 @@ class TestAsyncOnModelCall:
assert call_count["value"] == 2
assert result["messages"][1].content == "Async success"
+ async def test_decorator_with_async_agent(self) -> None:
+ """Test that decorated middleware works with async agent invocation."""
+ call_log = []
+
+ @wrap_model_call
+ async def logging_middleware(request, handler):
+ call_log.append("before")
+ result = await handler(request)
+ call_log.append("after")
+ return result
+
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))
+ agent = create_agent(model=model, middleware=[logging_middleware])
+
+ result = await agent.ainvoke({"messages": [HumanMessage("Test")]})
+
+ assert call_log == ["before", "after"]
+ assert result["messages"][1].content == "Async response"
+
+
+class TestSyncAsyncInterop:
+ """Test sync/async interoperability."""
+
+ def test_sync_invoke_with_only_async_middleware_raises_error(self) -> None:
+ """Test that sync invoke with only async middleware raises error."""
+
+ class AsyncOnlyMiddleware(AgentMiddleware):
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ return await handler(request)
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[AsyncOnlyMiddleware()],
+ )
+
+ with pytest.raises(NotImplementedError):
+ agent.invoke({"messages": [HumanMessage("hello")]})
+
+ def test_sync_invoke_with_mixed_middleware(self) -> None:
+ """Test that sync invoke works with mixed sync/async middleware when sync versions exist."""
+ calls = []
+
+ class MixedMiddleware(AgentMiddleware):
+ def before_model(self, state, runtime) -> None:
+ calls.append("MixedMiddleware.before_model")
+
+ async def abefore_model(self, state, runtime) -> None:
+ calls.append("MixedMiddleware.abefore_model")
+
+ def wrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ calls.append("MixedMiddleware.wrap_model_call")
+ return handler(request)
+
+ async def awrap_model_call(
+ self,
+ request: ModelRequest,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ calls.append("MixedMiddleware.awrap_model_call")
+ return await handler(request)
+
+ agent = create_agent(
+ model=FakeToolCallingModel(),
+ tools=[],
+ system_prompt="You are a helpful assistant.",
+ middleware=[MixedMiddleware()],
+ )
+
+ result = agent.invoke({"messages": [HumanMessage("hello")]})
+
+ # In sync mode, only sync methods should be called
+ assert calls == [
+ "MixedMiddleware.before_model",
+ "MixedMiddleware.wrap_model_call",
+ ]
+
class TestEdgeCases:
"""Test edge cases and error conditions."""
@@ -753,12 +1232,10 @@ class TestEdgeCases:
def wrap_model_call(self, request, handler):
attempts.append("first-attempt")
try:
- result = handler(request)
- return result
+ return handler(request)
except Exception:
attempts.append("retry-attempt")
- result = handler(request)
- return result
+ return handler(request)
call_count = {"value": 0}
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_tool_call_decorator.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_tool_call.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_tool_call_decorator.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_tool_call.py
index ca92bc65b7..89c10ee0c3 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_tool_call_decorator.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_tool_call.py
@@ -14,7 +14,7 @@ from langgraph.types import Command
from langchain.agents.factory import create_agent
from langchain.agents.middleware.types import wrap_tool_call
from langchain.agents.middleware.types import ToolCallRequest
-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
@tool
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/__init__.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_context_editing_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_context_editing.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/test_context_editing_middleware.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_context_editing.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_file_search.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_file_search.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_file_search.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_file_search.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_human_in_the_loop.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_human_in_the_loop.py
new file mode 100644
index 0000000000..5a58733aa3
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_human_in_the_loop.py
@@ -0,0 +1,575 @@
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage, ToolCall, ToolMessage
+from langgraph.runtime import Runtime
+
+from langchain.agents.middleware.human_in_the_loop import (
+ Action,
+ HumanInTheLoopMiddleware,
+)
+from langchain.agents.middleware.types import AgentState
+
+
+def test_human_in_the_loop_middleware_initialization() -> None:
+ """Test HumanInTheLoopMiddleware initialization."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}},
+ description_prefix="Custom prefix",
+ )
+
+ assert middleware.interrupt_on == {
+ "test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}
+ }
+ assert middleware.description_prefix == "Custom prefix"
+
+
+def test_human_in_the_loop_middleware_no_interrupts_needed() -> None:
+ """Test HumanInTheLoopMiddleware when no interrupts are needed."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ # Test with no messages
+ state: dict[str, Any] = {"messages": []}
+ result = middleware.after_model(state, None)
+ assert result is None
+
+ # Test with message but no tool calls
+ state = {"messages": [HumanMessage(content="Hello"), AIMessage(content="Hi there")]}
+ result = middleware.after_model(state, None)
+ assert result is None
+
+ # Test with tool calls that don't require interrupts
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "other_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+ result = middleware.after_model(state, None)
+ assert result is None
+
+
+def test_human_in_the_loop_middleware_single_tool_accept() -> None:
+ """Test HumanInTheLoopMiddleware with single tool accept response."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_accept(requests):
+ return {"decisions": [{"type": "approve"}]}
+
+ with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_accept):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert result["messages"][0] == ai_message
+ assert result["messages"][0].tool_calls == ai_message.tool_calls
+
+ state["messages"].append(
+ ToolMessage(content="Tool message", name="test_tool", tool_call_id="1")
+ )
+ state["messages"].append(AIMessage(content="test_tool called with result: Tool message"))
+
+ result = middleware.after_model(state, None)
+ # No interrupts needed
+ assert result is None
+
+
+def test_human_in_the_loop_middleware_single_tool_edit() -> None:
+ """Test HumanInTheLoopMiddleware with single tool edit response."""
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_edit(requests):
+ return {
+ "decisions": [
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="test_tool",
+ args={"input": "edited"},
+ ),
+ }
+ ]
+ }
+
+ with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_edit):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert result["messages"][0].tool_calls[0]["args"] == {"input": "edited"}
+ assert result["messages"][0].tool_calls[0]["id"] == "1" # ID should be preserved
+
+
+def test_human_in_the_loop_middleware_single_tool_response() -> None:
+ """Test HumanInTheLoopMiddleware with single tool response with custom message."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_response(requests):
+ return {"decisions": [{"type": "reject", "message": "Custom response message"}]}
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_response
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 2
+ assert isinstance(result["messages"][0], AIMessage)
+ assert isinstance(result["messages"][1], ToolMessage)
+ assert result["messages"][1].content == "Custom response message"
+ assert result["messages"][1].name == "test_tool"
+ assert result["messages"][1].tool_call_id == "1"
+
+
+def test_human_in_the_loop_middleware_multiple_tools_mixed_responses() -> None:
+ """Test HumanInTheLoopMiddleware with multiple tools and mixed response types."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={
+ "get_forecast": {"allowed_decisions": ["approve", "edit", "reject"]},
+ "get_temperature": {"allowed_decisions": ["approve", "edit", "reject"]},
+ }
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you with weather",
+ tool_calls=[
+ {"name": "get_forecast", "args": {"location": "San Francisco"}, "id": "1"},
+ {"name": "get_temperature", "args": {"location": "San Francisco"}, "id": "2"},
+ ],
+ )
+ state = {"messages": [HumanMessage(content="What's the weather?"), ai_message]}
+
+ def mock_mixed_responses(requests):
+ return {
+ "decisions": [
+ {"type": "approve"},
+ {"type": "reject", "message": "User rejected this tool call"},
+ ]
+ }
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_mixed_responses
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert (
+ len(result["messages"]) == 2
+ ) # AI message with accepted tool call + tool message for rejected
+
+ # First message should be the AI message with both tool calls
+ updated_ai_message = result["messages"][0]
+ assert len(updated_ai_message.tool_calls) == 2 # Both tool calls remain
+ assert updated_ai_message.tool_calls[0]["name"] == "get_forecast" # Accepted
+ assert updated_ai_message.tool_calls[1]["name"] == "get_temperature" # Got response
+
+ # Second message should be the tool message for the rejected tool call
+ tool_message = result["messages"][1]
+ assert isinstance(tool_message, ToolMessage)
+ assert tool_message.content == "User rejected this tool call"
+ assert tool_message.name == "get_temperature"
+
+
+def test_human_in_the_loop_middleware_multiple_tools_edit_responses() -> None:
+ """Test HumanInTheLoopMiddleware with multiple tools and edit responses."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={
+ "get_forecast": {"allowed_decisions": ["approve", "edit", "reject"]},
+ "get_temperature": {"allowed_decisions": ["approve", "edit", "reject"]},
+ }
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you with weather",
+ tool_calls=[
+ {"name": "get_forecast", "args": {"location": "San Francisco"}, "id": "1"},
+ {"name": "get_temperature", "args": {"location": "San Francisco"}, "id": "2"},
+ ],
+ )
+ state = {"messages": [HumanMessage(content="What's the weather?"), ai_message]}
+
+ def mock_edit_responses(requests):
+ return {
+ "decisions": [
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="get_forecast",
+ args={"location": "New York"},
+ ),
+ },
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="get_temperature",
+ args={"location": "New York"},
+ ),
+ },
+ ]
+ }
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_edit_responses
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+
+ updated_ai_message = result["messages"][0]
+ assert updated_ai_message.tool_calls[0]["args"] == {"location": "New York"}
+ assert updated_ai_message.tool_calls[0]["id"] == "1" # ID preserved
+ assert updated_ai_message.tool_calls[1]["args"] == {"location": "New York"}
+ assert updated_ai_message.tool_calls[1]["id"] == "2" # ID preserved
+
+
+def test_human_in_the_loop_middleware_edit_with_modified_args() -> None:
+ """Test HumanInTheLoopMiddleware with edit action that includes modified args."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_edit_with_args(requests):
+ return {
+ "decisions": [
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="test_tool",
+ args={"input": "modified"},
+ ),
+ }
+ ]
+ }
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ side_effect=mock_edit_with_args,
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+
+ # Should have modified args
+ updated_ai_message = result["messages"][0]
+ assert updated_ai_message.tool_calls[0]["args"] == {"input": "modified"}
+ assert updated_ai_message.tool_calls[0]["id"] == "1" # ID preserved
+
+
+def test_human_in_the_loop_middleware_unknown_response_type() -> None:
+ """Test HumanInTheLoopMiddleware with unknown response type."""
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_unknown(requests):
+ return {"decisions": [{"type": "unknown"}]}
+
+ with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_unknown):
+ with pytest.raises(
+ ValueError,
+ match=r"Unexpected human decision: {'type': 'unknown'}. Decision type 'unknown' is not allowed for tool 'test_tool'. Expected one of \['approve', 'edit', 'reject'\] based on the tool's configuration.",
+ ):
+ middleware.after_model(state, None)
+
+
+def test_human_in_the_loop_middleware_disallowed_action() -> None:
+ """Test HumanInTheLoopMiddleware with action not allowed by tool config."""
+
+ # edit is not allowed by tool config
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_disallowed_action(requests):
+ return {
+ "decisions": [
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="test_tool",
+ args={"input": "modified"},
+ ),
+ }
+ ]
+ }
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ side_effect=mock_disallowed_action,
+ ):
+ with pytest.raises(
+ ValueError,
+ match=r"Unexpected human decision: {'type': 'edit', 'edited_action': {'name': 'test_tool', 'args': {'input': 'modified'}}}. Decision type 'edit' is not allowed for tool 'test_tool'. Expected one of \['approve', 'reject'\] based on the tool's configuration.",
+ ):
+ middleware.after_model(state, None)
+
+
+def test_human_in_the_loop_middleware_mixed_auto_approved_and_interrupt() -> None:
+ """Test HumanInTheLoopMiddleware with mix of auto-approved and interrupt tools."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"interrupt_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[
+ {"name": "auto_tool", "args": {"input": "auto"}, "id": "1"},
+ {"name": "interrupt_tool", "args": {"input": "interrupt"}, "id": "2"},
+ ],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ def mock_accept(requests):
+ return {"decisions": [{"type": "approve"}]}
+
+ with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_accept):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+
+ updated_ai_message = result["messages"][0]
+ # Should have both tools: auto-approved first, then interrupt tool
+ assert len(updated_ai_message.tool_calls) == 2
+ assert updated_ai_message.tool_calls[0]["name"] == "auto_tool"
+ assert updated_ai_message.tool_calls[1]["name"] == "interrupt_tool"
+
+
+def test_human_in_the_loop_middleware_interrupt_request_structure() -> None:
+ """Test that interrupt requests are structured correctly."""
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}},
+ description_prefix="Custom prefix",
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test", "location": "SF"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ captured_request = None
+
+ def mock_capture_requests(request):
+ nonlocal captured_request
+ captured_request = request
+ return {"decisions": [{"type": "approve"}]}
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_capture_requests
+ ):
+ middleware.after_model(state, None)
+
+ assert captured_request is not None
+ assert "action_requests" in captured_request
+ assert "review_configs" in captured_request
+
+ assert len(captured_request["action_requests"]) == 1
+ action_request = captured_request["action_requests"][0]
+ assert action_request["name"] == "test_tool"
+ assert action_request["args"] == {"input": "test", "location": "SF"}
+ assert "Custom prefix" in action_request["description"]
+ assert "Tool: test_tool" in action_request["description"]
+ assert "Args: {'input': 'test', 'location': 'SF'}" in action_request["description"]
+
+ assert len(captured_request["review_configs"]) == 1
+ review_config = captured_request["review_configs"][0]
+ assert review_config["action_name"] == "test_tool"
+ assert review_config["allowed_decisions"] == ["approve", "edit", "reject"]
+
+
+def test_human_in_the_loop_middleware_boolean_configs() -> None:
+ """Test HITL middleware with boolean tool configs."""
+ middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": True})
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ # Test accept
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ return_value={"decisions": [{"type": "approve"}]},
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert result["messages"][0].tool_calls == ai_message.tool_calls
+
+ # Test edit
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ return_value={
+ "decisions": [
+ {
+ "type": "edit",
+ "edited_action": Action(
+ name="test_tool",
+ args={"input": "edited"},
+ ),
+ }
+ ]
+ },
+ ):
+ result = middleware.after_model(state, None)
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert result["messages"][0].tool_calls[0]["args"] == {"input": "edited"}
+
+ middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": False})
+
+ result = middleware.after_model(state, None)
+ # No interruption should occur
+ assert result is None
+
+
+def test_human_in_the_loop_middleware_sequence_mismatch() -> None:
+ """Test that sequence mismatch in resume raises an error."""
+ middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": True})
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ # Test with too few responses
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ return_value={"decisions": []}, # No responses for 1 tool call
+ ):
+ with pytest.raises(
+ ValueError,
+ match=r"Number of human decisions \(0\) does not match number of hanging tool calls \(1\)\.",
+ ):
+ middleware.after_model(state, None)
+
+ # Test with too many responses
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt",
+ return_value={
+ "decisions": [
+ {"type": "approve"},
+ {"type": "approve"},
+ ]
+ }, # 2 responses for 1 tool call
+ ):
+ with pytest.raises(
+ ValueError,
+ match=r"Number of human decisions \(2\) does not match number of hanging tool calls \(1\)\.",
+ ):
+ middleware.after_model(state, None)
+
+
+def test_human_in_the_loop_middleware_description_as_callable() -> None:
+ """Test that description field accepts both string and callable."""
+
+ def custom_description(tool_call: ToolCall, state: AgentState, runtime: Runtime) -> str:
+ """Generate a custom description."""
+ return f"Custom: {tool_call['name']} with args {tool_call['args']}"
+
+ middleware = HumanInTheLoopMiddleware(
+ interrupt_on={
+ "tool_with_callable": {
+ "allowed_decisions": ["approve"],
+ "description": custom_description,
+ },
+ "tool_with_string": {
+ "allowed_decisions": ["approve"],
+ "description": "Static description",
+ },
+ }
+ )
+
+ ai_message = AIMessage(
+ content="I'll help you",
+ tool_calls=[
+ {"name": "tool_with_callable", "args": {"x": 1}, "id": "1"},
+ {"name": "tool_with_string", "args": {"y": 2}, "id": "2"},
+ ],
+ )
+ state = {"messages": [HumanMessage(content="Hello"), ai_message]}
+
+ captured_request = None
+
+ def mock_capture_requests(request):
+ nonlocal captured_request
+ captured_request = request
+ return {"decisions": [{"type": "approve"}, {"type": "approve"}]}
+
+ with patch(
+ "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_capture_requests
+ ):
+ middleware.after_model(state, None)
+
+ assert captured_request is not None
+ assert "action_requests" in captured_request
+ assert len(captured_request["action_requests"]) == 2
+
+ # Check callable description
+ assert (
+ captured_request["action_requests"][0]["description"]
+ == "Custom: tool_with_callable with args {'x': 1}"
+ )
+
+ # Check string description
+ assert captured_request["action_requests"][1]["description"] == "Static description"
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_call_limit.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_call_limit.py
new file mode 100644
index 0000000000..0ad2f6e8fd
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_call_limit.py
@@ -0,0 +1,224 @@
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import InMemorySaver
+
+from langchain.agents.factory import create_agent
+from langchain.agents.middleware.model_call_limit import (
+ ModelCallLimitMiddleware,
+ ModelCallLimitExceededError,
+)
+
+from ...model import FakeToolCallingModel
+
+
+@tool
+def simple_tool(input: str) -> str:
+ """A simple tool"""
+ return input
+
+
+def test_middleware_unit_functionality():
+ """Test that the middleware works as expected in isolation."""
+ # Test with end behavior
+ middleware = ModelCallLimitMiddleware(thread_limit=2, run_limit=1)
+
+ # Mock runtime (not used in current implementation)
+ runtime = None
+
+ # Test when limits are not exceeded
+ state = {"thread_model_call_count": 0, "run_model_call_count": 0}
+ result = middleware.before_model(state, runtime)
+ assert result is None
+
+ # Test when thread limit is exceeded
+ state = {"thread_model_call_count": 2, "run_model_call_count": 0}
+ result = middleware.before_model(state, runtime)
+ assert result is not None
+ assert result["jump_to"] == "end"
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert "thread limit (2/2)" in result["messages"][0].content
+
+ # Test when run limit is exceeded
+ state = {"thread_model_call_count": 1, "run_model_call_count": 1}
+ result = middleware.before_model(state, runtime)
+ assert result is not None
+ assert result["jump_to"] == "end"
+ assert "messages" in result
+ assert len(result["messages"]) == 1
+ assert "run limit (1/1)" in result["messages"][0].content
+
+ # Test with error behavior
+ middleware_exception = ModelCallLimitMiddleware(
+ thread_limit=2, run_limit=1, exit_behavior="error"
+ )
+
+ # Test exception when thread limit exceeded
+ state = {"thread_model_call_count": 2, "run_model_call_count": 0}
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ middleware_exception.before_model(state, runtime)
+
+ assert "thread limit (2/2)" in str(exc_info.value)
+
+ # Test exception when run limit exceeded
+ state = {"thread_model_call_count": 1, "run_model_call_count": 1}
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ middleware_exception.before_model(state, runtime)
+
+ assert "run limit (1/1)" in str(exc_info.value)
+
+
+def test_thread_limit_with_create_agent():
+ """Test that thread limits work correctly with create_agent."""
+ model = FakeToolCallingModel()
+
+ # Set thread limit to 1 (should be exceeded after 1 call)
+ agent = create_agent(
+ model=model,
+ tools=[simple_tool],
+ middleware=[ModelCallLimitMiddleware(thread_limit=1)],
+ checkpointer=InMemorySaver(),
+ )
+
+ # First invocation should work - 1 model call, within thread limit
+ result = agent.invoke(
+ {"messages": [HumanMessage("Hello")]}, {"configurable": {"thread_id": "thread1"}}
+ )
+
+ # Should complete successfully with 1 model call
+ assert "messages" in result
+ assert len(result["messages"]) == 2 # Human + AI messages
+
+ # Second invocation in same thread should hit thread limit
+ # The agent should jump to end after detecting the limit
+ result2 = agent.invoke(
+ {"messages": [HumanMessage("Hello again")]}, {"configurable": {"thread_id": "thread1"}}
+ )
+
+ assert "messages" in result2
+ # The agent should have detected the limit and jumped to end with a limit exceeded message
+ # So we should have: previous messages + new human message + limit exceeded AI message
+ assert len(result2["messages"]) == 4 # Previous Human + AI + New Human + Limit AI
+ assert isinstance(result2["messages"][0], HumanMessage) # First human
+ assert isinstance(result2["messages"][1], AIMessage) # First AI response
+ assert isinstance(result2["messages"][2], HumanMessage) # Second human
+ assert isinstance(result2["messages"][3], AIMessage) # Limit exceeded message
+ assert "thread limit" in result2["messages"][3].content
+
+
+def test_run_limit_with_create_agent():
+ """Test that run limits work correctly with create_agent."""
+ # Create a model that will make 2 calls
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [{"name": "simple_tool", "args": {"input": "test"}, "id": "1"}],
+ [], # No tool calls on second call
+ ]
+ )
+
+ # Set run limit to 1 (should be exceeded after 1 call)
+ agent = create_agent(
+ model=model,
+ tools=[simple_tool],
+ middleware=[ModelCallLimitMiddleware(run_limit=1)],
+ checkpointer=InMemorySaver(),
+ )
+
+ # This should hit the run limit after the first model call
+ result = agent.invoke(
+ {"messages": [HumanMessage("Hello")]}, {"configurable": {"thread_id": "thread1"}}
+ )
+
+ assert "messages" in result
+ # The agent should have made 1 model call then jumped to end with limit exceeded message
+ # So we should have: Human + AI + Tool + Limit exceeded AI message
+ assert len(result["messages"]) == 4 # Human + AI + Tool + Limit AI
+ assert isinstance(result["messages"][0], HumanMessage)
+ assert isinstance(result["messages"][1], AIMessage)
+ assert isinstance(result["messages"][2], ToolMessage)
+ assert isinstance(result["messages"][3], AIMessage) # Limit exceeded message
+ assert "run limit" in result["messages"][3].content
+
+
+def test_middleware_initialization_validation():
+ """Test that middleware initialization validates parameters correctly."""
+ # Test that at least one limit must be specified
+ with pytest.raises(ValueError, match="At least one limit must be specified"):
+ ModelCallLimitMiddleware()
+
+ # Test invalid exit behavior
+ with pytest.raises(ValueError, match="Invalid exit_behavior"):
+ ModelCallLimitMiddleware(thread_limit=5, exit_behavior="invalid")
+
+ # Test valid initialization
+ middleware = ModelCallLimitMiddleware(thread_limit=5, run_limit=3)
+ assert middleware.thread_limit == 5
+ assert middleware.run_limit == 3
+ assert middleware.exit_behavior == "end"
+
+ # Test with only thread limit
+ middleware = ModelCallLimitMiddleware(thread_limit=5)
+ assert middleware.thread_limit == 5
+ assert middleware.run_limit is None
+
+ # Test with only run limit
+ middleware = ModelCallLimitMiddleware(run_limit=3)
+ assert middleware.thread_limit is None
+ assert middleware.run_limit == 3
+
+
+def test_exception_error_message():
+ """Test that the exception provides clear error messages."""
+ middleware = ModelCallLimitMiddleware(thread_limit=2, run_limit=1, exit_behavior="error")
+
+ # Test thread limit exceeded
+ state = {"thread_model_call_count": 2, "run_model_call_count": 0}
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ middleware.before_model(state, None)
+
+ error_msg = str(exc_info.value)
+ assert "Model call limits exceeded" in error_msg
+ assert "thread limit (2/2)" in error_msg
+
+ # Test run limit exceeded
+ state = {"thread_model_call_count": 0, "run_model_call_count": 1}
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ middleware.before_model(state, None)
+
+ error_msg = str(exc_info.value)
+ assert "Model call limits exceeded" in error_msg
+ assert "run limit (1/1)" in error_msg
+
+ # Test both limits exceeded
+ state = {"thread_model_call_count": 2, "run_model_call_count": 1}
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ middleware.before_model(state, None)
+
+ error_msg = str(exc_info.value)
+ assert "Model call limits exceeded" in error_msg
+ assert "thread limit (2/2)" in error_msg
+ assert "run limit (1/1)" in error_msg
+
+
+def test_run_limit_resets_between_invocations() -> None:
+ """Test that run_model_call_count resets between invocations, but thread_model_call_count accumulates."""
+
+ # First: No tool calls per invocation, so model does not increment call counts internally
+ middleware = ModelCallLimitMiddleware(thread_limit=3, run_limit=1, exit_behavior="error")
+ model = FakeToolCallingModel(
+ tool_calls=[[], [], [], []]
+ ) # No tool calls, so only model call per run
+
+ agent = create_agent(model=model, middleware=[middleware], checkpointer=InMemorySaver())
+
+ thread_config = {"configurable": {"thread_id": "test_thread"}}
+ agent.invoke({"messages": [HumanMessage("Hello")]}, thread_config)
+ agent.invoke({"messages": [HumanMessage("Hello again")]}, thread_config)
+ agent.invoke({"messages": [HumanMessage("Hello third")]}, thread_config)
+
+ # Fourth run: should raise, thread_model_call_count == 3 (limit)
+ with pytest.raises(ModelCallLimitExceededError) as exc_info:
+ agent.invoke({"messages": [HumanMessage("Hello fourth")]}, thread_config)
+ error_msg = str(exc_info.value)
+ assert "thread limit (3/3)" in error_msg
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_model_fallback_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_fallback.py
similarity index 71%
rename from libs/langchain_v1/tests/unit_tests/agents/test_model_fallback_middleware.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_fallback.py
index 2c24296fc1..bf0b32ded3 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_model_fallback_middleware.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_fallback.py
@@ -5,13 +5,18 @@ from __future__ import annotations
from typing import cast
import pytest
+from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
-from langchain_core.messages import AIMessage
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+from langchain.agents.factory import create_agent
from langchain.agents.middleware.model_fallback import ModelFallbackMiddleware
from langchain.agents.middleware.types import ModelRequest, ModelResponse
from langgraph.runtime import Runtime
+from ...model import FakeToolCallingModel
+
def _fake_runtime() -> Runtime:
return cast(Runtime, object())
@@ -213,3 +218,90 @@ async def test_all_models_fail_async() -> None:
with pytest.raises(ValueError, match="Model failed"):
await middleware.awrap_model_call(request, mock_handler)
+
+
+def test_model_fallback_middleware_with_agent() -> None:
+ """Test ModelFallbackMiddleware with agent.invoke and fallback models only."""
+
+ class FailingModel(BaseChatModel):
+ """Model that always fails."""
+
+ def _generate(self, messages, **kwargs):
+ raise ValueError("Primary model failed")
+
+ @property
+ def _llm_type(self):
+ return "failing"
+
+ class SuccessModel(BaseChatModel):
+ """Model that succeeds."""
+
+ def _generate(self, messages, **kwargs):
+ return ChatResult(
+ generations=[ChatGeneration(message=AIMessage(content="Fallback success"))]
+ )
+
+ @property
+ def _llm_type(self):
+ return "success"
+
+ primary = FailingModel()
+ fallback = SuccessModel()
+
+ # Only pass fallback models to middleware (not the primary)
+ fallback_middleware = ModelFallbackMiddleware(fallback)
+
+ agent = create_agent(model=primary, middleware=[fallback_middleware])
+
+ result = agent.invoke({"messages": [HumanMessage("Test")]})
+
+ # Should have succeeded with fallback model
+ assert len(result["messages"]) == 2
+ assert result["messages"][1].content == "Fallback success"
+
+
+def test_model_fallback_middleware_exhausted_with_agent() -> None:
+ """Test ModelFallbackMiddleware with agent.invoke when all models fail."""
+
+ class AlwaysFailingModel(BaseChatModel):
+ """Model that always fails."""
+
+ def __init__(self, name: str):
+ super().__init__()
+ self.name = name
+
+ def _generate(self, messages, **kwargs):
+ raise ValueError(f"{self.name} failed")
+
+ @property
+ def _llm_type(self):
+ return self.name
+
+ primary = AlwaysFailingModel("primary")
+ fallback1 = AlwaysFailingModel("fallback1")
+ fallback2 = AlwaysFailingModel("fallback2")
+
+ # Primary fails (attempt 1), then fallback1 (attempt 2), then fallback2 (attempt 3)
+ fallback_middleware = ModelFallbackMiddleware(fallback1, fallback2)
+
+ agent = create_agent(model=primary, middleware=[fallback_middleware])
+
+ # Should fail with the last fallback's error
+ with pytest.raises(ValueError, match="fallback2 failed"):
+ agent.invoke({"messages": [HumanMessage("Test")]})
+
+
+def test_model_fallback_middleware_initialization() -> None:
+ """Test ModelFallbackMiddleware initialization."""
+
+ # Test with no models - now a TypeError (missing required argument)
+ with pytest.raises(TypeError):
+ ModelFallbackMiddleware() # type: ignore[call-arg]
+
+ # Test with one fallback model (valid)
+ middleware = ModelFallbackMiddleware(FakeToolCallingModel())
+ assert len(middleware.models) == 1
+
+ # Test with multiple fallback models
+ middleware = ModelFallbackMiddleware(FakeToolCallingModel(), FakeToolCallingModel())
+ assert len(middleware.models) == 2
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_pii_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_pii.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/test_pii_middleware.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_pii.py
index 5b76f79ef0..3fbd04b118 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_pii_middleware.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_pii.py
@@ -14,7 +14,7 @@ from langchain.agents.middleware.pii import (
)
from langchain.agents.factory import create_agent
-from .model import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
# ============================================================================
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_execution_policies.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_execution_policies.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_execution_policies.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_execution_policies.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_tool.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_tool.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_tool.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_tool.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_structured_output_retry.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_structured_output_retry.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_structured_output_retry.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_structured_output_retry.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_summarization.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_summarization.py
new file mode 100644
index 0000000000..b7a3943f2e
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_summarization.py
@@ -0,0 +1,566 @@
+from typing import TYPE_CHECKING
+
+import pytest
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, RemoveMessage, ToolMessage
+from langchain_core.outputs import ChatGeneration, ChatResult
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from unittest.mock import patch
+
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+
+from ...model import FakeToolCallingModel
+
+if TYPE_CHECKING:
+ from langchain_model_profiles import ModelProfile
+
+
+def test_summarization_middleware_initialization() -> None:
+ """Test SummarizationMiddleware initialization."""
+ model = FakeToolCallingModel()
+ middleware = SummarizationMiddleware(
+ model=model,
+ trigger=("tokens", 1000),
+ keep=("messages", 10),
+ summary_prompt="Custom prompt: {messages}",
+ )
+
+ assert middleware.model == model
+ assert middleware.trigger == ("tokens", 1000)
+ assert middleware.keep == ("messages", 10)
+ assert middleware.summary_prompt == "Custom prompt: {messages}"
+ assert middleware.trim_tokens_to_summarize == 4000
+
+ with pytest.raises(ValueError):
+ SummarizationMiddleware(model=model, keep=("fraction", 0.5)) # no model profile
+
+ # Test with string model
+ with patch(
+ "langchain.agents.middleware.summarization.init_chat_model",
+ return_value=FakeToolCallingModel(),
+ ):
+ middleware = SummarizationMiddleware(model="fake-model")
+ assert isinstance(middleware.model, FakeToolCallingModel)
+
+
+def test_summarization_middleware_no_summarization_cases() -> None:
+ """Test SummarizationMiddleware when summarization is not needed or disabled."""
+ model = FakeToolCallingModel()
+ middleware = SummarizationMiddleware(model=model, trigger=("tokens", 1000))
+
+ # Test when summarization is disabled
+ middleware_disabled = SummarizationMiddleware(model=model, trigger=None)
+ state = {"messages": [HumanMessage(content="Hello"), AIMessage(content="Hi")]}
+ result = middleware_disabled.before_model(state, None)
+ assert result is None
+
+ # Test when token count is below threshold
+ def mock_token_counter(messages):
+ return 500 # Below threshold
+
+ middleware.token_counter = mock_token_counter
+ result = middleware.before_model(state, None)
+ assert result is None
+
+
+def test_summarization_middleware_helper_methods() -> None:
+ """Test SummarizationMiddleware helper methods."""
+ model = FakeToolCallingModel()
+ middleware = SummarizationMiddleware(model=model, trigger=("tokens", 1000))
+
+ # Test message ID assignment
+ messages = [HumanMessage(content="Hello"), AIMessage(content="Hi")]
+ middleware._ensure_message_ids(messages)
+ for msg in messages:
+ assert msg.id is not None
+
+ # Test message partitioning
+ messages = [
+ HumanMessage(content="1"),
+ HumanMessage(content="2"),
+ HumanMessage(content="3"),
+ HumanMessage(content="4"),
+ HumanMessage(content="5"),
+ ]
+ to_summarize, preserved = middleware._partition_messages(messages, 2)
+ assert len(to_summarize) == 2
+ assert len(preserved) == 3
+ assert to_summarize == messages[:2]
+ assert preserved == messages[2:]
+
+ # Test summary message building
+ summary = "This is a test summary"
+ new_messages = middleware._build_new_messages(summary)
+ assert len(new_messages) == 1
+ assert isinstance(new_messages[0], HumanMessage)
+ assert "Here is a summary of the conversation to date:" in new_messages[0].content
+ assert summary in new_messages[0].content
+
+ # Test tool call detection
+ ai_message_no_tools = AIMessage(content="Hello")
+ assert not middleware._has_tool_calls(ai_message_no_tools)
+
+ ai_message_with_tools = AIMessage(
+ content="Hello", tool_calls=[{"name": "test", "args": {}, "id": "1"}]
+ )
+ assert middleware._has_tool_calls(ai_message_with_tools)
+
+ human_message = HumanMessage(content="Hello")
+ assert not middleware._has_tool_calls(human_message)
+
+
+def test_summarization_middleware_tool_call_safety() -> None:
+ """Test SummarizationMiddleware tool call safety logic."""
+ model = FakeToolCallingModel()
+ middleware = SummarizationMiddleware(
+ model=model, trigger=("tokens", 1000), keep=("messages", 3)
+ )
+
+ # Test safe cutoff point detection with tool calls
+ messages = [
+ HumanMessage(content="1"),
+ AIMessage(content="2", tool_calls=[{"name": "test", "args": {}, "id": "1"}]),
+ ToolMessage(content="3", tool_call_id="1"),
+ HumanMessage(content="4"),
+ ]
+
+ # Safe cutoff (doesn't separate AI/Tool pair)
+ is_safe = middleware._is_safe_cutoff_point(messages, 0)
+ assert is_safe is True
+
+ # Unsafe cutoff (separates AI/Tool pair)
+ is_safe = middleware._is_safe_cutoff_point(messages, 2)
+ assert is_safe is False
+
+ # Test tool call ID extraction
+ ids = middleware._extract_tool_call_ids(messages[1])
+ assert ids == {"1"}
+
+
+def test_summarization_middleware_summary_creation() -> None:
+ """Test SummarizationMiddleware summary creation."""
+
+ class MockModel(BaseChatModel):
+ def invoke(self, prompt):
+ return AIMessage(content="Generated summary")
+
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ middleware = SummarizationMiddleware(model=MockModel(), trigger=("tokens", 1000))
+
+ # Test normal summary creation
+ messages = [HumanMessage(content="Hello"), AIMessage(content="Hi")]
+ summary = middleware._create_summary(messages)
+ assert summary == "Generated summary"
+
+ # Test empty messages
+ summary = middleware._create_summary([])
+ assert summary == "No previous conversation history."
+
+ # Test error handling
+ class ErrorModel(BaseChatModel):
+ def invoke(self, prompt):
+ raise Exception("Model error")
+
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ middleware_error = SummarizationMiddleware(model=ErrorModel(), trigger=("tokens", 1000))
+ summary = middleware_error._create_summary(messages)
+ assert "Error generating summary: Model error" in summary
+
+ # Test we raise warning if max_tokens_before_summary or messages_to_keep is specified
+ with pytest.warns(DeprecationWarning, match="max_tokens_before_summary is deprecated"):
+ SummarizationMiddleware(model=MockModel(), max_tokens_before_summary=500)
+ with pytest.warns(DeprecationWarning, match="messages_to_keep is deprecated"):
+ SummarizationMiddleware(model=MockModel(), messages_to_keep=5)
+
+
+def test_summarization_middleware_trim_limit_none_keeps_all_messages() -> None:
+ """Verify disabling trim limit preserves full message sequence."""
+
+ class MockModel(BaseChatModel):
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ messages = [HumanMessage(content=str(i)) for i in range(10)]
+ middleware = SummarizationMiddleware(
+ model=MockModel(),
+ trim_tokens_to_summarize=None,
+ )
+ middleware.token_counter = lambda msgs: len(msgs)
+
+ trimmed = middleware._trim_messages_for_summary(messages)
+ assert trimmed is messages
+
+
+def test_summarization_middleware_profile_inference_triggers_summary() -> None:
+ """Ensure automatic profile inference triggers summarization when limits are exceeded."""
+
+ class ProfileModel(BaseChatModel):
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self) -> str:
+ return "mock"
+
+ @property
+ def profile(self) -> "ModelProfile":
+ return {"max_input_tokens": 1000}
+
+ token_counter = lambda messages: len(messages) * 200
+
+ middleware = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.81),
+ keep=("fraction", 0.5),
+ token_counter=token_counter,
+ )
+
+ state = {
+ "messages": [
+ HumanMessage(content="Message 1"),
+ AIMessage(content="Message 2"),
+ HumanMessage(content="Message 3"),
+ AIMessage(content="Message 4"),
+ ]
+ }
+
+ # Test we don't engage summarization
+ # total_tokens = 4 * 200 = 800
+ # max_input_tokens = 1000
+ # 0.81 * 1000 == 810 > 800 -> summarization not triggered
+ result = middleware.before_model(state, None)
+ assert result is None
+
+ # Engage summarization
+ # 0.80 * 1000 == 800 <= 800
+ middleware = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.80),
+ keep=("fraction", 0.5),
+ token_counter=token_counter,
+ )
+ result = middleware.before_model(state, None)
+ assert result is not None
+ assert isinstance(result["messages"][0], RemoveMessage)
+ summary_message = result["messages"][1]
+ assert isinstance(summary_message, HumanMessage)
+ assert summary_message.text.startswith("Here is a summary of the conversation")
+ assert len(result["messages"][2:]) == 2 # Preserved messages
+ assert [message.content for message in result["messages"][2:]] == [
+ "Message 3",
+ "Message 4",
+ ]
+
+ # With keep=("fraction", 0.6) the target token allowance becomes 600,
+ # so the cutoff shifts to keep the last three messages instead of two.
+ middleware = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.80),
+ keep=("fraction", 0.6),
+ token_counter=token_counter,
+ )
+ result = middleware.before_model(state, None)
+ assert result is not None
+ assert [message.content for message in result["messages"][2:]] == [
+ "Message 2",
+ "Message 3",
+ "Message 4",
+ ]
+
+ # Once keep=("fraction", 0.8) the inferred limit equals the full
+ # context (target tokens = 800), so token-based retention keeps everything
+ # and summarization is skipped entirely.
+ middleware = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.80),
+ keep=("fraction", 0.8),
+ token_counter=token_counter,
+ )
+ assert middleware.before_model(state, None) is None
+
+ # Test with tokens_to_keep as absolute int value
+ middleware_int = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.80),
+ keep=("tokens", 400), # Keep exactly 400 tokens (2 messages)
+ token_counter=token_counter,
+ )
+ result = middleware_int.before_model(state, None)
+ assert result is not None
+ assert [message.content for message in result["messages"][2:]] == [
+ "Message 3",
+ "Message 4",
+ ]
+
+ # Test with tokens_to_keep as larger int value
+ middleware_int_large = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.80),
+ keep=("tokens", 600), # Keep 600 tokens (3 messages)
+ token_counter=token_counter,
+ )
+ result = middleware_int_large.before_model(state, None)
+ assert result is not None
+ assert [message.content for message in result["messages"][2:]] == [
+ "Message 2",
+ "Message 3",
+ "Message 4",
+ ]
+
+
+def test_summarization_middleware_token_retention_pct_respects_tool_pairs() -> None:
+ """Ensure token retention keeps pairs together even if exceeding target tokens."""
+
+ class ProfileModel(BaseChatModel):
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self) -> str:
+ return "mock"
+
+ @property
+ def profile(self) -> "ModelProfile":
+ return {"max_input_tokens": 1000}
+
+ def token_counter(messages):
+ return sum(len(getattr(message, "content", "")) for message in messages)
+
+ middleware = SummarizationMiddleware(
+ model=ProfileModel(),
+ trigger=("fraction", 0.1),
+ keep=("fraction", 0.5),
+ )
+ middleware.token_counter = token_counter
+
+ messages: list[AnyMessage] = [
+ HumanMessage(content="H" * 300),
+ AIMessage(
+ content="A" * 200,
+ tool_calls=[{"name": "test", "args": {}, "id": "call-1"}],
+ ),
+ ToolMessage(content="T" * 50, tool_call_id="call-1"),
+ HumanMessage(content="H" * 180),
+ HumanMessage(content="H" * 160),
+ ]
+
+ state = {"messages": messages}
+ result = middleware.before_model(state, None)
+ assert result is not None
+
+ preserved_messages = result["messages"][2:]
+ assert preserved_messages == messages[1:]
+
+ target_token_count = int(1000 * 0.5)
+ preserved_tokens = middleware.token_counter(preserved_messages)
+
+ # Tool pair retention can exceed the target token count but should keep the pair intact.
+ assert preserved_tokens > target_token_count
+
+
+def test_summarization_middleware_missing_profile() -> None:
+ """Ensure automatic profile inference falls back when profiles are unavailable."""
+
+ class ImportErrorProfileModel(BaseChatModel):
+ def _generate(self, messages, **kwargs):
+ raise NotImplementedError
+
+ @property
+ def _llm_type(self) -> str:
+ return "mock"
+
+ @property
+ def profile(self):
+ raise ImportError("Profile not available")
+
+ with pytest.raises(
+ ValueError,
+ match="Model profile information is required to use fractional token limits",
+ ):
+ _ = SummarizationMiddleware(
+ model=ImportErrorProfileModel, trigger=("fraction", 0.5), keep=("messages", 1)
+ )
+
+
+def test_summarization_middleware_full_workflow() -> None:
+ """Test SummarizationMiddleware complete summarization workflow."""
+
+ class MockModel(BaseChatModel):
+ def invoke(self, prompt):
+ return AIMessage(content="Generated summary")
+
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ with pytest.warns(DeprecationWarning):
+ # keep test for functionality
+ middleware = SummarizationMiddleware(
+ model=MockModel(), max_tokens_before_summary=1000, messages_to_keep=2
+ )
+
+ # Mock high token count to trigger summarization
+ def mock_token_counter(messages):
+ return 1500 # Above threshold
+
+ middleware.token_counter = mock_token_counter
+
+ messages = [
+ HumanMessage(content="1"),
+ HumanMessage(content="2"),
+ HumanMessage(content="3"),
+ HumanMessage(content="4"),
+ HumanMessage(content="5"),
+ ]
+
+ state = {"messages": messages}
+ result = middleware.before_model(state, None)
+
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) > 0
+
+ # Should have RemoveMessage for cleanup
+ assert isinstance(result["messages"][0], RemoveMessage)
+ assert result["messages"][0].id == REMOVE_ALL_MESSAGES
+
+ # Should have summary message
+ summary_message = None
+ for msg in result["messages"]:
+ if isinstance(msg, HumanMessage) and "summary of the conversation" in msg.content:
+ summary_message = msg
+ break
+
+ assert summary_message is not None
+ assert "Generated summary" in summary_message.content
+
+
+async def test_summarization_middleware_full_workflow_async() -> None:
+ """Test SummarizationMiddleware complete summarization workflow."""
+
+ class MockModel(BaseChatModel):
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Blep"))])
+
+ async def _agenerate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Blip"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ middleware = SummarizationMiddleware(
+ model=MockModel(), trigger=("tokens", 1000), keep=("messages", 2)
+ )
+
+ # Mock high token count to trigger summarization
+ def mock_token_counter(messages):
+ return 1500 # Above threshold
+
+ middleware.token_counter = mock_token_counter
+
+ messages = [
+ HumanMessage(content="1"),
+ HumanMessage(content="2"),
+ HumanMessage(content="3"),
+ HumanMessage(content="4"),
+ HumanMessage(content="5"),
+ ]
+
+ state = {"messages": messages}
+ result = await middleware.abefore_model(state, None)
+
+ assert result is not None
+ assert "messages" in result
+ assert len(result["messages"]) > 0
+
+ expected_types = ["remove", "human", "human", "human"]
+ actual_types = [message.type for message in result["messages"]]
+ assert actual_types == expected_types
+ assert [message.content for message in result["messages"][2:]] == ["4", "5"]
+
+ summary_message = result["messages"][1]
+ assert "Blip" in summary_message.text
+
+
+def test_summarization_middleware_keep_messages() -> None:
+ """Test SummarizationMiddleware with keep parameter specifying messages."""
+
+ class MockModel(BaseChatModel):
+ def invoke(self, prompt):
+ return AIMessage(content="Generated summary")
+
+ def _generate(self, messages, **kwargs):
+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
+
+ @property
+ def _llm_type(self):
+ return "mock"
+
+ # Test that summarization is triggered when message count reaches threshold
+ middleware = SummarizationMiddleware(
+ model=MockModel(), trigger=("messages", 5), keep=("messages", 2)
+ )
+
+ # Below threshold - no summarization
+ messages_below = [
+ HumanMessage(content="1"),
+ HumanMessage(content="2"),
+ HumanMessage(content="3"),
+ HumanMessage(content="4"),
+ ]
+ state_below = {"messages": messages_below}
+ result = middleware.before_model(state_below, None)
+ assert result is None
+
+ # At threshold - should trigger summarization
+ messages_at_threshold = [
+ HumanMessage(content="1"),
+ HumanMessage(content="2"),
+ HumanMessage(content="3"),
+ HumanMessage(content="4"),
+ HumanMessage(content="5"),
+ ]
+ state_at = {"messages": messages_at_threshold}
+ result = middleware.before_model(state_at, None)
+ assert result is not None
+ assert "messages" in result
+ expected_types = ["remove", "human", "human", "human"]
+ actual_types = [message.type for message in result["messages"]]
+ assert actual_types == expected_types
+ assert [message.content for message in result["messages"][2:]] == ["4", "5"]
+
+ # Above threshold - should also trigger summarization
+ messages_above = messages_at_threshold + [HumanMessage(content="6")]
+ state_above = {"messages": messages_above}
+ result = middleware.before_model(state_above, None)
+ assert result is not None
+ assert "messages" in result
+ expected_types = ["remove", "human", "human", "human"]
+ actual_types = [message.type for message in result["messages"]]
+ assert actual_types == expected_types
+ assert [message.content for message in result["messages"][2:]] == ["5", "6"]
+
+ # Test with both parameters disabled
+ middleware_disabled = SummarizationMiddleware(model=MockModel(), trigger=None)
+ result = middleware_disabled.before_model(state_above, None)
+ assert result is None
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_todo.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_todo.py
new file mode 100644
index 0000000000..29f8315829
--- /dev/null
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_todo.py
@@ -0,0 +1,453 @@
+"""Unit tests for TodoListMiddleware."""
+
+from __future__ import annotations
+
+from typing import cast
+
+import pytest
+from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.runtime import Runtime
+
+from langchain.agents.factory import create_agent
+from langchain.agents.middleware.todo import (
+ PlanningState,
+ TodoListMiddleware,
+ WRITE_TODOS_SYSTEM_PROMPT,
+ WRITE_TODOS_TOOL_DESCRIPTION,
+ write_todos,
+)
+from langchain.agents.middleware.types import ModelRequest, ModelResponse
+
+from ...model import FakeToolCallingModel
+
+
+def _fake_runtime() -> Runtime:
+ return cast(Runtime, object())
+
+
+def _make_request(system_prompt: str | None = None) -> ModelRequest:
+ """Create a minimal ModelRequest for testing."""
+ model = GenericFakeChatModel(messages=iter([AIMessage(content="response")]))
+ return ModelRequest(
+ model=model,
+ system_prompt=system_prompt,
+ messages=[],
+ tool_choice=None,
+ tools=[],
+ response_format=None,
+ state=cast("AgentState", {}), # type: ignore[name-defined]
+ runtime=_fake_runtime(),
+ model_settings={},
+ )
+
+
+# ==============================================================================
+# Synchronous Tests
+# ==============================================================================
+
+
+def test_todo_middleware_initialization() -> None:
+ """Test that TodoListMiddleware initializes correctly."""
+ middleware = TodoListMiddleware()
+ assert middleware.state_schema == PlanningState
+ assert len(middleware.tools) == 1
+ assert middleware.tools[0].name == "write_todos"
+
+
+def test_has_write_todos_tool() -> None:
+ """Test that middleware registers the write_todos tool."""
+ middleware = TodoListMiddleware()
+
+ # Should have one tool registered
+ assert len(middleware.tools) == 1
+ assert middleware.tools[0].name == "write_todos"
+
+
+def test_todo_middleware_default_prompts() -> None:
+ """Test that TodoListMiddleware uses default prompts when none provided."""
+ middleware = TodoListMiddleware()
+
+ # Verify default system prompt
+ assert middleware.system_prompt == WRITE_TODOS_SYSTEM_PROMPT
+
+ # Verify default tool description
+ assert middleware.tool_description == WRITE_TODOS_TOOL_DESCRIPTION
+ assert len(middleware.tools) == 1
+ tool = middleware.tools[0]
+ assert tool.description == WRITE_TODOS_TOOL_DESCRIPTION
+
+
+def test_adds_system_prompt_when_none_exists() -> None:
+ """Test that middleware adds system prompt when request has none."""
+ middleware = TodoListMiddleware()
+ request = _make_request(system_prompt=None)
+
+ def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ middleware.wrap_model_call(request, mock_handler)
+
+ # System prompt should be set
+ assert request.system_prompt is not None
+ assert "write_todos" in request.system_prompt
+
+
+def test_appends_to_existing_system_prompt() -> None:
+ """Test that middleware appends to existing system prompt."""
+ existing_prompt = "You are a helpful assistant."
+ middleware = TodoListMiddleware()
+ request = _make_request(system_prompt=existing_prompt)
+
+ def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ middleware.wrap_model_call(request, mock_handler)
+
+ # System prompt should contain both
+ assert request.system_prompt is not None
+ assert existing_prompt in request.system_prompt
+ assert "write_todos" in request.system_prompt
+ assert request.system_prompt.startswith(existing_prompt)
+
+
+ "original_prompt,expected_prompt_prefix",
+ [
+ ("Original prompt", "Original prompt\n\n## `write_todos`"),
+ (None, "## `write_todos`"),
+ ],
+)
+def test_todo_middleware_on_model_call(original_prompt, expected_prompt_prefix) -> None:
+ """Test that wrap_model_call handles system prompts correctly."""
+ middleware = TodoListMiddleware()
+ model = FakeToolCallingModel()
+
+ state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
+
+ request = ModelRequest(
+ model=model,
+ system_prompt=original_prompt,
+ messages=[HumanMessage(content="Hello")],
+ tool_choice=None,
+ tools=[],
+ response_format=None,
+ state=state,
+ runtime=cast(Runtime, object()),
+ model_settings={},
+ )
+
+ def mock_handler(req: ModelRequest) -> AIMessage:
+ return AIMessage(content="mock response")
+
+ # Call wrap_model_call to trigger the middleware logic
+ middleware.wrap_model_call(request, mock_handler)
+ # Check that the request was modified in place
+ assert request.system_prompt.startswith(expected_prompt_prefix)
+
+
+def test_custom_system_prompt() -> None:
+ """Test that middleware uses custom system prompt."""
+ custom_prompt = "Custom planning instructions"
+ middleware = TodoListMiddleware(system_prompt=custom_prompt)
+ request = _make_request(system_prompt=None)
+
+ def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ middleware.wrap_model_call(request, mock_handler)
+
+ # Should use custom prompt
+ assert request.system_prompt == custom_prompt
+
+
+def test_todo_middleware_custom_system_prompt() -> None:
+ """Test that TodoListMiddleware can be initialized with custom system prompt."""
+ custom_system_prompt = "Custom todo system prompt for testing"
+ middleware = TodoListMiddleware(system_prompt=custom_system_prompt)
+ model = FakeToolCallingModel()
+
+ state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
+
+ request = ModelRequest(
+ model=model,
+ system_prompt="Original prompt",
+ messages=[HumanMessage(content="Hello")],
+ tool_choice=None,
+ tools=[],
+ response_format=None,
+ model_settings={},
+ state=state,
+ runtime=cast(Runtime, object()),
+ )
+
+ def mock_handler(req: ModelRequest) -> AIMessage:
+ return AIMessage(content="mock response")
+
+ # Call wrap_model_call to trigger the middleware logic
+ middleware.wrap_model_call(request, mock_handler)
+ # Check that the request was modified in place
+ assert request.system_prompt == f"Original prompt\n\n{custom_system_prompt}"
+
+
+def test_custom_tool_description() -> None:
+ """Test that middleware uses custom tool description."""
+ custom_description = "Custom todo tool description"
+ middleware = TodoListMiddleware(tool_description=custom_description)
+
+ # Tool should use custom description
+ assert len(middleware.tools) == 1
+ assert middleware.tools[0].description == custom_description
+
+
+def test_todo_middleware_custom_tool_description() -> None:
+ """Test that TodoListMiddleware can be initialized with custom tool description."""
+ custom_tool_description = "Custom tool description for testing"
+ middleware = TodoListMiddleware(tool_description=custom_tool_description)
+
+ assert len(middleware.tools) == 1
+ tool = middleware.tools[0]
+ assert tool.description == custom_tool_description
+
+
+def test_todo_middleware_custom_system_prompt_and_tool_description() -> None:
+ """Test that TodoListMiddleware can be initialized with both custom prompts."""
+ custom_system_prompt = "Custom system prompt"
+ custom_tool_description = "Custom tool description"
+ middleware = TodoListMiddleware(
+ system_prompt=custom_system_prompt,
+ tool_description=custom_tool_description,
+ )
+
+ # Verify system prompt
+ model = FakeToolCallingModel()
+ state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
+
+ request = ModelRequest(
+ model=model,
+ system_prompt=None,
+ messages=[HumanMessage(content="Hello")],
+ tool_choice=None,
+ tools=[],
+ response_format=None,
+ state=state,
+ runtime=cast(Runtime, object()),
+ model_settings={},
+ )
+
+ def mock_handler(req: ModelRequest) -> AIMessage:
+ return AIMessage(content="mock response")
+
+ # Call wrap_model_call to trigger the middleware logic
+ middleware.wrap_model_call(request, mock_handler)
+ # Check that the request was modified in place
+ assert request.system_prompt == custom_system_prompt
+
+ # Verify tool description
+ assert len(middleware.tools) == 1
+ tool = middleware.tools[0]
+ assert tool.description == custom_tool_description
+
+
+ "todos,expected_message",
+ [
+ ([], "Updated todo list to []"),
+ (
+ [{"content": "Task 1", "status": "pending"}],
+ "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}]",
+ ),
+ (
+ [
+ {"content": "Task 1", "status": "pending"},
+ {"content": "Task 2", "status": "in_progress"},
+ ],
+ "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}, {'content': 'Task 2', 'status': 'in_progress'}]",
+ ),
+ (
+ [
+ {"content": "Task 1", "status": "pending"},
+ {"content": "Task 2", "status": "in_progress"},
+ {"content": "Task 3", "status": "completed"},
+ ],
+ "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}, {'content': 'Task 2', 'status': 'in_progress'}, {'content': 'Task 3', 'status': 'completed'}]",
+ ),
+ ],
+)
+def test_todo_middleware_write_todos_tool_execution(todos, expected_message) -> None:
+ """Test that the write_todos tool executes correctly."""
+ tool_call = {
+ "args": {"todos": todos},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ result = write_todos.invoke(tool_call)
+ assert result.update["todos"] == todos
+ assert result.update["messages"][0].content == expected_message
+
+
+ "invalid_todos",
+ [
+ [{"content": "Task 1", "status": "invalid_status"}],
+ [{"status": "pending"}],
+ ],
+)
+def test_todo_middleware_write_todos_tool_validation_errors(invalid_todos) -> None:
+ """Test that the write_todos tool rejects invalid input."""
+ tool_call = {
+ "args": {"todos": invalid_todos},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ with pytest.raises(Exception):
+ write_todos.invoke(tool_call)
+
+
+def test_todo_middleware_agent_creation_with_middleware() -> None:
+ """Test that an agent can be created with the planning middleware."""
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [
+ {
+ "args": {"todos": [{"content": "Task 1", "status": "pending"}]},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ ],
+ [
+ {
+ "args": {"todos": [{"content": "Task 1", "status": "in_progress"}]},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ ],
+ [
+ {
+ "args": {"todos": [{"content": "Task 1", "status": "completed"}]},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ ],
+ [],
+ ]
+ )
+ middleware = TodoListMiddleware()
+ agent = create_agent(model=model, middleware=[middleware])
+
+ result = agent.invoke({"messages": [HumanMessage("Hello")]})
+ assert result["todos"] == [{"content": "Task 1", "status": "completed"}]
+
+ # human message (1)
+ # ai message (2) - initial todo
+ # tool message (3)
+ # ai message (4) - updated todo
+ # tool message (5)
+ # ai message (6) - complete todo
+ # tool message (7)
+ # ai message (8) - no tool calls
+ assert len(result["messages"]) == 8
+
+
+def test_todo_middleware_custom_system_prompt_in_agent() -> None:
+ """Test that custom tool executes correctly in an agent."""
+ middleware = TodoListMiddleware(system_prompt="call the write_todos tool")
+
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [
+ {
+ "args": {"todos": [{"content": "Custom task", "status": "pending"}]},
+ "name": "write_todos",
+ "type": "tool_call",
+ "id": "test_call",
+ }
+ ],
+ [],
+ ]
+ )
+
+ agent = create_agent(model=model, middleware=[middleware])
+
+ result = agent.invoke({"messages": [HumanMessage("Hello")]})
+ assert result["todos"] == [{"content": "Custom task", "status": "pending"}]
+ # assert custom system prompt is in the first AI message
+ assert "call the write_todos tool" in result["messages"][1].content
+
+
+# ==============================================================================
+# Async Tests
+# ==============================================================================
+
+
+async def test_adds_system_prompt_when_none_exists_async() -> None:
+ """Test async version - middleware adds system prompt when request has none."""
+ middleware = TodoListMiddleware()
+ request = _make_request(system_prompt=None)
+
+ async def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ await middleware.awrap_model_call(request, mock_handler)
+
+ # System prompt should be set
+ assert request.system_prompt is not None
+ assert "write_todos" in request.system_prompt
+
+
+async def test_appends_to_existing_system_prompt_async() -> None:
+ """Test async version - middleware appends to existing system prompt."""
+ existing_prompt = "You are a helpful assistant."
+ middleware = TodoListMiddleware()
+ request = _make_request(system_prompt=existing_prompt)
+
+ async def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ await middleware.awrap_model_call(request, mock_handler)
+
+ # System prompt should contain both
+ assert request.system_prompt is not None
+ assert existing_prompt in request.system_prompt
+ assert "write_todos" in request.system_prompt
+ assert request.system_prompt.startswith(existing_prompt)
+
+
+async def test_custom_system_prompt_async() -> None:
+ """Test async version - middleware uses custom system prompt."""
+ custom_prompt = "Custom planning instructions"
+ middleware = TodoListMiddleware(system_prompt=custom_prompt)
+ request = _make_request(system_prompt=None)
+
+ async def mock_handler(req: ModelRequest) -> ModelResponse:
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ await middleware.awrap_model_call(request, mock_handler)
+
+ # Should use custom prompt
+ assert request.system_prompt == custom_prompt
+
+
+async def test_handler_called_with_modified_request_async() -> None:
+ """Test async version - handler receives the modified request."""
+ middleware = TodoListMiddleware()
+ request = _make_request(system_prompt="Original")
+ handler_called = {"value": False}
+ received_prompt = {"value": None}
+
+ async def mock_handler(req: ModelRequest) -> ModelResponse:
+ handler_called["value"] = True
+ received_prompt["value"] = req.system_prompt
+ return ModelResponse(result=[AIMessage(content="response")])
+
+ await middleware.awrap_model_call(request, mock_handler)
+
+ assert handler_called["value"]
+ assert received_prompt["value"] is not None
+ assert "Original" in received_prompt["value"]
+ assert "write_todos" in received_prompt["value"]
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_tool_call_limit.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_call_limit.py
similarity index 77%
rename from libs/langchain_v1/tests/unit_tests/agents/test_tool_call_limit.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_call_limit.py
index d382eb885d..961b0e6225 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_tool_call_limit.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_call_limit.py
@@ -10,7 +10,7 @@ from langchain.agents.middleware.tool_call_limit import (
ToolCallLimitExceededError,
ToolCallLimitMiddleware,
)
-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
def test_middleware_initialization_validation():
@@ -605,3 +605,185 @@ def test_end_behavior_creates_artificial_messages():
assert "Do not" in error_msg_content, (
"Tool message should instruct model not to call tool again"
)
+
+
+def test_parallel_tool_calls_with_limit_continue_mode():
+ """Test parallel tool calls with a limit of 1 in 'continue' mode.
+
+ When the model proposes 3 tool calls with a limit of 1:
+ - The first call should execute successfully
+ - The 2nd and 3rd calls should be blocked with error ToolMessages
+ - Execution should continue (no jump_to)
+ """
+
+ @tool
+ def search(query: str) -> str:
+ """Search for information."""
+ return f"Results: {query}"
+
+ # Model proposes 3 parallel search calls in a single AIMessage
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [
+ ToolCall(name="search", args={"query": "q1"}, id="1"),
+ ToolCall(name="search", args={"query": "q2"}, id="2"),
+ ToolCall(name="search", args={"query": "q3"}, id="3"),
+ ],
+ [], # Model stops after seeing the errors
+ ]
+ )
+
+ limiter = ToolCallLimitMiddleware(thread_limit=1, exit_behavior="continue")
+ agent = create_agent(
+ model=model, tools=[search], middleware=[limiter], checkpointer=InMemorySaver()
+ )
+
+ result = agent.invoke(
+ {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
+ )
+ messages = result["messages"]
+
+ # Verify tool message counts
+ tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
+ successful_tool_messages = [msg for msg in tool_messages if msg.status != "error"]
+ error_tool_messages = [msg for msg in tool_messages if msg.status == "error"]
+
+ assert len(successful_tool_messages) == 1, "Should have 1 successful tool message (q1)"
+ assert len(error_tool_messages) == 2, "Should have 2 blocked tool messages (q2, q3)"
+
+ # Verify the successful call is q1
+ assert "q1" in successful_tool_messages[0].content
+
+ # Verify error messages explain the limit
+ for error_msg in error_tool_messages:
+ assert "limit" in error_msg.content.lower()
+
+ # Verify execution continued (no early termination)
+ ai_messages = [msg for msg in messages if isinstance(msg, AIMessage)]
+ # Should have: initial AI message with 3 tool calls, then final AI message (no tool calls)
+ assert len(ai_messages) >= 2
+
+
+def test_parallel_tool_calls_with_limit_end_mode():
+ """Test parallel tool calls with a limit of 1 in 'end' mode.
+
+ When the model proposes 3 tool calls with a limit of 1:
+ - The first call would be allowed (within limit)
+ - The 2nd and 3rd calls exceed the limit and get blocked with error ToolMessages
+ - Execution stops immediately (jump_to: end) so NO tools actually execute
+ - An AI message explains why execution stopped
+ """
+
+ @tool
+ def search(query: str) -> str:
+ """Search for information."""
+ return f"Results: {query}"
+
+ # Model proposes 3 parallel search calls
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [
+ ToolCall(name="search", args={"query": "q1"}, id="1"),
+ ToolCall(name="search", args={"query": "q2"}, id="2"),
+ ToolCall(name="search", args={"query": "q3"}, id="3"),
+ ],
+ [],
+ ]
+ )
+
+ limiter = ToolCallLimitMiddleware(thread_limit=1, exit_behavior="end")
+ agent = create_agent(
+ model=model, tools=[search], middleware=[limiter], checkpointer=InMemorySaver()
+ )
+
+ result = agent.invoke(
+ {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
+ )
+ messages = result["messages"]
+
+ # Verify tool message counts
+ # With "end" behavior, when we jump to end, NO tools execute (not even allowed ones)
+ # We only get error ToolMessages for the 2 blocked calls
+ tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
+ successful_tool_messages = [msg for msg in tool_messages if msg.status != "error"]
+ error_tool_messages = [msg for msg in tool_messages if msg.status == "error"]
+
+ assert len(successful_tool_messages) == 0, "No tools execute when we jump to end"
+ assert len(error_tool_messages) == 2, "Should have 2 blocked tool messages (q2, q3)"
+
+ # Verify error tool messages (sent to model - include "Do not" instruction)
+ for error_msg in error_tool_messages:
+ assert "Tool call limit exceeded" in error_msg.content
+ assert "Do not" in error_msg.content
+
+ # Verify AI message explaining why execution stopped (displayed to user - includes thread/run details)
+ ai_limit_messages = [
+ msg
+ for msg in messages
+ if isinstance(msg, AIMessage) and "limit" in msg.content.lower() and not msg.tool_calls
+ ]
+ assert len(ai_limit_messages) == 1, "Should have exactly one AI message explaining the limit"
+
+ ai_msg_content = ai_limit_messages[0].content.lower()
+ assert "thread limit exceeded" in ai_msg_content or "run limit exceeded" in ai_msg_content, (
+ "AI message should include thread/run limit details for the user"
+ )
+
+
+def test_parallel_mixed_tool_calls_with_specific_tool_limit():
+ """Test parallel calls to different tools when limiting a specific tool.
+
+ When limiting 'search' to 1 call, and model proposes 3 search + 2 calculator calls:
+ - First search call should execute
+ - Other 2 search calls should be blocked
+ - All calculator calls should execute (not limited)
+ """
+
+ @tool
+ def search(query: str) -> str:
+ """Search for information."""
+ return f"Search: {query}"
+
+ @tool
+ def calculator(expression: str) -> str:
+ """Calculate an expression."""
+ return f"Calc: {expression}"
+
+ model = FakeToolCallingModel(
+ tool_calls=[
+ [
+ ToolCall(name="search", args={"query": "q1"}, id="1"),
+ ToolCall(name="calculator", args={"expression": "1+1"}, id="2"),
+ ToolCall(name="search", args={"query": "q2"}, id="3"),
+ ToolCall(name="calculator", args={"expression": "2+2"}, id="4"),
+ ToolCall(name="search", args={"query": "q3"}, id="5"),
+ ],
+ [],
+ ]
+ )
+
+ search_limiter = ToolCallLimitMiddleware(
+ tool_name="search", thread_limit=1, exit_behavior="continue"
+ )
+ agent = create_agent(
+ model=model,
+ tools=[search, calculator],
+ middleware=[search_limiter],
+ checkpointer=InMemorySaver(),
+ )
+
+ result = agent.invoke(
+ {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
+ )
+ messages = result["messages"]
+
+ tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
+ search_success = [m for m in tool_messages if "Search:" in m.content]
+ search_blocked = [
+ m for m in tool_messages if "limit" in m.content.lower() and "search" in m.content.lower()
+ ]
+ calc_success = [m for m in tool_messages if "Calc:" in m.content]
+
+ assert len(search_success) == 1, "Should have 1 successful search call"
+ assert len(search_blocked) == 2, "Should have 2 blocked search calls"
+ assert len(calc_success) == 2, "All calculator calls should succeed (not limited)"
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_emulator.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_emulator.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_retry.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_retry.py
similarity index 99%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_retry.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_retry.py
index 88faa0deb1..5e18d1cae4 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_retry.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_retry.py
@@ -11,7 +11,7 @@ from langgraph.checkpoint.memory import InMemorySaver
from langchain.agents.factory import create_agent
from langchain.agents.middleware.tool_retry import ToolRetryMiddleware
-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel
+from tests.unit_tests.agents.model import FakeToolCallingModel
@tool
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_llm_tool_selection.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_selection.py
similarity index 100%
rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_llm_tool_selection.py
rename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_selection.py
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_before_after_agent.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_before_after_agent.py
deleted file mode 100644
index 9736c39544..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_before_after_agent.py
+++ /dev/null
@@ -1,286 +0,0 @@
-"""Unit tests for before_agent and after_agent middleware hooks."""
-
-from typing import Any
-
-import pytest
-from langchain.agents import create_agent
-from langchain.agents.middleware import (
- AgentMiddleware,
- AgentState,
- after_agent,
- after_model,
- before_model,
- before_agent,
-)
-from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
-from langchain_core.messages import AIMessage, HumanMessage
-from langchain_core.tools import tool
-from langgraph.runtime import Runtime
-
-from ..model import FakeToolCallingModel
-
-
-@tool
-def sample_tool(query: str) -> str:
- """A sample tool for testing."""
- return f"Result for: {query}"
-
-
-class TestAgentMiddlewareHooks:
- """Test before_agent and after_agent middleware hooks."""
-
- @pytest.mark.parametrize("is_async", [False, True])
- @pytest.mark.parametrize("hook_type", ["before", "after"])
- async def test_hook_execution(self, is_async: bool, hook_type: str) -> None:
- """Test that agent hooks are called in both sync and async modes."""
- execution_log: list[str] = []
-
- if is_async:
- if hook_type == "before":
-
- @before_agent
- async def log_hook(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
- execution_log.append(f"{hook_type}_agent_called")
- execution_log.append(f"message_count: {len(state['messages'])}")
- return None
- else:
-
- @after_agent
- async def log_hook(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
- execution_log.append(f"{hook_type}_agent_called")
- execution_log.append(f"message_count: {len(state['messages'])}")
- return None
- else:
- if hook_type == "before":
-
- @before_agent
- def log_hook(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
- execution_log.append(f"{hook_type}_agent_called")
- execution_log.append(f"message_count: {len(state['messages'])}")
- return None
- else:
-
- @after_agent
- def log_hook(state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
- execution_log.append(f"{hook_type}_agent_called")
- execution_log.append(f"message_count: {len(state['messages'])}")
- return None
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, tools=[], middleware=[log_hook])
-
- if is_async:
- await agent.ainvoke({"messages": [HumanMessage("Hi")]})
- else:
- agent.invoke({"messages": [HumanMessage("Hi")]})
-
- assert f"{hook_type}_agent_called" in execution_log
- assert any("message_count:" in log for log in execution_log)
-
- @pytest.mark.parametrize("is_async", [False, True])
- @pytest.mark.parametrize("hook_type", ["before", "after"])
- async def test_hook_with_class_inheritance(self, is_async: bool, hook_type: str) -> None:
- """Test agent hooks using class inheritance in both sync and async modes."""
- execution_log: list[str] = []
-
- if is_async:
-
- class CustomMiddleware(AgentMiddleware):
- async def abefore_agent(
- self, state: AgentState, runtime: Runtime
- ) -> dict[str, Any] | None:
- if hook_type == "before":
- execution_log.append("hook_called")
- return None
-
- async def aafter_agent(
- self, state: AgentState, runtime: Runtime
- ) -> dict[str, Any] | None:
- if hook_type == "after":
- execution_log.append("hook_called")
- return None
- else:
-
- class CustomMiddleware(AgentMiddleware):
- def before_agent(
- self, state: AgentState, runtime: Runtime
- ) -> dict[str, Any] | None:
- if hook_type == "before":
- execution_log.append("hook_called")
- return None
-
- def after_agent(self, state: AgentState, runtime: Runtime) -> dict[str, Any] | None:
- if hook_type == "after":
- execution_log.append("hook_called")
- return None
-
- middleware = CustomMiddleware()
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, tools=[], middleware=[middleware])
-
- if is_async:
- await agent.ainvoke({"messages": [HumanMessage("Test")]})
- else:
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert "hook_called" in execution_log
-
-
-class TestAgentHooksCombined:
- """Test before_agent and after_agent hooks working together."""
-
- @pytest.mark.parametrize("is_async", [False, True])
- async def test_execution_order(self, is_async: bool) -> None:
- """Test that before_agent executes before after_agent in both sync and async modes."""
- execution_log: list[str] = []
-
- if is_async:
-
- @before_agent
- async def log_before(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before")
-
- @after_agent
- async def log_after(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after")
- else:
-
- @before_agent
- def log_before(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before")
-
- @after_agent
- def log_after(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after")
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, tools=[], middleware=[log_before, log_after])
-
- if is_async:
- await agent.ainvoke({"messages": [HumanMessage("Test")]})
- else:
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert execution_log == ["before", "after"]
-
- def test_state_passthrough(self) -> None:
- """Test that state modifications in before_agent are visible to after_agent."""
-
- @before_agent
- def modify_in_before(state: AgentState, runtime: Runtime) -> dict[str, Any]:
- return {"messages": [HumanMessage("Added by before_agent")]}
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, tools=[], middleware=[modify_in_before])
- result = agent.invoke({"messages": [HumanMessage("Original")]})
-
- message_contents = [msg.content for msg in result["messages"]]
- assert message_contents[1] == "Added by before_agent"
-
- def test_multiple_middleware_instances(self) -> None:
- """Test multiple before_agent and after_agent middleware instances."""
- execution_log = []
-
- @before_agent
- def before_one(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before_1")
-
- @before_agent
- def before_two(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before_2")
-
- @after_agent
- def after_one(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after_1")
-
- @after_agent
- def after_two(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after_2")
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(
- model=model, tools=[], middleware=[before_one, before_two, after_one, after_two]
- )
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert execution_log == ["before_1", "before_2", "after_2", "after_1"]
-
- def test_agent_hooks_run_once_with_multiple_model_calls(self) -> None:
- """Test that before_agent and after_agent run only once per thread.
-
- This test verifies that agent-level hooks (before_agent, after_agent) execute
- exactly once per agent invocation, regardless of how many tool calling loops occur.
- This is different from model-level hooks (before_model, after_model) which run
- on every model invocation within the tool calling loop.
- """
- execution_log = []
-
- @before_agent
- def log_before_agent(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before_agent")
-
- @before_model
- def log_before_model(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("before_model")
-
- @after_agent
- def log_after_agent(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after_agent")
-
- @after_model
- def log_after_model(state: AgentState, runtime: Runtime) -> None:
- execution_log.append("after_model")
-
- # Model will call a tool twice, then respond with final answer
- # This creates 3 model invocations total, but agent hooks should still run once
- model = FakeToolCallingModel(
- tool_calls=[
- [{"name": "sample_tool", "args": {"query": "first"}, "id": "1"}],
- [{"name": "sample_tool", "args": {"query": "second"}, "id": "2"}],
- [], # Third call returns no tool calls (final answer)
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[sample_tool],
- middleware=[log_before_agent, log_before_model, log_after_model, log_after_agent],
- )
-
- agent.invoke(
- {"messages": [HumanMessage("Test")]}, config={"configurable": {"thread_id": "abc"}}
- )
-
- assert execution_log == [
- "before_agent",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "after_agent",
- ]
-
- agent.invoke(
- {"messages": [HumanMessage("Test")]}, config={"configurable": {"thread_id": "abc"}}
- )
-
- assert execution_log == [
- "before_agent",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "after_agent",
- "before_agent",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "before_model",
- "after_model",
- "after_agent",
- ]
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_decorator.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_decorator.py
deleted file mode 100644
index 29194b484d..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_decorator.py
+++ /dev/null
@@ -1,355 +0,0 @@
-"""Unit tests for the @wrap_model_call decorator."""
-
-import pytest
-from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
-from langchain_core.messages import AIMessage, HumanMessage
-
-from langchain.agents import create_agent
-from langchain.agents.middleware.types import (
- AgentMiddleware,
- AgentState,
- ModelRequest,
- wrap_model_call,
-)
-
-
-class TestOnModelCallDecorator:
- """Test the @wrap_model_call decorator for creating middleware."""
-
- def test_basic_decorator_usage(self) -> None:
- """Test basic decorator usage without parameters."""
-
- @wrap_model_call
- def passthrough_middleware(request, handler):
- return handler(request)
-
- # Should return an AgentMiddleware instance
- assert isinstance(passthrough_middleware, AgentMiddleware)
-
- # Should work in agent
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Hello")]))
- agent = create_agent(model=model, middleware=[passthrough_middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Hi")]})
- assert len(result["messages"]) == 2
- assert result["messages"][1].content == "Hello"
-
- def test_decorator_with_custom_name(self) -> None:
- """Test decorator with custom middleware name."""
-
- @wrap_model_call(name="CustomMiddleware")
- def my_middleware(request, handler):
- return handler(request)
-
- assert isinstance(my_middleware, AgentMiddleware)
- assert my_middleware.__class__.__name__ == "CustomMiddleware"
-
- def test_decorator_retry_logic(self) -> None:
- """Test decorator for implementing retry logic."""
- call_count = {"value": 0}
-
- class FailOnceThenSucceed(GenericFakeChatModel):
- def _generate(self, messages, **kwargs):
- call_count["value"] += 1
- if call_count["value"] == 1:
- raise ValueError("First call fails")
- return super()._generate(messages, **kwargs)
-
- @wrap_model_call
- def retry_once(request, handler):
- try:
- return handler(request)
- except Exception:
- # Retry once
- return handler(request)
-
- model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
- agent = create_agent(model=model, middleware=[retry_once])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert call_count["value"] == 2
- assert result["messages"][1].content == "Success"
-
- def test_decorator_response_rewriting(self) -> None:
- """Test decorator for rewriting responses."""
-
- @wrap_model_call
- def uppercase_responses(request, handler):
- result = handler(request)
- # result is ModelResponse, extract AIMessage from it
- ai_message = result.result[0]
- return AIMessage(content=ai_message.content.upper())
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="hello world")]))
- agent = create_agent(model=model, middleware=[uppercase_responses])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert result["messages"][1].content == "HELLO WORLD"
-
- def test_decorator_error_handling(self) -> None:
- """Test decorator for error recovery."""
-
- class AlwaysFailModel(GenericFakeChatModel):
- def _generate(self, messages, **kwargs):
- raise ValueError("Model error")
-
- @wrap_model_call
- def error_to_fallback(request, handler):
- try:
- return handler(request)
- except Exception:
- return AIMessage(content="Fallback response")
-
- model = AlwaysFailModel(messages=iter([]))
- agent = create_agent(model=model, middleware=[error_to_fallback])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert result["messages"][1].content == "Fallback response"
-
- def test_decorator_with_state_access(self) -> None:
- """Test decorator accessing agent state."""
- state_values = []
-
- @wrap_model_call
- def log_state(request, handler):
- state_values.append(request.state.get("messages"))
- return handler(request)
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, middleware=[log_state])
-
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- # State should contain the user message
- assert len(state_values) == 1
- assert len(state_values[0]) == 1
- assert state_values[0][0].content == "Test"
-
- def test_multiple_decorated_middleware(self) -> None:
- """Test composition of multiple decorated middleware."""
- execution_order = []
-
- @wrap_model_call
- def outer_middleware(request, handler):
- execution_order.append("outer-before")
- result = handler(request)
- execution_order.append("outer-after")
- return result
-
- @wrap_model_call
- def inner_middleware(request, handler):
- execution_order.append("inner-before")
- result = handler(request)
- execution_order.append("inner-after")
- return result
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, middleware=[outer_middleware, inner_middleware])
-
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert execution_order == [
- "outer-before",
- "inner-before",
- "inner-after",
- "outer-after",
- ]
-
- def test_decorator_with_custom_state_schema(self) -> None:
- """Test decorator with custom state schema."""
- from typing_extensions import TypedDict
-
- class CustomState(TypedDict):
- messages: list
- custom_field: str
-
- @wrap_model_call(state_schema=CustomState)
- def middleware_with_schema(request, handler):
- return handler(request)
-
- assert isinstance(middleware_with_schema, AgentMiddleware)
- # Custom state schema should be set
- assert middleware_with_schema.state_schema == CustomState
-
- def test_decorator_with_tools_parameter(self) -> None:
- """Test decorator with tools parameter."""
- from langchain_core.tools import tool
-
- @tool
- def test_tool(query: str) -> str:
- """A test tool."""
- return f"Result: {query}"
-
- @wrap_model_call(tools=[test_tool])
- def middleware_with_tools(request, handler):
- return handler(request)
-
- assert isinstance(middleware_with_tools, AgentMiddleware)
- assert len(middleware_with_tools.tools) == 1
- assert middleware_with_tools.tools[0].name == "test_tool"
-
- def test_decorator_parentheses_optional(self) -> None:
- """Test that decorator works both with and without parentheses."""
-
- # Without parentheses
- @wrap_model_call
- def middleware_no_parens(request, handler):
- return handler(request)
-
- # With parentheses
- @wrap_model_call()
- def middleware_with_parens(request, handler):
- return handler(request)
-
- assert isinstance(middleware_no_parens, AgentMiddleware)
- assert isinstance(middleware_with_parens, AgentMiddleware)
-
- def test_decorator_preserves_function_name(self) -> None:
- """Test that decorator uses function name for class name."""
-
- @wrap_model_call
- def my_custom_middleware(request, handler):
- return handler(request)
-
- assert my_custom_middleware.__class__.__name__ == "my_custom_middleware"
-
- def test_decorator_mixed_with_class_middleware(self) -> None:
- """Test decorated middleware mixed with class-based middleware."""
- execution_order = []
-
- @wrap_model_call
- def decorated_middleware(request, handler):
- execution_order.append("decorated-before")
- result = handler(request)
- execution_order.append("decorated-after")
- return result
-
- class ClassMiddleware(AgentMiddleware):
- def wrap_model_call(self, request, handler):
- execution_order.append("class-before")
- result = handler(request)
- execution_order.append("class-after")
- return result
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(
- model=model,
- middleware=[decorated_middleware, ClassMiddleware()],
- )
-
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Decorated is outer, class-based is inner
- assert execution_order == [
- "decorated-before",
- "class-before",
- "class-after",
- "decorated-after",
- ]
-
- def test_decorator_complex_retry_logic(self) -> None:
- """Test decorator with complex retry logic and backoff."""
- attempts = []
- call_count = {"value": 0}
-
- class UnreliableModel(GenericFakeChatModel):
- def _generate(self, messages, **kwargs):
- call_count["value"] += 1
- if call_count["value"] <= 2:
- raise ValueError(f"Attempt {call_count['value']} failed")
- return super()._generate(messages, **kwargs)
-
- @wrap_model_call
- def retry_with_tracking(request, handler):
- max_retries = 3
- last_exception = None
- for attempt in range(max_retries):
- attempts.append(attempt + 1)
- try:
- return handler(request)
- except Exception as e:
- last_exception = e
- # On error, continue to next attempt
- if attempt < max_retries - 1:
- continue # Retry
- else:
- raise # All retries failed
-
- model = UnreliableModel(messages=iter([AIMessage(content="Finally worked")]))
- agent = create_agent(model=model, middleware=[retry_with_tracking])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert attempts == [1, 2, 3]
- assert result["messages"][1].content == "Finally worked"
-
- async def test_decorator_with_async_agent(self) -> None:
- """Test that decorated middleware works with async agent invocation."""
- call_log = []
-
- @wrap_model_call
- async def logging_middleware(request, handler):
- call_log.append("before")
- result = await handler(request)
- call_log.append("after")
- return result
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))
- agent = create_agent(model=model, middleware=[logging_middleware])
-
- result = await agent.ainvoke({"messages": [HumanMessage("Test")]})
-
- assert call_log == ["before", "after"]
- assert result["messages"][1].content == "Async response"
-
- def test_decorator_request_modification(self) -> None:
- """Test decorator modifying request before execution."""
- modified_prompts = []
-
- @wrap_model_call
- def add_system_prompt(request, handler):
- # Modify request to add system prompt
- modified_request = ModelRequest(
- messages=request.messages,
- model=request.model,
- system_prompt="You are a helpful assistant",
- tool_choice=request.tool_choice,
- tools=request.tools,
- response_format=request.response_format,
- state={},
- runtime=None,
- )
- modified_prompts.append(modified_request.system_prompt)
- return handler(modified_request)
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
- agent = create_agent(model=model, middleware=[add_system_prompt])
-
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert modified_prompts == ["You are a helpful assistant"]
-
- def test_decorator_multi_stage_transformation(self) -> None:
- """Test decorator applying multiple transformations."""
-
- @wrap_model_call
- def multi_transform(request, handler):
- result = handler(request)
- # result is ModelResponse, extract AIMessage from it
- ai_message = result.result[0]
-
- # First transformation: uppercase
- content = ai_message.content.upper()
- # Second transformation: add prefix and suffix
- content = f"[START] {content} [END]"
- return AIMessage(content=content)
-
- model = GenericFakeChatModel(messages=iter([AIMessage(content="hello")]))
- agent = create_agent(model=model, middleware=[multi_transform])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- assert result["messages"][1].content == "[START] HELLO [END]"
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py b/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py
deleted file mode 100644
index 2908b865b0..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py
+++ /dev/null
@@ -1,2939 +0,0 @@
-import warnings
-from collections.abc import Awaitable, Callable
-from types import ModuleType
-from typing import Any, TYPE_CHECKING
-from unittest.mock import patch
-
-import sys
-import pytest
-from langchain_core.language_models import BaseChatModel
-from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.messages import (
- AIMessage,
- AnyMessage,
- HumanMessage,
- RemoveMessage,
- ToolCall,
- ToolMessage,
-)
-from typing import cast
-
-from langchain_core.outputs import ChatGeneration, ChatResult
-from langchain_core.tools import InjectedToolCallId, tool
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.constants import END
-from langgraph.graph.message import REMOVE_ALL_MESSAGES
-from langgraph.runtime import Runtime
-from langgraph.types import Command
-from pydantic import BaseModel, Field
-from syrupy.assertion import SnapshotAssertion
-from typing_extensions import Annotated
-
-from langchain.agents.middleware.human_in_the_loop import (
- Action,
- HumanInTheLoopMiddleware,
-)
-from langchain.agents.middleware.todo import (
- TodoListMiddleware,
- PlanningState,
- WRITE_TODOS_SYSTEM_PROMPT,
- write_todos,
- WRITE_TODOS_TOOL_DESCRIPTION,
-)
-from langchain.agents.middleware.model_call_limit import (
- ModelCallLimitMiddleware,
- ModelCallLimitExceededError,
-)
-from langchain.agents.middleware.model_fallback import ModelFallbackMiddleware
-from langchain.agents.middleware.summarization import SummarizationMiddleware
-from langchain.agents.middleware.types import (
- AgentMiddleware,
- AgentState,
- hook_config,
- ModelRequest,
- OmitFromInput,
- OmitFromOutput,
- PrivateStateAttr,
- ModelResponse,
- ModelCallResult,
-)
-from langchain.agents.factory import create_agent
-from langchain.agents.structured_output import ToolStrategy
-from langchain.tools import InjectedState
-
-from .messages import _AnyIdHumanMessage, _AnyIdToolMessage
-from .model import FakeToolCallingModel
-
-if TYPE_CHECKING:
- from langchain_model_profiles import ModelProfile
-
-
-def test_create_agent_diagram(
- snapshot: SnapshotAssertion,
-):
- class NoopOne(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- class NoopTwo(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- class NoopThree(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- class NoopFour(AgentMiddleware):
- def after_model(self, state, runtime):
- pass
-
- class NoopFive(AgentMiddleware):
- def after_model(self, state, runtime):
- pass
-
- class NoopSix(AgentMiddleware):
- def after_model(self, state, runtime):
- pass
-
- class NoopSeven(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- def after_model(self, state, runtime):
- pass
-
- class NoopEight(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- def after_model(self, state, runtime):
- pass
-
- class NoopNine(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- def after_model(self, state, runtime):
- pass
-
- class NoopTen(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- return handler(request)
-
- def after_model(self, state, runtime):
- pass
-
- class NoopEleven(AgentMiddleware):
- def before_model(self, state, runtime):
- pass
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- return handler(request)
-
- def after_model(self, state, runtime):
- pass
-
- agent_zero = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- )
-
- assert agent_zero.get_graph().draw_mermaid() == snapshot
-
- agent_one = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopOne()],
- )
-
- assert agent_one.get_graph().draw_mermaid() == snapshot
-
- agent_two = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopOne(), NoopTwo()],
- )
-
- assert agent_two.get_graph().draw_mermaid() == snapshot
-
- agent_three = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopOne(), NoopTwo(), NoopThree()],
- )
-
- assert agent_three.get_graph().draw_mermaid() == snapshot
-
- agent_four = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopFour()],
- )
-
- assert agent_four.get_graph().draw_mermaid() == snapshot
-
- agent_five = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopFour(), NoopFive()],
- )
-
- assert agent_five.get_graph().draw_mermaid() == snapshot
-
- agent_six = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopFour(), NoopFive(), NoopSix()],
- )
-
- assert agent_six.get_graph().draw_mermaid() == snapshot
-
- agent_seven = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopSeven()],
- )
-
- assert agent_seven.get_graph().draw_mermaid() == snapshot
-
- agent_eight = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopSeven(), NoopEight()],
- )
-
- assert agent_eight.get_graph().draw_mermaid() == snapshot
-
- agent_nine = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopSeven(), NoopEight(), NoopNine()],
- )
-
- assert agent_nine.get_graph().draw_mermaid() == snapshot
-
- agent_ten = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopTen()],
- )
-
- assert agent_ten.get_graph().draw_mermaid() == snapshot
-
- agent_eleven = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopTen(), NoopEleven()],
- )
-
- assert agent_eleven.get_graph().draw_mermaid() == snapshot
-
-
-def test_create_agent_invoke(
- snapshot: SnapshotAssertion,
- sync_checkpointer: BaseCheckpointSaver,
-):
- calls = []
-
- class NoopSeven(AgentMiddleware):
- def before_model(self, state, runtime):
- calls.append("NoopSeven.before_model")
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("NoopSeven.wrap_model_call")
- return handler(request)
-
- def after_model(self, state, runtime):
- calls.append("NoopSeven.after_model")
-
- class NoopEight(AgentMiddleware):
- def before_model(self, state, runtime):
- calls.append("NoopEight.before_model")
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("NoopEight.wrap_model_call")
- return handler(request)
-
- def after_model(self, state, runtime):
- calls.append("NoopEight.after_model")
-
- @tool
- def my_tool(input: str) -> str:
- """A great tool"""
- calls.append("my_tool")
- return input.upper()
-
- agent_one = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[
- [
- {"args": {"input": "yo"}, "id": "1", "name": "my_tool"},
- ],
- [],
- ]
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopSeven(), NoopEight()],
- checkpointer=sync_checkpointer,
- )
-
- thread1 = {"configurable": {"thread_id": "1"}}
- assert agent_one.invoke({"messages": ["hello"]}, thread1) == {
- "messages": [
- _AnyIdHumanMessage(content="hello"),
- AIMessage(
- content="You are a helpful assistant.-hello",
- additional_kwargs={},
- response_metadata={},
- id="0",
- tool_calls=[
- {
- "name": "my_tool",
- "args": {"input": "yo"},
- "id": "1",
- "type": "tool_call",
- }
- ],
- ),
- _AnyIdToolMessage(content="YO", name="my_tool", tool_call_id="1"),
- AIMessage(
- content="You are a helpful assistant.-hello-You are a helpful assistant.-hello-YO",
- additional_kwargs={},
- response_metadata={},
- id="1",
- ),
- ],
- }
- assert calls == [
- "NoopSeven.before_model",
- "NoopEight.before_model",
- "NoopSeven.wrap_model_call",
- "NoopEight.wrap_model_call",
- "NoopEight.after_model",
- "NoopSeven.after_model",
- "my_tool",
- "NoopSeven.before_model",
- "NoopEight.before_model",
- "NoopSeven.wrap_model_call",
- "NoopEight.wrap_model_call",
- "NoopEight.after_model",
- "NoopSeven.after_model",
- ]
-
-
-def test_create_agent_jump(
- snapshot: SnapshotAssertion,
- sync_checkpointer: BaseCheckpointSaver,
-):
- calls = []
-
- class NoopSeven(AgentMiddleware):
- def before_model(self, state, runtime):
- calls.append("NoopSeven.before_model")
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("NoopSeven.wrap_model_call")
- return handler(request)
-
- def after_model(self, state, runtime):
- calls.append("NoopSeven.after_model")
-
- class NoopEight(AgentMiddleware):
- @hook_config(can_jump_to=["end"])
- def before_model(self, state, runtime) -> dict[str, Any]:
- calls.append("NoopEight.before_model")
- return {"jump_to": "end"}
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("NoopEight.wrap_model_call")
- return handler(request)
-
- def after_model(self, state, runtime):
- calls.append("NoopEight.after_model")
-
- @tool
- def my_tool(input: str) -> str:
- """A great tool"""
- calls.append("my_tool")
- return input.upper()
-
- agent_one = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopSeven(), NoopEight()],
- checkpointer=sync_checkpointer,
- )
-
- if isinstance(sync_checkpointer, InMemorySaver):
- assert agent_one.get_graph().draw_mermaid() == snapshot
-
- thread1 = {"configurable": {"thread_id": "1"}}
- assert agent_one.invoke({"messages": []}, thread1) == {"messages": []}
- assert calls == ["NoopSeven.before_model", "NoopEight.before_model"]
-
-
-def test_simple_agent_graph(snapshot: SnapshotAssertion) -> None:
- @tool
- def my_tool(input_string: str) -> str:
- """A great tool."""
- return input_string
-
- agent_one = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- )
-
- assert agent_one.get_graph().draw_mermaid() == snapshot
-
-
-def test_agent_graph_with_jump_to_end_as_after_agent(snapshot: SnapshotAssertion) -> None:
- @tool
- def my_tool(input_string: str) -> str:
- """A great tool."""
- return input_string
-
- class NoopZero(AgentMiddleware):
- @hook_config(can_jump_to=["end"])
- def before_agent(self, state, runtime) -> None:
- return None
-
- class NoopOne(AgentMiddleware):
- def after_agent(self, state, runtime) -> None:
- return None
-
- class NoopTwo(AgentMiddleware):
- def after_agent(self, state, runtime) -> None:
- return None
-
- agent_one = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[NoopZero(), NoopOne(), NoopTwo()],
- )
-
- assert agent_one.get_graph().draw_mermaid() == snapshot
-
-
-# Tests for HumanInTheLoopMiddleware
-def test_human_in_the_loop_middleware_initialization() -> None:
- """Test HumanInTheLoopMiddleware initialization."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}},
- description_prefix="Custom prefix",
- )
-
- assert middleware.interrupt_on == {
- "test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}
- }
- assert middleware.description_prefix == "Custom prefix"
-
-
-def test_human_in_the_loop_middleware_no_interrupts_needed() -> None:
- """Test HumanInTheLoopMiddleware when no interrupts are needed."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- # Test with no messages
- state: dict[str, Any] = {"messages": []}
- result = middleware.after_model(state, None)
- assert result is None
-
- # Test with message but no tool calls
- state = {"messages": [HumanMessage(content="Hello"), AIMessage(content="Hi there")]}
- result = middleware.after_model(state, None)
- assert result is None
-
- # Test with tool calls that don't require interrupts
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "other_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
- result = middleware.after_model(state, None)
- assert result is None
-
-
-def test_human_in_the_loop_middleware_single_tool_accept() -> None:
- """Test HumanInTheLoopMiddleware with single tool accept response."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_accept(requests):
- return {"decisions": [{"type": "approve"}]}
-
- with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_accept):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert result["messages"][0] == ai_message
- assert result["messages"][0].tool_calls == ai_message.tool_calls
-
- state["messages"].append(
- ToolMessage(content="Tool message", name="test_tool", tool_call_id="1")
- )
- state["messages"].append(AIMessage(content="test_tool called with result: Tool message"))
-
- result = middleware.after_model(state, None)
- # No interrupts needed
- assert result is None
-
-
-def test_human_in_the_loop_middleware_single_tool_edit() -> None:
- """Test HumanInTheLoopMiddleware with single tool edit response."""
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_edit(requests):
- return {
- "decisions": [
- {
- "type": "edit",
- "edited_action": Action(
- name="test_tool",
- args={"input": "edited"},
- ),
- }
- ]
- }
-
- with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_edit):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert result["messages"][0].tool_calls[0]["args"] == {"input": "edited"}
- assert result["messages"][0].tool_calls[0]["id"] == "1" # ID should be preserved
-
-
-def test_human_in_the_loop_middleware_single_tool_response() -> None:
- """Test HumanInTheLoopMiddleware with single tool response with custom message."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_response(requests):
- return {"decisions": [{"type": "reject", "message": "Custom response message"}]}
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_response
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 2
- assert isinstance(result["messages"][0], AIMessage)
- assert isinstance(result["messages"][1], ToolMessage)
- assert result["messages"][1].content == "Custom response message"
- assert result["messages"][1].name == "test_tool"
- assert result["messages"][1].tool_call_id == "1"
-
-
-def test_human_in_the_loop_middleware_multiple_tools_mixed_responses() -> None:
- """Test HumanInTheLoopMiddleware with multiple tools and mixed response types."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={
- "get_forecast": {"allowed_decisions": ["approve", "edit", "reject"]},
- "get_temperature": {"allowed_decisions": ["approve", "edit", "reject"]},
- }
- )
-
- ai_message = AIMessage(
- content="I'll help you with weather",
- tool_calls=[
- {"name": "get_forecast", "args": {"location": "San Francisco"}, "id": "1"},
- {"name": "get_temperature", "args": {"location": "San Francisco"}, "id": "2"},
- ],
- )
- state = {"messages": [HumanMessage(content="What's the weather?"), ai_message]}
-
- def mock_mixed_responses(requests):
- return {
- "decisions": [
- {"type": "approve"},
- {"type": "reject", "message": "User rejected this tool call"},
- ]
- }
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_mixed_responses
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert (
- len(result["messages"]) == 2
- ) # AI message with accepted tool call + tool message for rejected
-
- # First message should be the AI message with both tool calls
- updated_ai_message = result["messages"][0]
- assert len(updated_ai_message.tool_calls) == 2 # Both tool calls remain
- assert updated_ai_message.tool_calls[0]["name"] == "get_forecast" # Accepted
- assert updated_ai_message.tool_calls[1]["name"] == "get_temperature" # Got response
-
- # Second message should be the tool message for the rejected tool call
- tool_message = result["messages"][1]
- assert isinstance(tool_message, ToolMessage)
- assert tool_message.content == "User rejected this tool call"
- assert tool_message.name == "get_temperature"
-
-
-def test_human_in_the_loop_middleware_multiple_tools_edit_responses() -> None:
- """Test HumanInTheLoopMiddleware with multiple tools and edit responses."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={
- "get_forecast": {"allowed_decisions": ["approve", "edit", "reject"]},
- "get_temperature": {"allowed_decisions": ["approve", "edit", "reject"]},
- }
- )
-
- ai_message = AIMessage(
- content="I'll help you with weather",
- tool_calls=[
- {"name": "get_forecast", "args": {"location": "San Francisco"}, "id": "1"},
- {"name": "get_temperature", "args": {"location": "San Francisco"}, "id": "2"},
- ],
- )
- state = {"messages": [HumanMessage(content="What's the weather?"), ai_message]}
-
- def mock_edit_responses(requests):
- return {
- "decisions": [
- {
- "type": "edit",
- "edited_action": Action(
- name="get_forecast",
- args={"location": "New York"},
- ),
- },
- {
- "type": "edit",
- "edited_action": Action(
- name="get_temperature",
- args={"location": "New York"},
- ),
- },
- ]
- }
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_edit_responses
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
-
- updated_ai_message = result["messages"][0]
- assert updated_ai_message.tool_calls[0]["args"] == {"location": "New York"}
- assert updated_ai_message.tool_calls[0]["id"] == "1" # ID preserved
- assert updated_ai_message.tool_calls[1]["args"] == {"location": "New York"}
- assert updated_ai_message.tool_calls[1]["id"] == "2" # ID preserved
-
-
-def test_human_in_the_loop_middleware_edit_with_modified_args() -> None:
- """Test HumanInTheLoopMiddleware with edit action that includes modified args."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_edit_with_args(requests):
- return {
- "decisions": [
- {
- "type": "edit",
- "edited_action": Action(
- name="test_tool",
- args={"input": "modified"},
- ),
- }
- ]
- }
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- side_effect=mock_edit_with_args,
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
-
- # Should have modified args
- updated_ai_message = result["messages"][0]
- assert updated_ai_message.tool_calls[0]["args"] == {"input": "modified"}
- assert updated_ai_message.tool_calls[0]["id"] == "1" # ID preserved
-
-
-def test_human_in_the_loop_middleware_unknown_response_type() -> None:
- """Test HumanInTheLoopMiddleware with unknown response type."""
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_unknown(requests):
- return {"decisions": [{"type": "unknown"}]}
-
- with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_unknown):
- with pytest.raises(
- ValueError,
- match=r"Unexpected human decision: {'type': 'unknown'}. Decision type 'unknown' is not allowed for tool 'test_tool'. Expected one of \['approve', 'edit', 'reject'\] based on the tool's configuration.",
- ):
- middleware.after_model(state, None)
-
-
-def test_human_in_the_loop_middleware_disallowed_action() -> None:
- """Test HumanInTheLoopMiddleware with action not allowed by tool config."""
-
- # edit is not allowed by tool config
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_disallowed_action(requests):
- return {
- "decisions": [
- {
- "type": "edit",
- "edited_action": Action(
- name="test_tool",
- args={"input": "modified"},
- ),
- }
- ]
- }
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- side_effect=mock_disallowed_action,
- ):
- with pytest.raises(
- ValueError,
- match=r"Unexpected human decision: {'type': 'edit', 'edited_action': {'name': 'test_tool', 'args': {'input': 'modified'}}}. Decision type 'edit' is not allowed for tool 'test_tool'. Expected one of \['approve', 'reject'\] based on the tool's configuration.",
- ):
- middleware.after_model(state, None)
-
-
-def test_human_in_the_loop_middleware_mixed_auto_approved_and_interrupt() -> None:
- """Test HumanInTheLoopMiddleware with mix of auto-approved and interrupt tools."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"interrupt_tool": {"allowed_decisions": ["approve", "edit", "reject"]}}
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[
- {"name": "auto_tool", "args": {"input": "auto"}, "id": "1"},
- {"name": "interrupt_tool", "args": {"input": "interrupt"}, "id": "2"},
- ],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- def mock_accept(requests):
- return {"decisions": [{"type": "approve"}]}
-
- with patch("langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_accept):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
-
- updated_ai_message = result["messages"][0]
- # Should have both tools: auto-approved first, then interrupt tool
- assert len(updated_ai_message.tool_calls) == 2
- assert updated_ai_message.tool_calls[0]["name"] == "auto_tool"
- assert updated_ai_message.tool_calls[1]["name"] == "interrupt_tool"
-
-
-def test_human_in_the_loop_middleware_interrupt_request_structure() -> None:
- """Test that interrupt requests are structured correctly."""
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={"test_tool": {"allowed_decisions": ["approve", "edit", "reject"]}},
- description_prefix="Custom prefix",
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test", "location": "SF"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- captured_request = None
-
- def mock_capture_requests(request):
- nonlocal captured_request
- captured_request = request
- return {"decisions": [{"type": "approve"}]}
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_capture_requests
- ):
- middleware.after_model(state, None)
-
- assert captured_request is not None
- assert "action_requests" in captured_request
- assert "review_configs" in captured_request
-
- assert len(captured_request["action_requests"]) == 1
- action_request = captured_request["action_requests"][0]
- assert action_request["name"] == "test_tool"
- assert action_request["args"] == {"input": "test", "location": "SF"}
- assert "Custom prefix" in action_request["description"]
- assert "Tool: test_tool" in action_request["description"]
- assert "Args: {'input': 'test', 'location': 'SF'}" in action_request["description"]
-
- assert len(captured_request["review_configs"]) == 1
- review_config = captured_request["review_configs"][0]
- assert review_config["action_name"] == "test_tool"
- assert review_config["allowed_decisions"] == ["approve", "edit", "reject"]
-
-
-def test_human_in_the_loop_middleware_boolean_configs() -> None:
- """Test HITL middleware with boolean tool configs."""
- middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": True})
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- # Test accept
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- return_value={"decisions": [{"type": "approve"}]},
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert result["messages"][0].tool_calls == ai_message.tool_calls
-
- # Test edit
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- return_value={
- "decisions": [
- {
- "type": "edit",
- "edited_action": Action(
- name="test_tool",
- args={"input": "edited"},
- ),
- }
- ]
- },
- ):
- result = middleware.after_model(state, None)
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert result["messages"][0].tool_calls[0]["args"] == {"input": "edited"}
-
- middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": False})
-
- result = middleware.after_model(state, None)
- # No interruption should occur
- assert result is None
-
-
-def test_human_in_the_loop_middleware_sequence_mismatch() -> None:
- """Test that sequence mismatch in resume raises an error."""
- middleware = HumanInTheLoopMiddleware(interrupt_on={"test_tool": True})
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[{"name": "test_tool", "args": {"input": "test"}, "id": "1"}],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- # Test with too few responses
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- return_value={"decisions": []}, # No responses for 1 tool call
- ):
- with pytest.raises(
- ValueError,
- match=r"Number of human decisions \(0\) does not match number of hanging tool calls \(1\)\.",
- ):
- middleware.after_model(state, None)
-
- # Test with too many responses
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt",
- return_value={
- "decisions": [
- {"type": "approve"},
- {"type": "approve"},
- ]
- }, # 2 responses for 1 tool call
- ):
- with pytest.raises(
- ValueError,
- match=r"Number of human decisions \(2\) does not match number of hanging tool calls \(1\)\.",
- ):
- middleware.after_model(state, None)
-
-
-def test_human_in_the_loop_middleware_description_as_callable() -> None:
- """Test that description field accepts both string and callable."""
-
- def custom_description(tool_call: ToolCall, state: AgentState, runtime: Runtime) -> str:
- """Generate a custom description."""
- return f"Custom: {tool_call['name']} with args {tool_call['args']}"
-
- middleware = HumanInTheLoopMiddleware(
- interrupt_on={
- "tool_with_callable": {
- "allowed_decisions": ["approve"],
- "description": custom_description,
- },
- "tool_with_string": {
- "allowed_decisions": ["approve"],
- "description": "Static description",
- },
- }
- )
-
- ai_message = AIMessage(
- content="I'll help you",
- tool_calls=[
- {"name": "tool_with_callable", "args": {"x": 1}, "id": "1"},
- {"name": "tool_with_string", "args": {"y": 2}, "id": "2"},
- ],
- )
- state = {"messages": [HumanMessage(content="Hello"), ai_message]}
-
- captured_request = None
-
- def mock_capture_requests(request):
- nonlocal captured_request
- captured_request = request
- return {"decisions": [{"type": "approve"}, {"type": "approve"}]}
-
- with patch(
- "langchain.agents.middleware.human_in_the_loop.interrupt", side_effect=mock_capture_requests
- ):
- middleware.after_model(state, None)
-
- assert captured_request is not None
- assert "action_requests" in captured_request
- assert len(captured_request["action_requests"]) == 2
-
- # Check callable description
- assert (
- captured_request["action_requests"][0]["description"]
- == "Custom: tool_with_callable with args {'x': 1}"
- )
-
- # Check string description
- assert captured_request["action_requests"][1]["description"] == "Static description"
-
-
-# Tests for SummarizationMiddleware
-def test_summarization_middleware_initialization() -> None:
- """Test SummarizationMiddleware initialization."""
- model = FakeToolCallingModel()
- middleware = SummarizationMiddleware(
- model=model,
- trigger=("tokens", 1000),
- keep=("messages", 10),
- summary_prompt="Custom prompt: {messages}",
- )
-
- assert middleware.model == model
- assert middleware.trigger == ("tokens", 1000)
- assert middleware.keep == ("messages", 10)
- assert middleware.summary_prompt == "Custom prompt: {messages}"
- assert middleware.trim_tokens_to_summarize == 4000
-
- with pytest.raises(ValueError):
- SummarizationMiddleware(model=model, keep=("fraction", 0.5)) # no model profile
-
- # Test with string model
- with patch(
- "langchain.agents.middleware.summarization.init_chat_model",
- return_value=FakeToolCallingModel(),
- ):
- middleware = SummarizationMiddleware(model="fake-model")
- assert isinstance(middleware.model, FakeToolCallingModel)
-
-
-def test_summarization_middleware_no_summarization_cases() -> None:
- """Test SummarizationMiddleware when summarization is not needed or disabled."""
- model = FakeToolCallingModel()
- middleware = SummarizationMiddleware(model=model, trigger=("tokens", 1000))
-
- # Test when summarization is disabled
- middleware_disabled = SummarizationMiddleware(model=model, trigger=None)
- state = {"messages": [HumanMessage(content="Hello"), AIMessage(content="Hi")]}
- result = middleware_disabled.before_model(state, None)
- assert result is None
-
- # Test when token count is below threshold
- def mock_token_counter(messages):
- return 500 # Below threshold
-
- middleware.token_counter = mock_token_counter
- result = middleware.before_model(state, None)
- assert result is None
-
-
-def test_summarization_middleware_helper_methods() -> None:
- """Test SummarizationMiddleware helper methods."""
- model = FakeToolCallingModel()
- middleware = SummarizationMiddleware(model=model, trigger=("tokens", 1000))
-
- # Test message ID assignment
- messages = [HumanMessage(content="Hello"), AIMessage(content="Hi")]
- middleware._ensure_message_ids(messages)
- for msg in messages:
- assert msg.id is not None
-
- # Test message partitioning
- messages = [
- HumanMessage(content="1"),
- HumanMessage(content="2"),
- HumanMessage(content="3"),
- HumanMessage(content="4"),
- HumanMessage(content="5"),
- ]
- to_summarize, preserved = middleware._partition_messages(messages, 2)
- assert len(to_summarize) == 2
- assert len(preserved) == 3
- assert to_summarize == messages[:2]
- assert preserved == messages[2:]
-
- # Test summary message building
- summary = "This is a test summary"
- new_messages = middleware._build_new_messages(summary)
- assert len(new_messages) == 1
- assert isinstance(new_messages[0], HumanMessage)
- assert "Here is a summary of the conversation to date:" in new_messages[0].content
- assert summary in new_messages[0].content
-
- # Test tool call detection
- ai_message_no_tools = AIMessage(content="Hello")
- assert not middleware._has_tool_calls(ai_message_no_tools)
-
- ai_message_with_tools = AIMessage(
- content="Hello", tool_calls=[{"name": "test", "args": {}, "id": "1"}]
- )
- assert middleware._has_tool_calls(ai_message_with_tools)
-
- human_message = HumanMessage(content="Hello")
- assert not middleware._has_tool_calls(human_message)
-
-
-def test_summarization_middleware_tool_call_safety() -> None:
- """Test SummarizationMiddleware tool call safety logic."""
- model = FakeToolCallingModel()
- middleware = SummarizationMiddleware(
- model=model, trigger=("tokens", 1000), keep=("messages", 3)
- )
-
- # Test safe cutoff point detection with tool calls
- messages = [
- HumanMessage(content="1"),
- AIMessage(content="2", tool_calls=[{"name": "test", "args": {}, "id": "1"}]),
- ToolMessage(content="3", tool_call_id="1"),
- HumanMessage(content="4"),
- ]
-
- # Safe cutoff (doesn't separate AI/Tool pair)
- is_safe = middleware._is_safe_cutoff_point(messages, 0)
- assert is_safe is True
-
- # Unsafe cutoff (separates AI/Tool pair)
- is_safe = middleware._is_safe_cutoff_point(messages, 2)
- assert is_safe is False
-
- # Test tool call ID extraction
- ids = middleware._extract_tool_call_ids(messages[1])
- assert ids == {"1"}
-
-
-def test_summarization_middleware_summary_creation() -> None:
- """Test SummarizationMiddleware summary creation."""
-
- class MockModel(BaseChatModel):
- def invoke(self, prompt):
- return AIMessage(content="Generated summary")
-
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- middleware = SummarizationMiddleware(model=MockModel(), trigger=("tokens", 1000))
-
- # Test normal summary creation
- messages = [HumanMessage(content="Hello"), AIMessage(content="Hi")]
- summary = middleware._create_summary(messages)
- assert summary == "Generated summary"
-
- # Test empty messages
- summary = middleware._create_summary([])
- assert summary == "No previous conversation history."
-
- # Test error handling
- class ErrorModel(BaseChatModel):
- def invoke(self, prompt):
- raise Exception("Model error")
-
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- middleware_error = SummarizationMiddleware(model=ErrorModel(), trigger=("tokens", 1000))
- summary = middleware_error._create_summary(messages)
- assert "Error generating summary: Model error" in summary
-
- # Test we raise warning if max_tokens_before_summary or messages_to_keep is specified
- with pytest.warns(DeprecationWarning, match="max_tokens_before_summary is deprecated"):
- SummarizationMiddleware(model=MockModel(), max_tokens_before_summary=500)
- with pytest.warns(DeprecationWarning, match="messages_to_keep is deprecated"):
- SummarizationMiddleware(model=MockModel(), messages_to_keep=5)
-
-
-def test_summarization_middleware_trim_limit_none_keeps_all_messages() -> None:
- """Verify disabling trim limit preserves full message sequence."""
-
- class MockModel(BaseChatModel):
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- messages = [HumanMessage(content=str(i)) for i in range(10)]
- middleware = SummarizationMiddleware(
- model=MockModel(),
- trim_tokens_to_summarize=None,
- )
- middleware.token_counter = lambda msgs: len(msgs)
-
- trimmed = middleware._trim_messages_for_summary(messages)
- assert trimmed is messages
-
-
-def test_summarization_middleware_profile_inference_triggers_summary() -> None:
- """Ensure automatic profile inference triggers summarization when limits are exceeded."""
-
- class ProfileModel(BaseChatModel):
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self) -> str:
- return "mock"
-
- @property
- def profile(self) -> "ModelProfile":
- return {"max_input_tokens": 1000}
-
- token_counter = lambda messages: len(messages) * 200
-
- middleware = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.81),
- keep=("fraction", 0.5),
- token_counter=token_counter,
- )
-
- state = {
- "messages": [
- HumanMessage(content="Message 1"),
- AIMessage(content="Message 2"),
- HumanMessage(content="Message 3"),
- AIMessage(content="Message 4"),
- ]
- }
-
- # Test we don't engage summarization
- # total_tokens = 4 * 200 = 800
- # max_input_tokens = 1000
- # 0.81 * 1000 == 810 > 800 -> summarization not triggered
- result = middleware.before_model(state, None)
- assert result is None
-
- # Engage summarization
- # 0.80 * 1000 == 800 <= 800
- middleware = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.80),
- keep=("fraction", 0.5),
- token_counter=token_counter,
- )
- result = middleware.before_model(state, None)
- assert result is not None
- assert isinstance(result["messages"][0], RemoveMessage)
- summary_message = result["messages"][1]
- assert isinstance(summary_message, HumanMessage)
- assert summary_message.text.startswith("Here is a summary of the conversation")
- assert len(result["messages"][2:]) == 2 # Preserved messages
- assert [message.content for message in result["messages"][2:]] == [
- "Message 3",
- "Message 4",
- ]
-
- # With keep=("fraction", 0.6) the target token allowance becomes 600,
- # so the cutoff shifts to keep the last three messages instead of two.
- middleware = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.80),
- keep=("fraction", 0.6),
- token_counter=token_counter,
- )
- result = middleware.before_model(state, None)
- assert result is not None
- assert [message.content for message in result["messages"][2:]] == [
- "Message 2",
- "Message 3",
- "Message 4",
- ]
-
- # Once keep=("fraction", 0.8) the inferred limit equals the full
- # context (target tokens = 800), so token-based retention keeps everything
- # and summarization is skipped entirely.
- middleware = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.80),
- keep=("fraction", 0.8),
- token_counter=token_counter,
- )
- assert middleware.before_model(state, None) is None
-
- # Test with tokens_to_keep as absolute int value
- middleware_int = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.80),
- keep=("tokens", 400), # Keep exactly 400 tokens (2 messages)
- token_counter=token_counter,
- )
- result = middleware_int.before_model(state, None)
- assert result is not None
- assert [message.content for message in result["messages"][2:]] == [
- "Message 3",
- "Message 4",
- ]
-
- # Test with tokens_to_keep as larger int value
- middleware_int_large = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.80),
- keep=("tokens", 600), # Keep 600 tokens (3 messages)
- token_counter=token_counter,
- )
- result = middleware_int_large.before_model(state, None)
- assert result is not None
- assert [message.content for message in result["messages"][2:]] == [
- "Message 2",
- "Message 3",
- "Message 4",
- ]
-
-
-def test_summarization_middleware_token_retention_pct_respects_tool_pairs() -> None:
- """Ensure token retention keeps pairs together even if exceeding target tokens."""
-
- class ProfileModel(BaseChatModel):
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self) -> str:
- return "mock"
-
- @property
- def profile(self) -> "ModelProfile":
- return {"max_input_tokens": 1000}
-
- def token_counter(messages):
- return sum(len(getattr(message, "content", "")) for message in messages)
-
- middleware = SummarizationMiddleware(
- model=ProfileModel(),
- trigger=("fraction", 0.1),
- keep=("fraction", 0.5),
- )
- middleware.token_counter = token_counter
-
- messages: list[AnyMessage] = [
- HumanMessage(content="H" * 300),
- AIMessage(
- content="A" * 200,
- tool_calls=[{"name": "test", "args": {}, "id": "call-1"}],
- ),
- ToolMessage(content="T" * 50, tool_call_id="call-1"),
- HumanMessage(content="H" * 180),
- HumanMessage(content="H" * 160),
- ]
-
- state = {"messages": messages}
- result = middleware.before_model(state, None)
- assert result is not None
-
- preserved_messages = result["messages"][2:]
- assert preserved_messages == messages[1:]
-
- target_token_count = int(1000 * 0.5)
- preserved_tokens = middleware.token_counter(preserved_messages)
-
- # Tool pair retention can exceed the target token count but should keep the pair intact.
- assert preserved_tokens > target_token_count
-
-
-def test_summarization_middleware_missing_profile() -> None:
- """Ensure automatic profile inference falls back when profiles are unavailable."""
-
- class ImportErrorProfileModel(BaseChatModel):
- def _generate(self, messages, **kwargs):
- raise NotImplementedError
-
- @property
- def _llm_type(self) -> str:
- return "mock"
-
- @property
- def profile(self):
- raise ImportError("Profile not available")
-
- with pytest.raises(
- ValueError,
- match="Model profile information is required to use fractional token limits",
- ):
- _ = SummarizationMiddleware(
- model=ImportErrorProfileModel, trigger=("fraction", 0.5), keep=("messages", 1)
- )
-
-
-def test_summarization_middleware_full_workflow() -> None:
- """Test SummarizationMiddleware complete summarization workflow."""
-
- class MockModel(BaseChatModel):
- def invoke(self, prompt):
- return AIMessage(content="Generated summary")
-
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- with pytest.warns(DeprecationWarning):
- # keep test for functionality
- middleware = SummarizationMiddleware(
- model=MockModel(), max_tokens_before_summary=1000, messages_to_keep=2
- )
-
- # Mock high token count to trigger summarization
- def mock_token_counter(messages):
- return 1500 # Above threshold
-
- middleware.token_counter = mock_token_counter
-
- messages = [
- HumanMessage(content="1"),
- HumanMessage(content="2"),
- HumanMessage(content="3"),
- HumanMessage(content="4"),
- HumanMessage(content="5"),
- ]
-
- state = {"messages": messages}
- result = middleware.before_model(state, None)
-
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) > 0
-
- # Should have RemoveMessage for cleanup
- assert isinstance(result["messages"][0], RemoveMessage)
- assert result["messages"][0].id == REMOVE_ALL_MESSAGES
-
- # Should have summary message
- summary_message = None
- for msg in result["messages"]:
- if isinstance(msg, HumanMessage) and "summary of the conversation" in msg.content:
- summary_message = msg
- break
-
- assert summary_message is not None
- assert "Generated summary" in summary_message.content
-
-
-async def test_summarization_middleware_full_workflow_async() -> None:
- """Test SummarizationMiddleware complete summarization workflow."""
-
- class MockModel(BaseChatModel):
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Blep"))])
-
- async def _agenerate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Blip"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- middleware = SummarizationMiddleware(
- model=MockModel(), trigger=("tokens", 1000), keep=("messages", 2)
- )
-
- # Mock high token count to trigger summarization
- def mock_token_counter(messages):
- return 1500 # Above threshold
-
- middleware.token_counter = mock_token_counter
-
- messages = [
- HumanMessage(content="1"),
- HumanMessage(content="2"),
- HumanMessage(content="3"),
- HumanMessage(content="4"),
- HumanMessage(content="5"),
- ]
-
- state = {"messages": messages}
- result = await middleware.abefore_model(state, None)
-
- assert result is not None
- assert "messages" in result
- assert len(result["messages"]) > 0
-
- expected_types = ["remove", "human", "human", "human"]
- actual_types = [message.type for message in result["messages"]]
- assert actual_types == expected_types
- assert [message.content for message in result["messages"][2:]] == ["4", "5"]
-
- summary_message = result["messages"][1]
- assert "Blip" in summary_message.text
-
-
-def test_summarization_middleware_keep_messages() -> None:
- """Test SummarizationMiddleware with keep parameter specifying messages."""
-
- class MockModel(BaseChatModel):
- def invoke(self, prompt):
- return AIMessage(content="Generated summary")
-
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="Summary"))])
-
- @property
- def _llm_type(self):
- return "mock"
-
- # Test that summarization is triggered when message count reaches threshold
- middleware = SummarizationMiddleware(
- model=MockModel(), trigger=("messages", 5), keep=("messages", 2)
- )
-
- # Below threshold - no summarization
- messages_below = [
- HumanMessage(content="1"),
- HumanMessage(content="2"),
- HumanMessage(content="3"),
- HumanMessage(content="4"),
- ]
- state_below = {"messages": messages_below}
- result = middleware.before_model(state_below, None)
- assert result is None
-
- # At threshold - should trigger summarization
- messages_at_threshold = [
- HumanMessage(content="1"),
- HumanMessage(content="2"),
- HumanMessage(content="3"),
- HumanMessage(content="4"),
- HumanMessage(content="5"),
- ]
- state_at = {"messages": messages_at_threshold}
- result = middleware.before_model(state_at, None)
- assert result is not None
- assert "messages" in result
- expected_types = ["remove", "human", "human", "human"]
- actual_types = [message.type for message in result["messages"]]
- assert actual_types == expected_types
- assert [message.content for message in result["messages"][2:]] == ["4", "5"]
-
- # Above threshold - should also trigger summarization
- messages_above = messages_at_threshold + [HumanMessage(content="6")]
- state_above = {"messages": messages_above}
- result = middleware.before_model(state_above, None)
- assert result is not None
- assert "messages" in result
- expected_types = ["remove", "human", "human", "human"]
- actual_types = [message.type for message in result["messages"]]
- assert actual_types == expected_types
- assert [message.content for message in result["messages"][2:]] == ["5", "6"]
-
- # Test with both parameters disabled
- middleware_disabled = SummarizationMiddleware(model=MockModel(), trigger=None)
- result = middleware_disabled.before_model(state_above, None)
- assert result is None
-
-
-def test_on_model_call() -> None:
- class ModifyMiddleware(AgentMiddleware):
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- request.messages.append(HumanMessage("remember to be nice!"))
- return handler(request)
-
- agent = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[ModifyMiddleware()],
- )
-
- result = agent.invoke({"messages": [HumanMessage("Hello")]})
- assert result["messages"][0].content == "Hello"
- assert result["messages"][1].content == "remember to be nice!"
- assert (
- result["messages"][2].content == "You are a helpful assistant.-Hello-remember to be nice!"
- )
-
-
-def test_tools_to_model_edge_with_structured_and_regular_tool_calls():
- """Test that when there are both structured and regular tool calls, we execute regular and jump to END."""
-
- class WeatherResponse(BaseModel):
- """Weather response."""
-
- temperature: float = Field(description="Temperature in fahrenheit")
- condition: str = Field(description="Weather condition")
-
- @tool
- def regular_tool(query: str) -> str:
- """A regular tool that returns a string."""
- return f"Regular tool result for: {query}"
-
- # Create a fake model that returns both structured and regular tool calls
- class FakeModelWithBothToolCalls(FakeToolCallingModel):
- def __init__(self):
- super().__init__()
- self.tool_calls = [
- [
- ToolCall(
- name="WeatherResponse",
- args={"temperature": 72.0, "condition": "sunny"},
- id="structured_call_1",
- ),
- ToolCall(
- name="regular_tool", args={"query": "test query"}, id="regular_call_1"
- ),
- ]
- ]
-
- # Create agent with both structured output and regular tools
- agent = create_agent(
- model=FakeModelWithBothToolCalls(),
- tools=[regular_tool],
- response_format=ToolStrategy(schema=WeatherResponse),
- )
-
- # Invoke the agent (already compiled)
- result = agent.invoke(
- {"messages": [HumanMessage("What's the weather and help me with a query?")]}
- )
-
- # Verify that we have the expected messages:
- # 1. Human message
- # 2. AI message with both tool calls
- # 3. Tool message from structured tool call
- # 4. Tool message from regular tool call
-
- messages = result["messages"]
- assert len(messages) >= 4
-
- # Check that we have the AI message with both tool calls
- ai_message = messages[1]
- assert isinstance(ai_message, AIMessage)
- assert len(ai_message.tool_calls) == 2
-
- # Check that we have a tool message from the regular tool
- tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
- assert len(tool_messages) >= 1
-
- # The regular tool should have been executed
- regular_tool_message = next((m for m in tool_messages if m.name == "regular_tool"), None)
- assert regular_tool_message is not None
- assert "Regular tool result for: test query" in regular_tool_message.content
-
- # Verify that the structured response is available in the result
- assert "structured_response" in result
- assert result["structured_response"] is not None
- assert hasattr(result["structured_response"], "temperature")
- assert result["structured_response"].temperature == 72.0
- assert result["structured_response"].condition == "sunny"
-
-
-def test_public_private_state_for_custom_middleware() -> None:
- """Test public and private state for custom middleware."""
-
- class CustomState(AgentState):
- omit_input: Annotated[str, OmitFromInput]
- omit_output: Annotated[str, OmitFromOutput]
- private_state: Annotated[str, PrivateStateAttr]
-
- class CustomMiddleware(AgentMiddleware[CustomState]):
- state_schema: type[CustomState] = CustomState
-
- def before_model(self, state: CustomState) -> dict[str, Any]:
- assert "omit_input" not in state
- assert "omit_output" in state
- assert "private_state" not in state
- return {"omit_input": "test", "omit_output": "test", "private_state": "test"}
-
- agent = create_agent(model=FakeToolCallingModel(), middleware=[CustomMiddleware()])
- result = agent.invoke(
- {
- "messages": [HumanMessage("Hello")],
- "omit_input": "test in",
- "private_state": "test in",
- "omit_output": "test in",
- }
- )
- assert "omit_input" in result
- assert "omit_output" not in result
- assert "private_state" not in result
-
-
-def test_runtime_injected_into_middleware() -> None:
- """Test that the runtime is injected into the middleware."""
-
- class CustomMiddleware(AgentMiddleware):
- def before_model(self, state: AgentState, runtime: Runtime) -> None:
- assert runtime is not None
- return None
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- assert request.runtime is not None
- return handler(request)
-
- def after_model(self, state: AgentState, runtime: Runtime) -> None:
- assert runtime is not None
- return None
-
- middleware = CustomMiddleware()
-
- agent = create_agent(model=FakeToolCallingModel(), middleware=[CustomMiddleware()])
- agent.invoke({"messages": [HumanMessage("Hello")]})
-
-
-# test setup defined at this scope bc of pydantic issues inferring the namespace of
-# custom state w/in a function
-
-
-class CustomState(AgentState):
- custom_state: str
-
-
-@tool(description="Test the state")
-def test_state_tool(
- state: Annotated[CustomState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId]
-) -> str:
- """Test tool that accesses injected state."""
- assert "custom_state" in state
- return "success"
-
-
-class CustomMiddleware(AgentMiddleware):
- state_schema = CustomState
-
-
-agent = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[
- [{"args": {}, "id": "test_call_1", "name": "test_state_tool"}],
- [],
- ]
- ),
- tools=[test_state_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[CustomMiddleware()],
-)
-
-
- sys.version_info >= (3, 14), reason="pydantic 2.12 namespace management not working w/ 3.14"
-)
-def test_injected_state_in_middleware_agent() -> None:
- """Test that custom state is properly injected into tools when using middleware."""
-
- result = agent.invoke(
- {"custom_state": "I love pizza", "messages": [HumanMessage("Call the test state tool")]}
- )
-
- messages = result["messages"]
- assert len(messages) == 4 # Human message, AI message with tool call, tool message, AI message
-
- # Find the tool message
- tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
- assert len(tool_messages) == 1
-
- tool_message = tool_messages[0]
- assert tool_message.name == "test_state_tool"
- assert "success" in tool_message.content
- assert tool_message.tool_call_id == "test_call_1"
-
-
-def test_jump_to_is_ephemeral() -> None:
- class MyMiddleware(AgentMiddleware):
- def before_model(self, state: AgentState) -> dict[str, Any]:
- assert "jump_to" not in state
- return {"jump_to": "model"}
-
- def after_model(self, state: AgentState) -> dict[str, Any]:
- assert "jump_to" not in state
- return {"jump_to": "model"}
-
- agent = create_agent(model=FakeToolCallingModel(), middleware=[MyMiddleware()])
- result = agent.invoke({"messages": [HumanMessage("Hello")]})
- assert "jump_to" not in result
-
-
-# Tests for TodoListMiddleware
-def test_todo_middleware_initialization() -> None:
- """Test that TodoListMiddleware initializes correctly."""
- middleware = TodoListMiddleware()
- assert middleware.state_schema == PlanningState
- assert len(middleware.tools) == 1
- assert middleware.tools[0].name == "write_todos"
-
-
- "original_prompt,expected_prompt_prefix",
- [
- ("Original prompt", "Original prompt\n\n## `write_todos`"),
- (None, "## `write_todos`"),
- ],
-)
-def test_todo_middleware_on_model_call(original_prompt, expected_prompt_prefix) -> None:
- """Test that wrap_model_call handles system prompts correctly."""
- middleware = TodoListMiddleware()
- model = FakeToolCallingModel()
-
- state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
-
- request = ModelRequest(
- model=model,
- system_prompt=original_prompt,
- messages=[HumanMessage(content="Hello")],
- tool_choice=None,
- tools=[],
- response_format=None,
- state=state,
- runtime=cast(Runtime, object()),
- model_settings={},
- )
-
- def mock_handler(req: ModelRequest) -> AIMessage:
- return AIMessage(content="mock response")
-
- # Call wrap_model_call to trigger the middleware logic
- middleware.wrap_model_call(request, mock_handler)
- # Check that the request was modified in place
- assert request.system_prompt.startswith(expected_prompt_prefix)
-
-
- "todos,expected_message",
- [
- ([], "Updated todo list to []"),
- (
- [{"content": "Task 1", "status": "pending"}],
- "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}]",
- ),
- (
- [
- {"content": "Task 1", "status": "pending"},
- {"content": "Task 2", "status": "in_progress"},
- ],
- "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}, {'content': 'Task 2', 'status': 'in_progress'}]",
- ),
- (
- [
- {"content": "Task 1", "status": "pending"},
- {"content": "Task 2", "status": "in_progress"},
- {"content": "Task 3", "status": "completed"},
- ],
- "Updated todo list to [{'content': 'Task 1', 'status': 'pending'}, {'content': 'Task 2', 'status': 'in_progress'}, {'content': 'Task 3', 'status': 'completed'}]",
- ),
- ],
-)
-def test_todo_middleware_write_todos_tool_execution(todos, expected_message) -> None:
- """Test that the write_todos tool executes correctly."""
- tool_call = {
- "args": {"todos": todos},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- result = write_todos.invoke(tool_call)
- assert result.update["todos"] == todos
- assert result.update["messages"][0].content == expected_message
-
-
- "invalid_todos",
- [
- [{"content": "Task 1", "status": "invalid_status"}],
- [{"status": "pending"}],
- ],
-)
-def test_todo_middleware_write_todos_tool_validation_errors(invalid_todos) -> None:
- """Test that the write_todos tool rejects invalid input."""
- tool_call = {
- "args": {"todos": invalid_todos},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- with pytest.raises(Exception):
- write_todos.invoke(tool_call)
-
-
-def test_todo_middleware_agent_creation_with_middleware() -> None:
- """Test that an agent can be created with the planning middleware."""
- model = FakeToolCallingModel(
- tool_calls=[
- [
- {
- "args": {"todos": [{"content": "Task 1", "status": "pending"}]},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- ],
- [
- {
- "args": {"todos": [{"content": "Task 1", "status": "in_progress"}]},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- ],
- [
- {
- "args": {"todos": [{"content": "Task 1", "status": "completed"}]},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- ],
- [],
- ]
- )
- middleware = TodoListMiddleware()
- agent = create_agent(model=model, middleware=[middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Hello")]})
- assert result["todos"] == [{"content": "Task 1", "status": "completed"}]
-
- # human message (1)
- # ai message (2) - initial todo
- # tool message (3)
- # ai message (4) - updated todo
- # tool message (5)
- # ai message (6) - complete todo
- # tool message (7)
- # ai message (8) - no tool calls
- assert len(result["messages"]) == 8
-
-
-def test_todo_middleware_custom_system_prompt() -> None:
- """Test that TodoListMiddleware can be initialized with custom system prompt."""
- custom_system_prompt = "Custom todo system prompt for testing"
- middleware = TodoListMiddleware(system_prompt=custom_system_prompt)
- model = FakeToolCallingModel()
-
- state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
-
- request = ModelRequest(
- model=model,
- system_prompt="Original prompt",
- messages=[HumanMessage(content="Hello")],
- tool_choice=None,
- tools=[],
- response_format=None,
- model_settings={},
- state=state,
- runtime=cast(Runtime, object()),
- )
-
- def mock_handler(req: ModelRequest) -> AIMessage:
- return AIMessage(content="mock response")
-
- # Call wrap_model_call to trigger the middleware logic
- middleware.wrap_model_call(request, mock_handler)
- # Check that the request was modified in place
- assert request.system_prompt == f"Original prompt\n\n{custom_system_prompt}"
-
-
-def test_todo_middleware_custom_tool_description() -> None:
- """Test that TodoListMiddleware can be initialized with custom tool description."""
- custom_tool_description = "Custom tool description for testing"
- middleware = TodoListMiddleware(tool_description=custom_tool_description)
-
- assert len(middleware.tools) == 1
- tool = middleware.tools[0]
- assert tool.description == custom_tool_description
-
-
-def test_todo_middleware_custom_system_prompt_and_tool_description() -> None:
- """Test that TodoListMiddleware can be initialized with both custom prompts."""
- custom_system_prompt = "Custom system prompt"
- custom_tool_description = "Custom tool description"
- middleware = TodoListMiddleware(
- system_prompt=custom_system_prompt,
- tool_description=custom_tool_description,
- )
-
- # Verify system prompt
- model = FakeToolCallingModel()
- state: PlanningState = {"messages": [HumanMessage(content="Hello")]}
-
- request = ModelRequest(
- model=model,
- system_prompt=None,
- messages=[HumanMessage(content="Hello")],
- tool_choice=None,
- tools=[],
- response_format=None,
- state=state,
- runtime=cast(Runtime, object()),
- model_settings={},
- )
-
- def mock_handler(req: ModelRequest) -> AIMessage:
- return AIMessage(content="mock response")
-
- # Call wrap_model_call to trigger the middleware logic
- middleware.wrap_model_call(request, mock_handler)
- # Check that the request was modified in place
- assert request.system_prompt == custom_system_prompt
-
- # Verify tool description
- assert len(middleware.tools) == 1
- tool = middleware.tools[0]
- assert tool.description == custom_tool_description
-
-
-def test_todo_middleware_default_prompts() -> None:
- """Test that TodoListMiddleware uses default prompts when none provided."""
- middleware = TodoListMiddleware()
-
- # Verify default system prompt
- assert middleware.system_prompt == WRITE_TODOS_SYSTEM_PROMPT
-
- # Verify default tool description
- assert middleware.tool_description == WRITE_TODOS_TOOL_DESCRIPTION
- assert len(middleware.tools) == 1
- tool = middleware.tools[0]
- assert tool.description == WRITE_TODOS_TOOL_DESCRIPTION
-
-
-def test_todo_middleware_custom_system_prompt_in_agent() -> None:
- """Test that custom tool executes correctly in an agent."""
- middleware = TodoListMiddleware(system_prompt="call the write_todos tool")
-
- model = FakeToolCallingModel(
- tool_calls=[
- [
- {
- "args": {"todos": [{"content": "Custom task", "status": "pending"}]},
- "name": "write_todos",
- "type": "tool_call",
- "id": "test_call",
- }
- ],
- [],
- ]
- )
-
- agent = create_agent(model=model, middleware=[middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Hello")]})
- assert result["todos"] == [{"content": "Custom task", "status": "pending"}]
- # assert custom system prompt is in the first AI message
- assert "call the write_todos tool" in result["messages"][1].content
-
-
-@tool
-def simple_tool(input: str) -> str:
- """A simple tool"""
- return input
-
-
-def test_middleware_unit_functionality():
- """Test that the middleware works as expected in isolation."""
- # Test with end behavior
- middleware = ModelCallLimitMiddleware(thread_limit=2, run_limit=1)
-
- # Mock runtime (not used in current implementation)
- runtime = None
-
- # Test when limits are not exceeded
- state = {"thread_model_call_count": 0, "run_model_call_count": 0}
- result = middleware.before_model(state, runtime)
- assert result is None
-
- # Test when thread limit is exceeded
- state = {"thread_model_call_count": 2, "run_model_call_count": 0}
- result = middleware.before_model(state, runtime)
- assert result is not None
- assert result["jump_to"] == "end"
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert "thread limit (2/2)" in result["messages"][0].content
-
- # Test when run limit is exceeded
- state = {"thread_model_call_count": 1, "run_model_call_count": 1}
- result = middleware.before_model(state, runtime)
- assert result is not None
- assert result["jump_to"] == "end"
- assert "messages" in result
- assert len(result["messages"]) == 1
- assert "run limit (1/1)" in result["messages"][0].content
-
- # Test with error behavior
- middleware_exception = ModelCallLimitMiddleware(
- thread_limit=2, run_limit=1, exit_behavior="error"
- )
-
- # Test exception when thread limit exceeded
- state = {"thread_model_call_count": 2, "run_model_call_count": 0}
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- middleware_exception.before_model(state, runtime)
-
- assert "thread limit (2/2)" in str(exc_info.value)
-
- # Test exception when run limit exceeded
- state = {"thread_model_call_count": 1, "run_model_call_count": 1}
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- middleware_exception.before_model(state, runtime)
-
- assert "run limit (1/1)" in str(exc_info.value)
-
-
-def test_thread_limit_with_create_agent():
- """Test that thread limits work correctly with create_agent."""
- model = FakeToolCallingModel()
-
- # Set thread limit to 1 (should be exceeded after 1 call)
- agent = create_agent(
- model=model,
- tools=[simple_tool],
- middleware=[ModelCallLimitMiddleware(thread_limit=1)],
- checkpointer=InMemorySaver(),
- )
-
- # First invocation should work - 1 model call, within thread limit
- result = agent.invoke(
- {"messages": [HumanMessage("Hello")]}, {"configurable": {"thread_id": "thread1"}}
- )
-
- # Should complete successfully with 1 model call
- assert "messages" in result
- assert len(result["messages"]) == 2 # Human + AI messages
-
- # Second invocation in same thread should hit thread limit
- # The agent should jump to end after detecting the limit
- result2 = agent.invoke(
- {"messages": [HumanMessage("Hello again")]}, {"configurable": {"thread_id": "thread1"}}
- )
-
- assert "messages" in result2
- # The agent should have detected the limit and jumped to end with a limit exceeded message
- # So we should have: previous messages + new human message + limit exceeded AI message
- assert len(result2["messages"]) == 4 # Previous Human + AI + New Human + Limit AI
- assert isinstance(result2["messages"][0], HumanMessage) # First human
- assert isinstance(result2["messages"][1], AIMessage) # First AI response
- assert isinstance(result2["messages"][2], HumanMessage) # Second human
- assert isinstance(result2["messages"][3], AIMessage) # Limit exceeded message
- assert "thread limit" in result2["messages"][3].content
-
-
-def test_run_limit_with_create_agent():
- """Test that run limits work correctly with create_agent."""
- # Create a model that will make 2 calls
- model = FakeToolCallingModel(
- tool_calls=[
- [{"name": "simple_tool", "args": {"input": "test"}, "id": "1"}],
- [], # No tool calls on second call
- ]
- )
-
- # Set run limit to 1 (should be exceeded after 1 call)
- agent = create_agent(
- model=model,
- tools=[simple_tool],
- middleware=[ModelCallLimitMiddleware(run_limit=1)],
- checkpointer=InMemorySaver(),
- )
-
- # This should hit the run limit after the first model call
- result = agent.invoke(
- {"messages": [HumanMessage("Hello")]}, {"configurable": {"thread_id": "thread1"}}
- )
-
- assert "messages" in result
- # The agent should have made 1 model call then jumped to end with limit exceeded message
- # So we should have: Human + AI + Tool + Limit exceeded AI message
- assert len(result["messages"]) == 4 # Human + AI + Tool + Limit AI
- assert isinstance(result["messages"][0], HumanMessage)
- assert isinstance(result["messages"][1], AIMessage)
- assert isinstance(result["messages"][2], ToolMessage)
- assert isinstance(result["messages"][3], AIMessage) # Limit exceeded message
- assert "run limit" in result["messages"][3].content
-
-
-def test_middleware_initialization_validation():
- """Test that middleware initialization validates parameters correctly."""
- # Test that at least one limit must be specified
- with pytest.raises(ValueError, match="At least one limit must be specified"):
- ModelCallLimitMiddleware()
-
- # Test invalid exit behavior
- with pytest.raises(ValueError, match="Invalid exit_behavior"):
- ModelCallLimitMiddleware(thread_limit=5, exit_behavior="invalid")
-
- # Test valid initialization
- middleware = ModelCallLimitMiddleware(thread_limit=5, run_limit=3)
- assert middleware.thread_limit == 5
- assert middleware.run_limit == 3
- assert middleware.exit_behavior == "end"
-
- # Test with only thread limit
- middleware = ModelCallLimitMiddleware(thread_limit=5)
- assert middleware.thread_limit == 5
- assert middleware.run_limit is None
-
- # Test with only run limit
- middleware = ModelCallLimitMiddleware(run_limit=3)
- assert middleware.thread_limit is None
- assert middleware.run_limit == 3
-
-
-def test_exception_error_message():
- """Test that the exception provides clear error messages."""
- middleware = ModelCallLimitMiddleware(thread_limit=2, run_limit=1, exit_behavior="error")
-
- # Test thread limit exceeded
- state = {"thread_model_call_count": 2, "run_model_call_count": 0}
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- middleware.before_model(state, None)
-
- error_msg = str(exc_info.value)
- assert "Model call limits exceeded" in error_msg
- assert "thread limit (2/2)" in error_msg
-
- # Test run limit exceeded
- state = {"thread_model_call_count": 0, "run_model_call_count": 1}
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- middleware.before_model(state, None)
-
- error_msg = str(exc_info.value)
- assert "Model call limits exceeded" in error_msg
- assert "run limit (1/1)" in error_msg
-
- # Test both limits exceeded
- state = {"thread_model_call_count": 2, "run_model_call_count": 1}
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- middleware.before_model(state, None)
-
- error_msg = str(exc_info.value)
- assert "Model call limits exceeded" in error_msg
- assert "thread limit (2/2)" in error_msg
- assert "run limit (1/1)" in error_msg
-
-
-def test_run_limit_resets_between_invocations() -> None:
- """Test that run_model_call_count resets between invocations, but thread_model_call_count accumulates."""
-
- # First: No tool calls per invocation, so model does not increment call counts internally
- middleware = ModelCallLimitMiddleware(thread_limit=3, run_limit=1, exit_behavior="error")
- model = FakeToolCallingModel(
- tool_calls=[[], [], [], []]
- ) # No tool calls, so only model call per run
-
- agent = create_agent(model=model, middleware=[middleware], checkpointer=InMemorySaver())
-
- thread_config = {"configurable": {"thread_id": "test_thread"}}
- agent.invoke({"messages": [HumanMessage("Hello")]}, thread_config)
- agent.invoke({"messages": [HumanMessage("Hello again")]}, thread_config)
- agent.invoke({"messages": [HumanMessage("Hello third")]}, thread_config)
-
- # Fourth run: should raise, thread_model_call_count == 3 (limit)
- with pytest.raises(ModelCallLimitExceededError) as exc_info:
- agent.invoke({"messages": [HumanMessage("Hello fourth")]}, thread_config)
- error_msg = str(exc_info.value)
- assert "thread limit (3/3)" in error_msg
-
-
-# Async Middleware Tests
-async def test_create_agent_async_invoke() -> None:
- """Test async invoke with async middleware hooks."""
- calls = []
-
- class AsyncMiddleware(AgentMiddleware):
- async def abefore_model(self, state, runtime) -> None:
- calls.append("AsyncMiddleware.abefore_model")
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- calls.append("AsyncMiddleware.awrap_model_call")
- request.messages.append(HumanMessage("async middleware message"))
- return await handler(request)
-
- async def aafter_model(self, state, runtime) -> None:
- calls.append("AsyncMiddleware.aafter_model")
-
- @tool
- def my_tool(input: str) -> str:
- """A great tool"""
- calls.append("my_tool")
- return input.upper()
-
- agent = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[
- [{"args": {"input": "yo"}, "id": "1", "name": "my_tool"}],
- [],
- ]
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[AsyncMiddleware()],
- )
-
- result = await agent.ainvoke({"messages": [HumanMessage("hello")]})
-
- # Should have:
- # 1. Original hello message
- # 2. Async middleware message (first invoke)
- # 3. AI message with tool call
- # 4. Tool message
- # 5. Async middleware message (second invoke)
- # 6. Final AI message
- assert len(result["messages"]) == 6
- assert result["messages"][0].content == "hello"
- assert result["messages"][1].content == "async middleware message"
- assert calls == [
- "AsyncMiddleware.abefore_model",
- "AsyncMiddleware.awrap_model_call",
- "AsyncMiddleware.aafter_model",
- "my_tool",
- "AsyncMiddleware.abefore_model",
- "AsyncMiddleware.awrap_model_call",
- "AsyncMiddleware.aafter_model",
- ]
-
-
-async def test_create_agent_async_invoke_multiple_middleware() -> None:
- """Test async invoke with multiple async middleware hooks."""
- calls = []
-
- class AsyncMiddlewareOne(AgentMiddleware):
- async def abefore_model(self, state, runtime) -> None:
- calls.append("AsyncMiddlewareOne.abefore_model")
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- calls.append("AsyncMiddlewareOne.awrap_model_call")
- return await handler(request)
-
- async def aafter_model(self, state, runtime) -> None:
- calls.append("AsyncMiddlewareOne.aafter_model")
-
- class AsyncMiddlewareTwo(AgentMiddleware):
- async def abefore_model(self, state, runtime) -> None:
- calls.append("AsyncMiddlewareTwo.abefore_model")
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- calls.append("AsyncMiddlewareTwo.awrap_model_call")
- return await handler(request)
-
- async def aafter_model(self, state, runtime) -> None:
- calls.append("AsyncMiddlewareTwo.aafter_model")
-
- agent = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[AsyncMiddlewareOne(), AsyncMiddlewareTwo()],
- )
-
- result = await agent.ainvoke({"messages": [HumanMessage("hello")]})
-
- assert calls == [
- "AsyncMiddlewareOne.abefore_model",
- "AsyncMiddlewareTwo.abefore_model",
- "AsyncMiddlewareOne.awrap_model_call",
- "AsyncMiddlewareTwo.awrap_model_call",
- "AsyncMiddlewareTwo.aafter_model",
- "AsyncMiddlewareOne.aafter_model",
- ]
-
-
-async def test_create_agent_async_jump() -> None:
- """Test async invoke with async middleware using jump_to."""
- calls = []
-
- class AsyncMiddlewareOne(AgentMiddleware):
- async def abefore_model(self, state, runtime) -> None:
- calls.append("AsyncMiddlewareOne.abefore_model")
-
- class AsyncMiddlewareTwo(AgentMiddleware):
- @hook_config(can_jump_to=["end"])
- async def abefore_model(self, state, runtime) -> dict[str, Any]:
- calls.append("AsyncMiddlewareTwo.abefore_model")
- return {"jump_to": "end"}
-
- @tool
- def my_tool(input: str) -> str:
- """A great tool"""
- calls.append("my_tool")
- return input.upper()
-
- agent = create_agent(
- model=FakeToolCallingModel(
- tool_calls=[[ToolCall(id="1", name="my_tool", args={"input": "yo"})]],
- ),
- tools=[my_tool],
- system_prompt="You are a helpful assistant.",
- middleware=[AsyncMiddlewareOne(), AsyncMiddlewareTwo()],
- )
-
- result = await agent.ainvoke({"messages": []})
-
- assert result == {"messages": []}
- assert calls == ["AsyncMiddlewareOne.abefore_model", "AsyncMiddlewareTwo.abefore_model"]
-
-
-async def test_create_agent_mixed_sync_async_middleware() -> None:
- """Test async invoke with mixed sync and async middleware."""
- calls = []
-
- class MostlySyncMiddleware(AgentMiddleware):
- def before_model(self, state, runtime) -> None:
- calls.append("MostlySyncMiddleware.before_model")
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("MostlySyncMiddleware.wrap_model_call")
- return handler(request)
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
- ) -> ModelCallResult:
- calls.append("MostlySyncMiddleware.awrap_model_call")
- return await handler(request)
-
- def after_model(self, state, runtime) -> None:
- calls.append("MostlySyncMiddleware.after_model")
-
- class AsyncMiddleware(AgentMiddleware):
- async def abefore_model(self, state, runtime) -> None:
- calls.append("AsyncMiddleware.abefore_model")
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- calls.append("AsyncMiddleware.awrap_model_call")
- return await handler(request)
-
- async def aafter_model(self, state, runtime) -> None:
- calls.append("AsyncMiddleware.aafter_model")
-
- agent = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[MostlySyncMiddleware(), AsyncMiddleware()],
- )
-
- await agent.ainvoke({"messages": [HumanMessage("hello")]})
-
- # In async mode, both sync and async middleware should work
- # Note: Sync wrap_model_call is not called when running in async mode,
- # as the async version is preferred
- assert calls == [
- "MostlySyncMiddleware.before_model",
- "AsyncMiddleware.abefore_model",
- "MostlySyncMiddleware.awrap_model_call",
- "AsyncMiddleware.awrap_model_call",
- "AsyncMiddleware.aafter_model",
- "MostlySyncMiddleware.after_model",
- ]
-
-
-# Tests for wrap_model_call hook
-def test_wrap_model_call_hook() -> None:
- """Test that wrap_model_call hook is called on model errors."""
- call_count = {"value": 0}
-
- class FailingModel(BaseChatModel):
- """Model that fails on first call, succeeds on second."""
-
- def _generate(self, messages, **kwargs):
- call_count["value"] += 1
- if call_count["value"] == 1:
- raise ValueError("First call fails")
- return ChatResult(
- generations=[ChatGeneration(message=AIMessage(content="Success on retry"))]
- )
-
- @property
- def _llm_type(self):
- return "failing"
-
- class RetryMiddleware(AgentMiddleware):
- def __init__(self):
- super().__init__()
- self.retry_count = 0
-
- def wrap_model_call(self, request, handler):
- try:
- return handler(request)
- except Exception:
- # Retry on error
- self.retry_count += 1
- return handler(request)
-
- failing_model = FailingModel()
- retry_middleware = RetryMiddleware()
-
- agent = create_agent(model=failing_model, middleware=[retry_middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Should have retried once
- assert retry_middleware.retry_count == 1
- # Should have succeeded on second attempt
- assert len(result["messages"]) == 2
- assert result["messages"][1].content == "Success on retry"
-
-
-def test_wrap_model_call_retry_count() -> None:
- """Test that wrap_model_call can retry multiple times."""
-
- class AlwaysFailingModel(BaseChatModel):
- """Model that always fails."""
-
- def _generate(self, messages, **kwargs):
- raise ValueError("Always fails")
-
- @property
- def _llm_type(self):
- return "always_failing"
-
- class AttemptTrackingMiddleware(AgentMiddleware):
- def __init__(self):
- super().__init__()
- self.attempts = []
-
- def wrap_model_call(self, request, handler):
- max_retries = 3
- last_exception = None
- for attempt in range(max_retries):
- self.attempts.append(attempt + 1)
- try:
- return handler(request)
- except Exception as e:
- last_exception = e
- if attempt < max_retries - 1:
- continue # Retry
-
- # All retries failed, re-raise the last exception
- if last_exception:
- raise last_exception
-
- model = AlwaysFailingModel()
- tracker = AttemptTrackingMiddleware()
-
- agent = create_agent(model=model, middleware=[tracker])
-
- with pytest.raises(ValueError, match="Always fails"):
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Should have attempted 3 times
- assert tracker.attempts == [1, 2, 3]
-
-
-def test_wrap_model_call_no_retry() -> None:
- """Test that error is propagated when middleware doesn't retry."""
-
- class FailingModel(BaseChatModel):
- """Model that always fails."""
-
- def _generate(self, messages, **kwargs):
- raise ValueError("Model error")
-
- @property
- def _llm_type(self):
- return "failing"
-
- class NoRetryMiddleware(AgentMiddleware):
- def wrap_model_call(self, request, handler):
- return handler(request)
-
- agent = create_agent(model=FailingModel(), middleware=[NoRetryMiddleware()])
-
- with pytest.raises(ValueError, match="Model error"):
- agent.invoke({"messages": [HumanMessage("Test")]})
-
-
-def test_model_fallback_middleware() -> None:
- """Test ModelFallbackMiddleware with fallback models only."""
-
- class FailingModel(BaseChatModel):
- """Model that always fails."""
-
- def _generate(self, messages, **kwargs):
- raise ValueError("Primary model failed")
-
- @property
- def _llm_type(self):
- return "failing"
-
- class SuccessModel(BaseChatModel):
- """Model that succeeds."""
-
- def _generate(self, messages, **kwargs):
- return ChatResult(
- generations=[ChatGeneration(message=AIMessage(content="Fallback success"))]
- )
-
- @property
- def _llm_type(self):
- return "success"
-
- primary = FailingModel()
- fallback = SuccessModel()
-
- # Only pass fallback models to middleware (not the primary)
- fallback_middleware = ModelFallbackMiddleware(fallback)
-
- agent = create_agent(model=primary, middleware=[fallback_middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Should have succeeded with fallback model
- assert len(result["messages"]) == 2
- assert result["messages"][1].content == "Fallback success"
-
-
-def test_model_fallback_middleware_exhausted() -> None:
- """Test ModelFallbackMiddleware when all models fail."""
-
- class AlwaysFailingModel(BaseChatModel):
- """Model that always fails."""
-
- def __init__(self, name: str):
- super().__init__()
- self.name = name
-
- def _generate(self, messages, **kwargs):
- raise ValueError(f"{self.name} failed")
-
- @property
- def _llm_type(self):
- return self.name
-
- primary = AlwaysFailingModel("primary")
- fallback1 = AlwaysFailingModel("fallback1")
- fallback2 = AlwaysFailingModel("fallback2")
-
- # Primary fails (attempt 1), then fallback1 (attempt 2), then fallback2 (attempt 3)
- fallback_middleware = ModelFallbackMiddleware(fallback1, fallback2)
-
- agent = create_agent(model=primary, middleware=[fallback_middleware])
-
- # Should fail with the last fallback's error
- with pytest.raises(ValueError, match="fallback2 failed"):
- agent.invoke({"messages": [HumanMessage("Test")]})
-
-
-def test_model_fallback_middleware_initialization() -> None:
- """Test ModelFallbackMiddleware initialization."""
-
- # Test with no models - now a TypeError (missing required argument)
- with pytest.raises(TypeError):
- ModelFallbackMiddleware() # type: ignore[call-arg]
-
- # Test with one fallback model (valid)
- middleware = ModelFallbackMiddleware(FakeToolCallingModel())
- assert len(middleware.models) == 1
-
- # Test with multiple fallback models
- middleware = ModelFallbackMiddleware(FakeToolCallingModel(), FakeToolCallingModel())
- assert len(middleware.models) == 2
-
-
-def test_wrap_model_call_max_attempts() -> None:
- """Test that middleware controls termination via retry limits."""
-
- class AlwaysFailingModel(BaseChatModel):
- """Model that always fails."""
-
- def _generate(self, messages, **kwargs):
- raise ValueError("Always fails")
-
- @property
- def _llm_type(self):
- return "always_failing"
-
- class LimitedRetryMiddleware(AgentMiddleware):
- """Middleware that limits its own retries."""
-
- def __init__(self, max_retries: int = 10):
- super().__init__()
- self.max_retries = max_retries
- self.attempt_count = 0
-
- def wrap_model_call(self, request, handler):
- last_exception = None
- for attempt in range(self.max_retries):
- self.attempt_count += 1
- try:
- return handler(request)
- except Exception as e:
- last_exception = e
- # Continue to retry
-
- # All retries exhausted, re-raise the last error
- if last_exception:
- raise last_exception
-
- model = AlwaysFailingModel()
- middleware = LimitedRetryMiddleware(max_retries=10)
-
- agent = create_agent(model=model, middleware=[middleware])
-
- # Should fail with the model's error after middleware stops retrying
- with pytest.raises(ValueError, match="Always fails"):
- agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Should have attempted exactly 10 times as configured
- assert middleware.attempt_count == 10
-
-
-async def test_wrap_model_call_async() -> None:
- """Test wrap_model_call hook with async model execution."""
- call_count = {"value": 0}
-
- class AsyncFailingModel(BaseChatModel):
- """Model that fails on first async call, succeeds on second."""
-
- def _generate(self, messages, **kwargs):
- return ChatResult(generations=[ChatGeneration(message=AIMessage(content="sync"))])
-
- async def _agenerate(self, messages, **kwargs):
- call_count["value"] += 1
- if call_count["value"] == 1:
- raise ValueError("First async call fails")
- return ChatResult(
- generations=[ChatGeneration(message=AIMessage(content="Async retry success"))]
- )
-
- @property
- def _llm_type(self):
- return "async_failing"
-
- class AsyncRetryMiddleware(AgentMiddleware):
- def __init__(self):
- super().__init__()
- self.retry_count = 0
-
- async def awrap_model_call(self, request, handler):
- try:
- return await handler(request)
- except Exception:
- # Retry on error
- self.retry_count += 1
- return await handler(request)
-
- failing_model = AsyncFailingModel()
- retry_middleware = AsyncRetryMiddleware()
-
- agent = create_agent(model=failing_model, middleware=[retry_middleware])
-
- result = await agent.ainvoke({"messages": [HumanMessage("Test")]})
-
- # Should have retried once
- assert retry_middleware.retry_count == 1
- # Should have succeeded on second attempt
- assert len(result["messages"]) == 2
- assert result["messages"][1].content == "Async retry success"
-
-
-def test_wrap_model_call_rewrite_response() -> None:
- """Test that middleware can rewrite model responses."""
-
- class SimpleModel(BaseChatModel):
- """Model that returns a simple response."""
-
- def _generate(self, messages, **kwargs):
- return ChatResult(
- generations=[ChatGeneration(message=AIMessage(content="Original response"))]
- )
-
- @property
- def _llm_type(self):
- return "simple"
-
- class ResponseRewriteMiddleware(AgentMiddleware):
- """Middleware that rewrites the response."""
-
- def wrap_model_call(self, request, handler):
- result = handler(request)
-
- # result is ModelResponse, extract AIMessage from it
- ai_message = result.result[0]
- # Rewrite the response
- return AIMessage(content=f"REWRITTEN: {ai_message.content}")
-
- model = SimpleModel()
- middleware = ResponseRewriteMiddleware()
-
- agent = create_agent(model=model, middleware=[middleware])
-
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Response should be rewritten by middleware
- assert result["messages"][1].content == "REWRITTEN: Original response"
-
-
-def test_wrap_model_call_convert_error_to_response() -> None:
- """Test that middleware can convert errors to successful responses."""
-
- class AlwaysFailingModel(BaseChatModel):
- """Model that always fails."""
-
- def _generate(self, messages, **kwargs):
- raise ValueError("Model error")
-
- @property
- def _llm_type(self):
- return "failing"
-
- class ErrorToResponseMiddleware(AgentMiddleware):
- """Middleware that converts errors to success responses."""
-
- def wrap_model_call(self, request, handler):
- try:
- return handler(request)
- except Exception as e:
- # Convert error to success response
- return AIMessage(content=f"Error occurred: {e}. Using fallback response.")
-
- model = AlwaysFailingModel()
- middleware = ErrorToResponseMiddleware()
-
- agent = create_agent(model=model, middleware=[middleware])
-
- # Should not raise, middleware converts error to response
- result = agent.invoke({"messages": [HumanMessage("Test")]})
-
- # Response should be the fallback from middleware
- assert "Error occurred" in result["messages"][1].content
- assert "fallback response" in result["messages"][1].content
-
-
-def test_create_agent_sync_invoke_with_only_async_middleware_raises_error() -> None:
- """Test that sync invoke with only async middleware works via run_in_executor."""
-
- class AsyncOnlyMiddleware(AgentMiddleware):
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- return await handler(request)
-
- agent = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[AsyncOnlyMiddleware()],
- )
-
- with pytest.raises(NotImplementedError):
- agent.invoke({"messages": [HumanMessage("hello")]})
-
-
-def test_create_agent_sync_invoke_with_mixed_middleware() -> None:
- """Test that sync invoke works with mixed sync/async middleware when sync versions exist."""
- calls = []
-
- class MixedMiddleware(AgentMiddleware):
- def before_model(self, state, runtime) -> None:
- calls.append("MixedMiddleware.before_model")
-
- async def abefore_model(self, state, runtime) -> None:
- calls.append("MixedMiddleware.abefore_model")
-
- def wrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], AIMessage],
- ) -> AIMessage:
- calls.append("MixedMiddleware.wrap_model_call")
- return handler(request)
-
- async def awrap_model_call(
- self,
- request: ModelRequest,
- handler: Callable[[ModelRequest], Awaitable[AIMessage]],
- ) -> AIMessage:
- calls.append("MixedMiddleware.awrap_model_call")
- return await handler(request)
-
- agent = create_agent(
- model=FakeToolCallingModel(),
- tools=[],
- system_prompt="You are a helpful assistant.",
- middleware=[MixedMiddleware()],
- )
-
- result = agent.invoke({"messages": [HumanMessage("hello")]})
-
- # In sync mode, only sync methods should be called
- assert calls == [
- "MixedMiddleware.before_model",
- "MixedMiddleware.wrap_model_call",
- ]
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_on_tool_call_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/test_on_tool_call_middleware.py
deleted file mode 100644
index e936562ac0..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/test_on_tool_call_middleware.py
+++ /dev/null
@@ -1,828 +0,0 @@
-"""Unit tests for wrap_tool_call middleware integration."""
-
-from collections.abc import Callable
-
-import pytest
-from langchain_core.messages import HumanMessage, ToolCall, ToolMessage
-from langchain_core.tools import tool
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.types import Command
-
-from langchain.agents.factory import create_agent
-from langchain.agents.middleware.types import AgentMiddleware
-from langchain.agents.middleware.types import ToolCallRequest
-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel
-
-
-@tool
-def search(query: str) -> str:
- """Search for information."""
- return f"Results for: {query}"
-
-
-@tool
-def calculator(expression: str) -> str:
- """Calculate an expression."""
- return f"Result: {expression}"
-
-
-@tool
-def failing_tool(input: str) -> str:
- """Tool that always fails."""
- msg = f"Failed: {input}"
- raise ValueError(msg)
-
-
-def test_simple_logging_middleware() -> None:
- """Test middleware that logs tool calls."""
- call_log = []
-
- class LoggingMiddleware(AgentMiddleware):
- """Middleware that logs tool calls."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append(f"before_{request.tool.name}")
- response = handler(request)
- call_log.append(f"after_{request.tool.name}")
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[LoggingMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search for test")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- assert len(call_log) == 2
- assert call_log[0] == "before_search"
- assert call_log[1] == "after_search"
- assert len(result["messages"]) > 0
-
-
-def test_request_modification_middleware() -> None:
- """Test middleware that modifies tool call arguments."""
-
- class ModifyArgsMiddleware(AgentMiddleware):
- """Middleware that modifies tool arguments."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- # Add prefix to query
- if request.tool.name == "search":
- original_query = request.tool_call["args"]["query"]
- request.tool_call["args"]["query"] = f"modified: {original_query}"
- return handler(request)
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[ModifyArgsMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- assert "modified: test" in tool_messages[0].content
-
-
-def test_response_inspection_middleware() -> None:
- """Test middleware that inspects tool responses."""
- inspected_responses = []
-
- class ResponseInspectionMiddleware(AgentMiddleware):
- """Middleware that inspects responses."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- response = handler(request)
-
- # Record response details
- if isinstance(response, ToolMessage):
- inspected_responses.append(
- {
- "tool_name": request.tool.name,
- "content": response.content,
- }
- )
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[ResponseInspectionMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- # Middleware should have inspected the response
- assert len(inspected_responses) == 1
- assert inspected_responses[0]["tool_name"] == "search"
-
-
-def test_conditional_retry_middleware() -> None:
- """Test middleware that retries tool calls based on response content."""
- call_count = 0
-
- class ConditionalRetryMiddleware(AgentMiddleware):
- """Middleware that retries based on response content."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- nonlocal call_count
- max_retries = 2
-
- for attempt in range(max_retries):
- response = handler(request)
- call_count += 1
-
- # Check if we should retry based on content
- if (
- isinstance(response, ToolMessage)
- and "retry_marker" in response.content
- and attempt < max_retries - 1
- ):
- # Continue to retry
- continue
-
- # Return on success or final attempt
- return response
-
- return response
-
- # Use search tool which always succeeds - we'll modify request to test retry logic
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[ConditionalRetryMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Middleware should have been called at least once
- assert call_count >= 1
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
-
-
-def test_multiple_middleware_composition() -> None:
- """Test that multiple middleware compose correctly."""
- call_log = []
-
- class OuterMiddleware(AgentMiddleware):
- """Outer middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("outer_before")
- response = handler(request)
- call_log.append("outer_after")
- return response
-
- class InnerMiddleware(AgentMiddleware):
- """Inner middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("inner_before")
- response = handler(request)
- call_log.append("inner_after")
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- # First middleware is outermost
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[OuterMiddleware(), InnerMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Verify correct composition order
- assert call_log == ["outer_before", "inner_before", "inner_after", "outer_after"]
- assert len(result["messages"]) > 0
-
-
-def test_middleware_with_multiple_tool_calls() -> None:
- """Test middleware handles multiple tool calls correctly."""
- call_log = []
-
- class LoggingMiddleware(AgentMiddleware):
- """Middleware that logs tool calls."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append(request.tool.name)
- return handler(request)
-
- model = FakeToolCallingModel(
- tool_calls=[
- [
- ToolCall(name="search", args={"query": "test1"}, id="1"),
- ToolCall(name="calculator", args={"expression": "1+1"}, id="2"),
- ],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search, calculator],
- middleware=[LoggingMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Use tools")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Each tool call should be logged
- assert "search" in call_log
- assert "calculator" in call_log
- assert len(call_log) == 2
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 2
-
-
-def test_middleware_access_to_state() -> None:
- """Test middleware can access agent state."""
- state_seen = []
-
- class StateInspectionMiddleware(AgentMiddleware):
- """Middleware that inspects state."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- # Record state - state is now in request.state
- state = request.state
- if state is not None:
- if isinstance(state, dict) and "messages" in state:
- state_seen.append(("dict", len(state["messages"])))
- elif isinstance(state, list):
- state_seen.append(("list", len(state)))
- else:
- state_seen.append(("other", type(state).__name__))
- return handler(request)
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[StateInspectionMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Middleware should have seen state (state is passed to wrap_tool)
- assert len(state_seen) >= 1
-
-
-def test_middleware_without_wrap_tool() -> None:
- """Test that middleware without wrap_tool hook works normally."""
-
- class NoOpMiddleware(AgentMiddleware):
- """Middleware without wrap_tool."""
-
- def before_model(self, state, runtime):
- """Just a dummy hook."""
- return None
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[NoOpMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Should work normally
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
-
-
-def test_generator_composition_immediate_outer_return() -> None:
- """Test composition when outer handler intercepts response."""
- call_log = []
-
- class ImmediateReturnMiddleware(AgentMiddleware):
- """Outer middleware that intercepts and modifies response."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("outer_yield")
- # Call handler, receive response from inner
- response = handler(request)
- call_log.append("outer_got_response")
- # Return modified message
- modified = ToolMessage(
- content="Outer intercepted",
- tool_call_id=request.tool_call["id"],
- name=request.tool_call["name"],
- )
- return modified
-
- class InnerMiddleware(AgentMiddleware):
- """Inner middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("inner_called")
- response = handler(request)
- call_log.append("inner_got_response")
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[ImmediateReturnMiddleware(), InnerMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Both should be called, outer intercepts the response
- assert call_log == ["outer_yield", "inner_called", "inner_got_response", "outer_got_response"]
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- assert "Outer intercepted" in tool_messages[0].content
-
-
-def test_generator_composition_short_circuit() -> None:
- """Test composition when inner handler short-circuits."""
- call_log = []
-
- class OuterMiddleware(AgentMiddleware):
- """Outer middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("outer_before")
- response = handler(request)
- call_log.append("outer_after")
- # Modify response from inner
- if isinstance(response, ToolMessage):
- modified = ToolMessage(
- content=f"outer_wrapped: {response.content}",
- tool_call_id=response.tool_call_id,
- name=response.name,
- )
- return modified
- return response
-
- class InnerShortCircuitMiddleware(AgentMiddleware):
- """Inner middleware that short-circuits without calling actual tool."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("inner_short_circuit")
- # Don't call handler, return custom response directly
- return ToolMessage(
- content="inner_short_circuit_result",
- tool_call_id=request.tool_call["id"],
- name=request.tool_call["name"],
- )
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[OuterMiddleware(), InnerShortCircuitMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Verify order: outer_before -> inner short circuits -> outer_after
- assert call_log == ["outer_before", "inner_short_circuit", "outer_after"]
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- assert "outer_wrapped: inner_short_circuit_result" in tool_messages[0].content
-
-
-def test_generator_composition_nested_retries() -> None:
- """Test composition when both outer and inner handlers retry."""
- call_log = []
-
- class OuterRetryMiddleware(AgentMiddleware):
- """Outer middleware with retry logic."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- for outer_attempt in range(2):
- call_log.append(f"outer_{outer_attempt}")
- response = handler(request)
-
- if isinstance(response, ToolMessage) and response.content == "inner_final_failure":
- # Inner failed, retry once
- continue
- return response
- return response
-
- class InnerRetryMiddleware(AgentMiddleware):
- """Inner middleware with retry logic."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- for inner_attempt in range(2):
- call_log.append(f"inner_{inner_attempt}")
- response = handler(request)
-
- # Check for error in tool result
- if isinstance(response, ToolMessage):
- if inner_attempt == 0 and "Results for:" in response.content:
- # First attempt succeeded, but let's pretend it's a soft failure
- # to test inner retry
- continue
- return response
-
- # Inner exhausted retries
- return ToolMessage(
- content="inner_final_failure",
- tool_call_id=request.tool_call["id"],
- name=request.tool_call["name"],
- )
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[OuterRetryMiddleware(), InnerRetryMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Verify nested retry pattern
- assert "outer_0" in call_log
- assert "inner_0" in call_log
- assert "inner_1" in call_log
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
-
-
-def test_generator_composition_three_levels() -> None:
- """Test composition with three middleware levels."""
- call_log = []
-
- class OuterMiddleware(AgentMiddleware):
- """Outermost middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("outer_before")
- response = handler(request)
- call_log.append("outer_after")
- return response
-
- class MiddleMiddleware(AgentMiddleware):
- """Middle middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("middle_before")
- response = handler(request)
- call_log.append("middle_after")
- return response
-
- class InnerMiddleware(AgentMiddleware):
- """Innermost middleware."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("inner_before")
- response = handler(request)
- call_log.append("inner_after")
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[OuterMiddleware(), MiddleMiddleware(), InnerMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # Verify correct nesting order
- assert call_log == [
- "outer_before",
- "middle_before",
- "inner_before",
- "inner_after",
- "middle_after",
- "outer_after",
- ]
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
-
-
-def test_generator_composition_return_value_extraction() -> None:
- """Test that handler can modify and return response."""
- final_content = []
-
- class ModifyingMiddleware(AgentMiddleware):
- """Middleware that modifies the final result."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- response = handler(request)
-
- # Return a modified response
- if isinstance(response, ToolMessage):
- modified = ToolMessage(
- content=f"modified: {response.content}",
- tool_call_id=response.tool_call_id,
- name=response.name,
- )
- final_content.append(modified.content)
- return modified
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[ModifyingMiddleware()],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- # Verify the returned value was properly extracted
- assert "modified:" in tool_messages[0].content
- assert len(final_content) == 1
- assert "modified:" in final_content[0]
-
-
-def test_generator_composition_with_mixed_passthrough_and_intercepting() -> None:
- """Test composition with mix of pass-through and intercepting handlers."""
- call_log = []
-
- class FirstPassthroughMiddleware(AgentMiddleware):
- """First middleware that passes through."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("first_before")
- response = handler(request)
- call_log.append("first_after")
- return response
-
- class SecondInterceptingMiddleware(AgentMiddleware):
- """Second middleware that intercepts and returns custom result."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("second_intercept")
- # Call handler but ignore the result
- _ = handler(request)
- # Return custom result
- return ToolMessage(
- content="intercepted_result",
- tool_call_id=request.tool_call["id"],
- name=request.tool_call["name"],
- )
-
- class ThirdPassthroughMiddleware(AgentMiddleware):
- """Third middleware that passes through."""
-
- def wrap_tool_call(
- self,
- request: ToolCallRequest,
- handler: Callable[[ToolCallRequest], ToolMessage | Command],
- ) -> ToolMessage | Command:
- call_log.append("third_called")
- response = handler(request)
- call_log.append("third_after")
- return response
-
- model = FakeToolCallingModel(
- tool_calls=[
- [ToolCall(name="search", args={"query": "test"}, id="1")],
- [],
- ]
- )
-
- agent = create_agent(
- model=model,
- tools=[search],
- middleware=[
- FirstPassthroughMiddleware(),
- SecondInterceptingMiddleware(),
- ThirdPassthroughMiddleware(),
- ],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Search")]},
- {"configurable": {"thread_id": "test"}},
- )
-
- # All middleware are called, second intercepts and returns custom result
- assert call_log == [
- "first_before",
- "second_intercept",
- "third_called",
- "third_after",
- "first_after",
- ]
-
- tool_messages = [m for m in result["messages"] if isinstance(m, ToolMessage)]
- assert len(tool_messages) == 1
- assert "intercepted_result" in tool_messages[0].content
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_parallel_tool_call_limits.py b/libs/langchain_v1/tests/unit_tests/agents/test_parallel_tool_call_limits.py
deleted file mode 100644
index 141dcc9ac8..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/test_parallel_tool_call_limits.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""Tests for parallel tool call handling in ToolCallLimitMiddleware."""
-
-import pytest
-from langchain_core.messages import AIMessage, HumanMessage, ToolCall, ToolMessage
-from langchain_core.tools import tool
-from langgraph.checkpoint.memory import InMemorySaver
-
-from langchain.agents.factory import create_agent
-from langchain.agents.middleware.tool_call_limit import ToolCallLimitMiddleware
-from tests.unit_tests.agents.model import FakeToolCallingModel
-
-
-def test_parallel_tool_calls_with_limit_continue_mode():
- """Test parallel tool calls with a limit of 1 in 'continue' mode.
-
- When the model proposes 3 tool calls with a limit of 1:
- - The first call should execute successfully
- - The 2nd and 3rd calls should be blocked with error ToolMessages
- - Execution should continue (no jump_to)
- """
-
- @tool
- def search(query: str) -> str:
- """Search for information."""
- return f"Results: {query}"
-
- # Model proposes 3 parallel search calls in a single AIMessage
- model = FakeToolCallingModel(
- tool_calls=[
- [
- ToolCall(name="search", args={"query": "q1"}, id="1"),
- ToolCall(name="search", args={"query": "q2"}, id="2"),
- ToolCall(name="search", args={"query": "q3"}, id="3"),
- ],
- [], # Model stops after seeing the errors
- ]
- )
-
- limiter = ToolCallLimitMiddleware(thread_limit=1, exit_behavior="continue")
- agent = create_agent(
- model=model, tools=[search], middleware=[limiter], checkpointer=InMemorySaver()
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
- )
- messages = result["messages"]
-
- # Verify tool message counts
- tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
- successful_tool_messages = [msg for msg in tool_messages if msg.status != "error"]
- error_tool_messages = [msg for msg in tool_messages if msg.status == "error"]
-
- assert len(successful_tool_messages) == 1, "Should have 1 successful tool message (q1)"
- assert len(error_tool_messages) == 2, "Should have 2 blocked tool messages (q2, q3)"
-
- # Verify the successful call is q1
- assert "q1" in successful_tool_messages[0].content
-
- # Verify error messages explain the limit
- for error_msg in error_tool_messages:
- assert "limit" in error_msg.content.lower()
-
- # Verify execution continued (no early termination)
- ai_messages = [msg for msg in messages if isinstance(msg, AIMessage)]
- # Should have: initial AI message with 3 tool calls, then final AI message (no tool calls)
- assert len(ai_messages) >= 2
-
-
-def test_parallel_tool_calls_with_limit_end_mode():
- """Test parallel tool calls with a limit of 1 in 'end' mode.
-
- When the model proposes 3 tool calls with a limit of 1:
- - The first call would be allowed (within limit)
- - The 2nd and 3rd calls exceed the limit and get blocked with error ToolMessages
- - Execution stops immediately (jump_to: end) so NO tools actually execute
- - An AI message explains why execution stopped
- """
-
- @tool
- def search(query: str) -> str:
- """Search for information."""
- return f"Results: {query}"
-
- # Model proposes 3 parallel search calls
- model = FakeToolCallingModel(
- tool_calls=[
- [
- ToolCall(name="search", args={"query": "q1"}, id="1"),
- ToolCall(name="search", args={"query": "q2"}, id="2"),
- ToolCall(name="search", args={"query": "q3"}, id="3"),
- ],
- [],
- ]
- )
-
- limiter = ToolCallLimitMiddleware(thread_limit=1, exit_behavior="end")
- agent = create_agent(
- model=model, tools=[search], middleware=[limiter], checkpointer=InMemorySaver()
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
- )
- messages = result["messages"]
-
- # Verify tool message counts
- # With "end" behavior, when we jump to end, NO tools execute (not even allowed ones)
- # We only get error ToolMessages for the 2 blocked calls
- tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
- successful_tool_messages = [msg for msg in tool_messages if msg.status != "error"]
- error_tool_messages = [msg for msg in tool_messages if msg.status == "error"]
-
- assert len(successful_tool_messages) == 0, "No tools execute when we jump to end"
- assert len(error_tool_messages) == 2, "Should have 2 blocked tool messages (q2, q3)"
-
- # Verify error tool messages (sent to model - include "Do not" instruction)
- for error_msg in error_tool_messages:
- assert "Tool call limit exceeded" in error_msg.content
- assert "Do not" in error_msg.content
-
- # Verify AI message explaining why execution stopped (displayed to user - includes thread/run details)
- ai_limit_messages = [
- msg
- for msg in messages
- if isinstance(msg, AIMessage) and "limit" in msg.content.lower() and not msg.tool_calls
- ]
- assert len(ai_limit_messages) == 1, "Should have exactly one AI message explaining the limit"
-
- ai_msg_content = ai_limit_messages[0].content.lower()
- assert "thread limit exceeded" in ai_msg_content or "run limit exceeded" in ai_msg_content, (
- "AI message should include thread/run limit details for the user"
- )
-
-
-def test_parallel_mixed_tool_calls_with_specific_tool_limit():
- """Test parallel calls to different tools when limiting a specific tool.
-
- When limiting 'search' to 1 call, and model proposes 3 search + 2 calculator calls:
- - First search call should execute
- - Other 2 search calls should be blocked
- - All calculator calls should execute (not limited)
- """
-
- @tool
- def search(query: str) -> str:
- """Search for information."""
- return f"Search: {query}"
-
- @tool
- def calculator(expression: str) -> str:
- """Calculate an expression."""
- return f"Calc: {expression}"
-
- model = FakeToolCallingModel(
- tool_calls=[
- [
- ToolCall(name="search", args={"query": "q1"}, id="1"),
- ToolCall(name="calculator", args={"expression": "1+1"}, id="2"),
- ToolCall(name="search", args={"query": "q2"}, id="3"),
- ToolCall(name="calculator", args={"expression": "2+2"}, id="4"),
- ToolCall(name="search", args={"query": "q3"}, id="5"),
- ],
- [],
- ]
- )
-
- search_limiter = ToolCallLimitMiddleware(
- tool_name="search", thread_limit=1, exit_behavior="continue"
- )
- agent = create_agent(
- model=model,
- tools=[search, calculator],
- middleware=[search_limiter],
- checkpointer=InMemorySaver(),
- )
-
- result = agent.invoke(
- {"messages": [HumanMessage("Test")]}, {"configurable": {"thread_id": "test"}}
- )
- messages = result["messages"]
-
- tool_messages = [msg for msg in messages if isinstance(msg, ToolMessage)]
- search_success = [m for m in tool_messages if "Search:" in m.content]
- search_blocked = [
- m for m in tool_messages if "limit" in m.content.lower() and "search" in m.content.lower()
- ]
- calc_success = [m for m in tool_messages if "Calc:" in m.content]
-
- assert len(search_success) == 1, "Should have 1 successful search call"
- assert len(search_blocked) == 2, "Should have 2 blocked search calls"
- assert len(calc_success) == 2, "All calculator calls should succeed (not limited)"
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_todo_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/test_todo_middleware.py
deleted file mode 100644
index 5f96855d4d..0000000000
--- a/libs/langchain_v1/tests/unit_tests/agents/test_todo_middleware.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Unit tests for TodoListMiddleware."""
-
-from __future__ import annotations
-
-from typing import cast
-
-from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
-from langchain_core.messages import AIMessage
-
-from langchain.agents.middleware.todo import TodoListMiddleware
-from langchain.agents.middleware.types import ModelRequest, ModelResponse
-from langgraph.runtime import Runtime
-
-
-def _fake_runtime() -> Runtime:
- return cast(Runtime, object())
-
-
-def _make_request(system_prompt: str | None = None) -> ModelRequest:
- """Create a minimal ModelRequest for testing."""
- model = GenericFakeChatModel(messages=iter([AIMessage(content="response")]))
- return ModelRequest(
- model=model,
- system_prompt=system_prompt,
- messages=[],
- tool_choice=None,
- tools=[],
- response_format=None,
- state=cast("AgentState", {}), # type: ignore[name-defined]
- runtime=_fake_runtime(),
- model_settings={},
- )
-
-
-def test_adds_system_prompt_when_none_exists() -> None:
- """Test that middleware adds system prompt when request has none."""
- middleware = TodoListMiddleware()
- request = _make_request(system_prompt=None)
-
- def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- middleware.wrap_model_call(request, mock_handler)
-
- # System prompt should be set
- assert request.system_prompt is not None
- assert "write_todos" in request.system_prompt
-
-
-def test_appends_to_existing_system_prompt() -> None:
- """Test that middleware appends to existing system prompt."""
- existing_prompt = "You are a helpful assistant."
- middleware = TodoListMiddleware()
- request = _make_request(system_prompt=existing_prompt)
-
- def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- middleware.wrap_model_call(request, mock_handler)
-
- # System prompt should contain both
- assert request.system_prompt is not None
- assert existing_prompt in request.system_prompt
- assert "write_todos" in request.system_prompt
- assert request.system_prompt.startswith(existing_prompt)
-
-
-def test_custom_system_prompt() -> None:
- """Test that middleware uses custom system prompt."""
- custom_prompt = "Custom planning instructions"
- middleware = TodoListMiddleware(system_prompt=custom_prompt)
- request = _make_request(system_prompt=None)
-
- def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- middleware.wrap_model_call(request, mock_handler)
-
- # Should use custom prompt
- assert request.system_prompt == custom_prompt
-
-
-def test_has_write_todos_tool() -> None:
- """Test that middleware registers the write_todos tool."""
- middleware = TodoListMiddleware()
-
- # Should have one tool registered
- assert len(middleware.tools) == 1
- assert middleware.tools[0].name == "write_todos"
-
-
-def test_custom_tool_description() -> None:
- """Test that middleware uses custom tool description."""
- custom_description = "Custom todo tool description"
- middleware = TodoListMiddleware(tool_description=custom_description)
-
- # Tool should use custom description
- assert len(middleware.tools) == 1
- assert middleware.tools[0].description == custom_description
-
-
-# ==============================================================================
-# Async Tests
-# ==============================================================================
-
-
-async def test_adds_system_prompt_when_none_exists_async() -> None:
- """Test async version - middleware adds system prompt when request has none."""
- middleware = TodoListMiddleware()
- request = _make_request(system_prompt=None)
-
- async def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- await middleware.awrap_model_call(request, mock_handler)
-
- # System prompt should be set
- assert request.system_prompt is not None
- assert "write_todos" in request.system_prompt
-
-
-async def test_appends_to_existing_system_prompt_async() -> None:
- """Test async version - middleware appends to existing system prompt."""
- existing_prompt = "You are a helpful assistant."
- middleware = TodoListMiddleware()
- request = _make_request(system_prompt=existing_prompt)
-
- async def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- await middleware.awrap_model_call(request, mock_handler)
-
- # System prompt should contain both
- assert request.system_prompt is not None
- assert existing_prompt in request.system_prompt
- assert "write_todos" in request.system_prompt
- assert request.system_prompt.startswith(existing_prompt)
-
-
-async def test_custom_system_prompt_async() -> None:
- """Test async version - middleware uses custom system prompt."""
- custom_prompt = "Custom planning instructions"
- middleware = TodoListMiddleware(system_prompt=custom_prompt)
- request = _make_request(system_prompt=None)
-
- async def mock_handler(req: ModelRequest) -> ModelResponse:
- return ModelResponse(result=[AIMessage(content="response")])
-
- await middleware.awrap_model_call(request, mock_handler)
-
- # Should use custom prompt
- assert request.system_prompt == custom_prompt
-
-
-async def test_handler_called_with_modified_request_async() -> None:
- """Test async version - handler receives the modified request."""
- middleware = TodoListMiddleware()
- request = _make_request(system_prompt="Original")
- handler_called = {"value": False}
- received_prompt = {"value": None}
-
- async def mock_handler(req: ModelRequest) -> ModelResponse:
- handler_called["value"] = True
- received_prompt["value"] = req.system_prompt
- return ModelResponse(result=[AIMessage(content="response")])
-
- await middleware.awrap_model_call(request, mock_handler)
-
- assert handler_called["value"]
- assert received_prompt["value"] is not None
- assert "Original" in received_prompt["value"]
- assert "write_todos" in received_prompt["value"]