The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat: refactor tests coverage (#33927)
Sydney Runkle637bb1cbbc93
diff --git a/libs/langchain_v1/Makefile b/libs/langchain_v1/Makefileindex 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.ambrnew file mode 100644index 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.ambrnew file mode 100644index 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.ambrnew file mode 100644index 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.ambrnew file mode 100644index 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__.pynew file mode 100644index 0000000000..e69de29bb2diff --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.ambrnew file mode 100644index 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.ambrnew file mode 100644index 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.ambrnew file mode 100644index 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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_composition.pydiff --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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/test_middleware_decorators.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_decorators.pyindex 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 FakeToolCallingModelclass 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.pynew file mode 100644index 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() == snapshotdiff --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.pynew file mode 100644index 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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_override_methods.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_overrides.pydiff --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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/test_sync_async_tool_wrapper_composition.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_sync_async_wrappers.pyindex 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 InMemorySaverfrom langchain.agents.factory import create_agentfrom langchain.agents.middleware.types import AgentMiddleware, wrap_tool_callfrom langchain.agents.middleware.types import ToolCallRequest-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel+from tests.unit_tests.agents.model import FakeToolCallingModel@tooldiff --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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/test_middleware_tools.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.pyindex 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, Modelfrom langgraph.prebuilt.tool_node import ToolNodefrom langchain_core.messages import AIMessage, HumanMessage, ToolMessagefrom langchain_core.tools import tool-from .model import FakeToolCallingModel+from tests.unit_tests.agents.model import FakeToolCallingModeldef 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.pysimilarity index 60%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_model_call_middleware.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_model_call.pyindex 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, Callableimport pytest+from langchain_core.language_models.chat_models import BaseChatModelfrom langchain_core.language_models.fake_chat_models import GenericFakeChatModelfrom langchain_core.messages import AIMessage, HumanMessage+from langchain_core.outputs import ChatGeneration, ChatResultfrom langchain.agents import create_agentfrom 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 = econtinue@@ -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 responseresult = 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].contentdef 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 resultexcept Exception:call_log.append("caught-error")- fallback = AIMessage(content="Recovered from error")- return fallback+ return AIMessage(content="Recovered from error")# Test 1: Success pathcall_log.clear()@@ -403,7 +501,6 @@ class TestStateAndRuntime:for attempt in range(max_retries):try:return handler(request)- break # Successexcept 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 resultassert 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 resultmodel = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))@@ -723,6 +1116,92 @@ class TestAsyncOnModelCall:assert call_count["value"] == 2assert 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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_wrap_tool_call_decorator.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_tool_call.pyindex 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 Commandfrom langchain.agents.factory import create_agentfrom langchain.agents.middleware.types import wrap_tool_callfrom langchain.agents.middleware.types import ToolCallRequest-from tests.unit_tests.agents.test_middleware_agent import FakeToolCallingModel+from tests.unit_tests.agents.model import FakeToolCallingModel@tooldiff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/__init__.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/__init__.pynew file mode 100644index 0000000000..e69de29bb2diff --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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/test_context_editing_middleware.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_context_editing.pydiff --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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_file_search.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_file_search.pydiff --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.pynew file mode 100644index 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.pynew file mode 100644index 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_msgdiff --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.pysimilarity index 71%rename from libs/langchain_v1/tests/unit_tests/agents/test_model_fallback_middleware.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_model_fallback.pyindex 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 annotationsfrom typing import castimport pytest+from langchain_core.language_models.chat_models import BaseChatModelfrom 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_agentfrom langchain.agents.middleware.model_fallback import ModelFallbackMiddlewarefrom langchain.agents.middleware.types import ModelRequest, ModelResponsefrom 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) == 2diff --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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/test_pii_middleware.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_pii.pyindex 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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_execution_policies.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_execution_policies.pydiff --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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_shell_tool.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_shell_tool.pydiff --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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_structured_output_retry.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_structured_output_retry.pydiff --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.pynew file mode 100644index 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 Nonediff --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.pynew file mode 100644index 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.pysimilarity index 77%rename from libs/langchain_v1/tests/unit_tests/agents/test_tool_call_limit.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_call_limit.pyindex 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 FakeToolCallingModeldef 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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_emulator.pydiff --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.pysimilarity index 99%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_retry.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_retry.pyindex 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 InMemorySaverfrom langchain.agents.factory import create_agentfrom 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@tooldiff --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.pysimilarity index 100%rename from libs/langchain_v1/tests/unit_tests/agents/middleware/test_llm_tool_selection.pyrename to libs/langchain_v1/tests/unit_tests/agents/middleware/implementations/test_tool_selection.pydiff --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.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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].contentdiff --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.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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"]