fix: adjust **kwargs in multiagent primitives

Author: JackYPCOnline

src/strands/multiagent/base.py

@@ -4,6 +4,7 @@
 """
 
 import asyncio
+import warnings
 from abc import ABC, abstractmethod
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
@@ -85,15 +86,14 @@ class MultiAgentBase(ABC):
 
     @abstractmethod
     async def invoke_async(
-        self, task: str | list[ContentBlock], invocation_state: dict[str, Any] | None = None, **kwargs: Any
+        self, task: str | list[ContentBlock], invocation_state: dict[str, Any] | None = None
     ) -> MultiAgentResult:
         """Invoke asynchronously.
 
         Args:
             task: The task to execute
             invocation_state: Additional state/context passed to underlying agents.
                 Defaults to None to avoid mutable default argument issues.
-            **kwargs: Additional keyword arguments passed to underlying agents.
         """
         raise NotImplementedError("invoke_async not implemented")
 
@@ -111,8 +111,12 @@ def __call__(
         if invocation_state is None:
             invocation_state = {}
 
+        if kwargs:
+            invocation_state.update(kwargs)
+            warnings.warn("`**kwargs` parameter is deprecating, use `invocation_state` instead.", stacklevel=2)
+
         def execute() -> MultiAgentResult:
-            return asyncio.run(self.invoke_async(task, invocation_state, **kwargs))
+            return asyncio.run(self.invoke_async(task, invocation_state))
 
         with ThreadPoolExecutor() as executor:
             future = executor.submit(execute)

src/strands/multiagent/graph.py

@@ -572,11 +572,11 @@ async def _execute_node(self, node: GraphNode, invocation_state: dict[str, Any])
                 elif isinstance(node.executor, Agent):
                     if self.node_timeout is not None:
                         agent_response = await asyncio.wait_for(
-                            node.executor.invoke_async(node_input, **invocation_state),
+                            node.executor.invoke_async(node_input, invocation_state=invocation_state),
                             timeout=self.node_timeout,
                         )
                     else:
-                        agent_response = await node.executor.invoke_async(node_input, **invocation_state)
+                        agent_response = await node.executor.invoke_async(node_input, invocation_state=invocation_state)
 
                     # Extract metrics from agent response
                     usage = Usage(inputTokens=0, outputTokens=0, totalTokens=0)

src/strands/multiagent/swarm.py

@@ -635,8 +635,7 @@ async def _execute_node(
             # Execute node
             result = None
             node.reset_executor_state()
-            # Unpacking since this is the agent class. Other executors should not unpack
-            result = await node.executor.invoke_async(node_input, **invocation_state)
+            result = await node.executor.invoke_async(node_input, invocation_state=invocation_state)
 
             execution_time = round((time.time() - start_time) * 1000)
 

tests/strands/multiagent/test_base.py

@@ -153,23 +153,23 @@ class TestMultiAgent(MultiAgentBase):
         def __init__(self):
             self.invoke_async_called = False
             self.received_task = None
-            self.received_kwargs = None
+            self.received_invocation_state = None
 
-        async def invoke_async(self, task, invocation_state, **kwargs):
+        async def invoke_async(self, task, invocation_state=None):
             self.invoke_async_called = True
             self.received_task = task
-            self.received_kwargs = kwargs
+            self.received_invocation_state = invocation_state
             return MultiAgentResult(
                 status=Status.COMPLETED, results={"test": NodeResult(result=Exception("test"), status=Status.COMPLETED)}
             )
 
     agent = TestMultiAgent()
 
     # Test with string task
-    result = agent("test task", param1="value1", param2="value2")
+    result = agent("test task", param1="value1", param2="value2", invocation_state={"value3": "value4"})
 
     assert agent.invoke_async_called
     assert agent.received_task == "test task"
-    assert agent.received_kwargs == {"param1": "value1", "param2": "value2"}
+    assert agent.received_invocation_state == {"param1": "value1", "param2": "value2", "value3": "value4"}
     assert isinstance(result, MultiAgentResult)
     assert result.status == Status.COMPLETED

tests/strands/multiagent/test_graph.py

@@ -310,7 +310,7 @@ async def test_graph_edge_cases(mock_strands_tracer, mock_use_span):
     result = await graph.invoke_async([{"text": "Original task"}])
 
     # Verify entry node was called with original task
-    entry_agent.invoke_async.assert_called_once_with([{"text": "Original task"}])
+    entry_agent.invoke_async.assert_called_once_with([{"text": "Original task"}], invocation_state={})
     assert result.status == Status.COMPLETED
     mock_strands_tracer.start_multiagent_span.assert_called()
     mock_use_span.assert_called_once()
@@ -906,7 +906,7 @@ def __init__(self, name):
             self._session_manager = None
             self.hooks = HookRegistry()
 
-        async def invoke_async(self, input_data):
+        async def invoke_async(self, input_data, invocation_state=None):
             # Increment execution count in state
             count = self.state.get("execution_count") or 0
             self.state.set("execution_count", count + 1)
@@ -1300,7 +1300,9 @@ async def test_graph_kwargs_passing_agent(mock_strands_tracer, mock_use_span):
     test_invocation_state = {"custom_param": "test_value", "another_param": 42}
     result = await graph.invoke_async("Test kwargs passing", test_invocation_state)
 
-    kwargs_agent.invoke_async.assert_called_once_with([{"text": "Test kwargs passing"}], **test_invocation_state)
+    kwargs_agent.invoke_async.assert_called_once_with(
+        [{"text": "Test kwargs passing"}], invocation_state=test_invocation_state
+    )
     assert result.status == Status.COMPLETED
 
 
@@ -1335,5 +1337,7 @@ def test_graph_kwargs_passing_sync(mock_strands_tracer, mock_use_span):
     test_invocation_state = {"custom_param": "test_value", "another_param": 42}
     result = graph("Test kwargs passing sync", test_invocation_state)
 
-    kwargs_agent.invoke_async.assert_called_once_with([{"text": "Test kwargs passing sync"}], **test_invocation_state)
+    kwargs_agent.invoke_async.assert_called_once_with(
+        [{"text": "Test kwargs passing sync"}], invocation_state=test_invocation_state
+    )
     assert result.status == Status.COMPLETED

tests/strands/multiagent/test_swarm.py

@@ -558,7 +558,7 @@ async def test_swarm_kwargs_passing(mock_strands_tracer, mock_use_span):
     test_kwargs = {"custom_param": "test_value", "another_param": 42}
     result = await swarm.invoke_async("Test kwargs passing", test_kwargs)
 
-    assert kwargs_agent.invoke_async.call_args.kwargs == test_kwargs
+    assert kwargs_agent.invoke_async.call_args.kwargs == {"invocation_state": test_kwargs}
     assert result.status == Status.COMPLETED
 
 
@@ -572,5 +572,5 @@ def test_swarm_kwargs_passing_sync(mock_strands_tracer, mock_use_span):
     test_kwargs = {"custom_param": "test_value", "another_param": 42}
     result = swarm("Test kwargs passing sync", test_kwargs)
 
-    assert kwargs_agent.invoke_async.call_args.kwargs == test_kwargs
+    assert kwargs_agent.invoke_async.call_args.kwargs == {"invocation_state": test_kwargs}
     assert result.status == Status.COMPLETED