Merge branch 'strands-agents:main' into main

Author: aditya270520

pyproject.toml

@@ -68,9 +68,8 @@ docs = [
     "sphinx-autodoc-typehints>=1.12.0,<2.0.0",
 ]
 litellm = [
-    "litellm>=1.73.1,<2.0.0",
-    # https://github.com/BerriAI/litellm/issues/13711
-    "openai<1.100.0",
+    "litellm>=1.75.9,<2.0.0",
+    "openai>=1.68.0,<1.102.0",
 ]
 llamaapi = [
     "llama-api-client>=0.1.0,<1.0.0",

src/strands/event_loop/streaming.py

@@ -289,7 +289,6 @@ async def process_stream(chunks: AsyncIterable[StreamEvent]) -> AsyncGenerator[T
         "text": "",
         "current_tool_use": {},
         "reasoningText": "",
-        "signature": "",
         "citationsContent": [],
     }
     state["content"] = state["message"]["content"]

src/strands/models/bedrock.py

@@ -37,6 +37,11 @@
     "too many total text bytes",
 ]
 
+# Models that should include tool result status (include_tool_result_status = True)
+_MODELS_INCLUDE_STATUS = [
+    "anthropic.claude",
+]
+
 T = TypeVar("T", bound=BaseModel)
 
 
@@ -71,6 +76,8 @@ class BedrockConfig(TypedDict, total=False):
             guardrail_redact_output_message: If a Bedrock Output guardrail triggers, replace output with this message.
             max_tokens: Maximum number of tokens to generate in the response
             model_id: The Bedrock model ID (e.g., "us.anthropic.claude-sonnet-4-20250514-v1:0")
+            include_tool_result_status: Flag to include status field in tool results.
+                True includes status, False removes status, "auto" determines based on model_id. Defaults to "auto".
             stop_sequences: List of sequences that will stop generation when encountered
             streaming: Flag to enable/disable streaming. Defaults to True.
             temperature: Controls randomness in generation (higher = more random)
@@ -92,6 +99,7 @@ class BedrockConfig(TypedDict, total=False):
         guardrail_redact_output_message: Optional[str]
         max_tokens: Optional[int]
         model_id: str
+        include_tool_result_status: Optional[Literal["auto"] | bool]
         stop_sequences: Optional[list[str]]
         streaming: Optional[bool]
         temperature: Optional[float]
@@ -119,7 +127,7 @@ def __init__(
         if region_name and boto_session:
             raise ValueError("Cannot specify both `region_name` and `boto_session`.")
 
-        self.config = BedrockModel.BedrockConfig(model_id=DEFAULT_BEDROCK_MODEL_ID)
+        self.config = BedrockModel.BedrockConfig(model_id=DEFAULT_BEDROCK_MODEL_ID, include_tool_result_status="auto")
         self.update_config(**model_config)
 
         logger.debug("config=<%s> | initializing", self.config)
@@ -169,6 +177,17 @@ def get_config(self) -> BedrockConfig:
         """
         return self.config
 
+    def _should_include_tool_result_status(self) -> bool:
+        """Determine whether to include tool result status based on current config."""
+        include_status = self.config.get("include_tool_result_status", "auto")
+
+        if include_status is True:
+            return True
+        elif include_status is False:
+            return False
+        else:  # "auto"
+            return any(model in self.config["model_id"] for model in _MODELS_INCLUDE_STATUS)
+
     def format_request(
         self,
         messages: Messages,
@@ -256,6 +275,7 @@ def _format_bedrock_messages(self, messages: Messages) -> Messages:
         """Format messages for Bedrock API compatibility.
 
         This function ensures messages conform to Bedrock's expected format by:
+        - Filtering out SDK_UNKNOWN_MEMBER content blocks
         - Cleaning tool result content blocks by removing additional fields that may be
           useful for retaining information in hooks but would cause Bedrock validation
           exceptions when presented with unexpected fields
@@ -273,19 +293,33 @@ def _format_bedrock_messages(self, messages: Messages) -> Messages:
             https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ToolResultBlock.html
         """
         cleaned_messages = []
+        filtered_unknown_members = False
 
         for message in messages:
             cleaned_content: list[ContentBlock] = []
 
             for content_block in message["content"]:
+                # Filter out SDK_UNKNOWN_MEMBER content blocks
+                if "SDK_UNKNOWN_MEMBER" in content_block:
+                    filtered_unknown_members = True
+                    continue
+
                 if "toolResult" in content_block:
                     # Create a new content block with only the cleaned toolResult
                     tool_result: ToolResult = content_block["toolResult"]
 
-                    # Keep only the required fields for Bedrock
-                    cleaned_tool_result = ToolResult(
-                        content=tool_result["content"], toolUseId=tool_result["toolUseId"], status=tool_result["status"]
-                    )
+                    if self._should_include_tool_result_status():
+                        # Include status field
+                        cleaned_tool_result = ToolResult(
+                            content=tool_result["content"],
+                            toolUseId=tool_result["toolUseId"],
+                            status=tool_result["status"],
+                        )
+                    else:
+                        # Remove status field
+                        cleaned_tool_result = ToolResult(  # type: ignore[typeddict-item]
+                            toolUseId=tool_result["toolUseId"], content=tool_result["content"]
+                        )
 
                     cleaned_block: ContentBlock = {"toolResult": cleaned_tool_result}
                     cleaned_content.append(cleaned_block)
@@ -297,6 +331,11 @@ def _format_bedrock_messages(self, messages: Messages) -> Messages:
             cleaned_message: Message = Message(content=cleaned_content, role=message["role"])
             cleaned_messages.append(cleaned_message)
 
+        if filtered_unknown_members:
+            logger.warning(
+                "Filtered out SDK_UNKNOWN_MEMBER content blocks from messages, consider upgrading boto3 version"
+            )
+
         return cleaned_messages
 
     def _has_blocked_guardrail(self, guardrail_data: dict[str, Any]) -> bool:

src/strands/types/_events.py

@@ -275,24 +275,19 @@ def is_callback_event(self) -> bool:
 class ToolStreamEvent(TypedEvent):
     """Event emitted when a tool yields sub-events as part of tool execution."""
 
-    def __init__(self, tool_use: ToolUse, tool_sub_event: Any) -> None:
+    def __init__(self, tool_use: ToolUse, tool_stream_data: Any) -> None:
         """Initialize with tool streaming data.
 
         Args:
             tool_use: The tool invocation producing the stream
-            tool_sub_event: The yielded event from the tool execution
+            tool_stream_data: The yielded event from the tool execution
         """
-        super().__init__({"tool_stream_tool_use": tool_use, "tool_stream_event": tool_sub_event})
+        super().__init__({"tool_stream_event": {"tool_use": tool_use, "data": tool_stream_data}})
 
     @property
     def tool_use_id(self) -> str:
         """The toolUseId associated with this stream."""
-        return cast(str, cast(ToolUse, self.get("tool_stream_tool_use")).get("toolUseId"))
-
-    @property
-    @override
-    def is_callback_event(self) -> bool:
-        return False
+        return cast(str, cast(ToolUse, cast(dict, self.get("tool_stream_event")).get("tool_use")).get("toolUseId"))
 
 
 class ModelMessageEvent(TypedEvent):

tests/strands/agent/hooks/test_agent_events.py

@@ -260,18 +260,22 @@ async def test_stream_e2e_success(alist):
                 "role": "assistant",
             }
         },
+        {
+            "tool_stream_event": {
+                "data": {"tool_streaming": True},
+                "tool_use": {"input": {}, "name": "streaming_tool", "toolUseId": "12345"},
+            }
+        },
+        {
+            "tool_stream_event": {
+                "data": "Final result",
+                "tool_use": {"input": {}, "name": "streaming_tool", "toolUseId": "12345"},
+            }
+        },
         {
             "message": {
                 "content": [
-                    {
-                        "toolResult": {
-                            # TODO update this text when we get tool streaming implemented; right now this
-                            # TODO is of the form '<async_generator object streaming_tool at 0x107d18a00>'
-                            "content": [{"text": ANY}],
-                            "status": "success",
-                            "toolUseId": "12345",
-                        }
-                    },
+                    {"toolResult": {"content": [{"text": "Final result"}], "status": "success", "toolUseId": "12345"}}
                 ],
                 "role": "user",
             }

tests/strands/event_loop/test_streaming.py

@@ -1,10 +1,12 @@
 import unittest.mock
+from typing import cast
 
 import pytest
 
 import strands
 import strands.event_loop
-from strands.types._events import TypedEvent
+from strands.types._events import ModelStopReason, TypedEvent
+from strands.types.content import Message
 from strands.types.streaming import (
     ContentBlockDeltaEvent,
     ContentBlockStartEvent,
@@ -565,6 +567,88 @@ async def test_process_stream(response, exp_events, agenerator, alist):
     assert non_typed_events == []
 
 
+def _get_message_from_event(event: ModelStopReason) -> Message:
+    return cast(Message, event["stop"][1])
+
+
+@pytest.mark.asyncio
+async def test_process_stream_with_no_signature(agenerator, alist):
+    response = [
+        {"messageStart": {"role": "assistant"}},
+        {
+            "contentBlockDelta": {
+                "delta": {"reasoningContent": {"text": 'User asks: "Reason about 2+2" so I will do that'}},
+                "contentBlockIndex": 0,
+            }
+        },
+        {"contentBlockDelta": {"delta": {"reasoningContent": {"text": "."}}, "contentBlockIndex": 0}},
+        {"contentBlockStop": {"contentBlockIndex": 0}},
+        {
+            "contentBlockDelta": {
+                "delta": {"text": "Sure! Let’s do it"},
+                "contentBlockIndex": 1,
+            }
+        },
+        {"contentBlockStop": {"contentBlockIndex": 1}},
+        {"messageStop": {"stopReason": "end_turn"}},
+        {
+            "metadata": {
+                "usage": {"inputTokens": 112, "outputTokens": 764, "totalTokens": 876},
+                "metrics": {"latencyMs": 2970},
+            }
+        },
+    ]
+
+    stream = strands.event_loop.streaming.process_stream(agenerator(response))
+
+    last_event = cast(ModelStopReason, (await alist(stream))[-1])
+
+    message = _get_message_from_event(last_event)
+
+    assert "signature" not in message["content"][0]["reasoningContent"]["reasoningText"]
+    assert message["content"][1]["text"] == "Sure! Let’s do it"
+
+
+@pytest.mark.asyncio
+async def test_process_stream_with_signature(agenerator, alist):
+    response = [
+        {"messageStart": {"role": "assistant"}},
+        {
+            "contentBlockDelta": {
+                "delta": {"reasoningContent": {"text": 'User asks: "Reason about 2+2" so I will do that'}},
+                "contentBlockIndex": 0,
+            }
+        },
+        {"contentBlockDelta": {"delta": {"reasoningContent": {"text": "."}}, "contentBlockIndex": 0}},
+        {"contentBlockDelta": {"delta": {"reasoningContent": {"signature": "test-"}}, "contentBlockIndex": 0}},
+        {"contentBlockDelta": {"delta": {"reasoningContent": {"signature": "signature"}}, "contentBlockIndex": 0}},
+        {"contentBlockStop": {"contentBlockIndex": 0}},
+        {
+            "contentBlockDelta": {
+                "delta": {"text": "Sure! Let’s do it"},
+                "contentBlockIndex": 1,
+            }
+        },
+        {"contentBlockStop": {"contentBlockIndex": 1}},
+        {"messageStop": {"stopReason": "end_turn"}},
+        {
+            "metadata": {
+                "usage": {"inputTokens": 112, "outputTokens": 764, "totalTokens": 876},
+                "metrics": {"latencyMs": 2970},
+            }
+        },
+    ]
+
+    stream = strands.event_loop.streaming.process_stream(agenerator(response))
+
+    last_event = cast(ModelStopReason, (await alist(stream))[-1])
+
+    message = _get_message_from_event(last_event)
+
+    assert message["content"][0]["reasoningContent"]["reasoningText"]["signature"] == "test-signature"
+    assert message["content"][1]["text"] == "Sure! Let’s do it"
+
+
 @pytest.mark.asyncio
 async def test_stream_messages(agenerator, alist):
     mock_model = unittest.mock.MagicMock()