agent-builder-sdk-aws-transform 1.0.2__tar.gz → 1.1.0__tar.gz

{agent_builder_sdk_aws_transform-1.0.2/src/agent_builder_sdk_aws_transform.egg-info → agent_builder_sdk_aws_transform-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-builder-sdk-aws-transform
-Version: 1.0.2
+Version: 1.1.0
 Summary: Base agent SDK for building orchestrator and subagents on AWS Transform
 Author: AWS Transform Team
 License-Expression: Apache-2.0
@@ -14,12 +14,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: NOTICE
 License-File: THIRD-PARTY-NOTICES.txt
-Requires-Dist: agent-builder-types-aws-transform>=1.0
+Requires-Dist: agent-builder-types-aws-transform>=1.1
 Requires-Dist: agent-builder-mcp-client-aws-transform>=1.0
 Requires-Dist: boto3>=1.28
 Requires-Dist: botocore>=1.28
 Requires-Dist: fastapi>=0.100
-Requires-Dist: mcp>=1.0
+Requires-Dist: mcp<2.0,>=1.0
 Requires-Dist: strands-agents>=1.30.0
 Requires-Dist: strands-agents-tools>=0.2
 Requires-Dist: uvicorn>=0.20
@@ -27,6 +27,9 @@ Requires-Dist: structlog
 Requires-Dist: starlette_context
 Requires-Dist: defusedxml
 Requires-Dist: aws-embedded-metrics>=3.0
+Requires-Dist: tenacity>=9.0
+Requires-Dist: a2a-sdk<0.4,>=0.3.7
+Requires-Dist: ag-ui-protocol<0.2,>=0.1.19
 Provides-Extra: full
 Requires-Dist: agent-builder-agentic-mcp-aws-transform>=1.0; extra == "full"
 Requires-Dist: agent-builder-mcp-aws-transform>=1.0; extra == "full"
@@ -184,6 +187,43 @@ if __name__ == "__main__":
     main()
 ```
 
+## Streaming (opt-in)
+
+By default an orchestrator serves one turn at a time through a buffered queue, and `message/stream` is rejected. Pass a `StreamingConfig` to stream turns live over SSE (reasoning, tool calls and text) and to serve many users of the same job concurrently:
+
+```python
+from agent_builder_sdk.streaming.config import StreamingConfig
+
+server = AgentRuntimeServer(
+    agent_factory=agent_factory,
+    host="0.0.0.0",
+    port=8080,
+    binary_location="agent-builder-agentic-mcp",
+    storage_dir="/tmp/my_agent",
+    # Omit or pass None to keep streaming off (the default).
+    streaming_config=StreamingConfig(
+        agent_idle_ttl_seconds=30 * 60,  # optional; evict idle per-user agents
+        emit_reasoning=True,             # optional; stream and persist reasoning (default True)
+        emit_tool_calls=True,            # optional; stream and persist tool calls (default True)
+    ),
+)
+```
+
+The `simple_cli_agent_core.py` entry point exposes the same option as `--concurrent-streaming` (plus `--emit-reasoning/--no-emit-reasoning` and `--emit-tool-calls/--no-emit-tool-calls`). AWS Transform only streams to agents whose agent card declares `capabilities.streaming: true`.
+
+**How it works**: Strands runs one invocation at a time per `Agent`, so the server keeps a `StreamingAgentPool` with one agent per source (a user, or another agent that streams to yours). Agents are built on first use and evicted after `agent_idle_ttl_seconds`. Your factory runs once per source, so each pooled agent builds its own model client. The MCP client, the conversation repository and the `MemoryManager` stay shared, so a user's buffered and streamed turns see the same job history. A synchronous factory runs on a dedicated worker thread, one build at a time, so building a new user's agent does not stall live streams; it has no running event loop there. Each streamed final response is persisted back to the chat.
+
+**Concurrency contract**: with streaming on, several users' turns run concurrently on one event loop. Tools and hooks must not keep per-request state in module-level or class-level mutable globals; use a `contextvars.ContextVar` or the per-request `ToolContext` / `invocation_state` instead.
+
+**Factory requirement**: your agent factory must accept and forward `conversation_repository` and `memory_manager` (for example `def agent_factory(mcp_client, storage_dir, **kwargs)` passing both to `create_default_orchestrator`). The server checks this at startup.
+
+**Subagents**: an agent that inherits `StreamingCapable` can stream too (`simple_subagent_cli.py --concurrent-streaming` builds one). Two opt-in tools, added through `custom_tools`, use a subagent's stream:
+
+- `send_message_to_subagent_and_relay` streams the subagent's answer live to the user as the orchestrator's final answer, and ends the turn.
+- `stream_message_to_subagent` returns the subagent's answer (its last model cycle) to the orchestrator without streaming it to the user, like `send_message_to_subagent`.
+
+**History repair**: when a turn is interrupted (timeout, client disconnect, crash), the next history load gives the unanswered message a placeholder reply, so the next turn answers its own prompt. A turn ended by a terminating tool (`stop_event_loop`) stores its `force_stop_response` as the reply.
+
 ## Requirements
 
 - Python 3.11+

{agent_builder_sdk_aws_transform-1.0.2 → agent_builder_sdk_aws_transform-1.1.0}/README.md

@@ -147,6 +147,43 @@ if __name__ == "__main__":
     main()
 ```
 
+## Streaming (opt-in)
+
+By default an orchestrator serves one turn at a time through a buffered queue, and `message/stream` is rejected. Pass a `StreamingConfig` to stream turns live over SSE (reasoning, tool calls and text) and to serve many users of the same job concurrently:
+
+```python
+from agent_builder_sdk.streaming.config import StreamingConfig
+
+server = AgentRuntimeServer(
+    agent_factory=agent_factory,
+    host="0.0.0.0",
+    port=8080,
+    binary_location="agent-builder-agentic-mcp",
+    storage_dir="/tmp/my_agent",
+    # Omit or pass None to keep streaming off (the default).
+    streaming_config=StreamingConfig(
+        agent_idle_ttl_seconds=30 * 60,  # optional; evict idle per-user agents
+        emit_reasoning=True,             # optional; stream and persist reasoning (default True)
+        emit_tool_calls=True,            # optional; stream and persist tool calls (default True)
+    ),
+)
+```
+
+The `simple_cli_agent_core.py` entry point exposes the same option as `--concurrent-streaming` (plus `--emit-reasoning/--no-emit-reasoning` and `--emit-tool-calls/--no-emit-tool-calls`). AWS Transform only streams to agents whose agent card declares `capabilities.streaming: true`.
+
+**How it works**: Strands runs one invocation at a time per `Agent`, so the server keeps a `StreamingAgentPool` with one agent per source (a user, or another agent that streams to yours). Agents are built on first use and evicted after `agent_idle_ttl_seconds`. Your factory runs once per source, so each pooled agent builds its own model client. The MCP client, the conversation repository and the `MemoryManager` stay shared, so a user's buffered and streamed turns see the same job history. A synchronous factory runs on a dedicated worker thread, one build at a time, so building a new user's agent does not stall live streams; it has no running event loop there. Each streamed final response is persisted back to the chat.
+
+**Concurrency contract**: with streaming on, several users' turns run concurrently on one event loop. Tools and hooks must not keep per-request state in module-level or class-level mutable globals; use a `contextvars.ContextVar` or the per-request `ToolContext` / `invocation_state` instead.
+
+**Factory requirement**: your agent factory must accept and forward `conversation_repository` and `memory_manager` (for example `def agent_factory(mcp_client, storage_dir, **kwargs)` passing both to `create_default_orchestrator`). The server checks this at startup.
+
+**Subagents**: an agent that inherits `StreamingCapable` can stream too (`simple_subagent_cli.py --concurrent-streaming` builds one). Two opt-in tools, added through `custom_tools`, use a subagent's stream:
+
+- `send_message_to_subagent_and_relay` streams the subagent's answer live to the user as the orchestrator's final answer, and ends the turn.
+- `stream_message_to_subagent` returns the subagent's answer (its last model cycle) to the orchestrator without streaming it to the user, like `send_message_to_subagent`.
+
+**History repair**: when a turn is interrupted (timeout, client disconnect, crash), the next history load gives the unanswered message a placeholder reply, so the next turn answers its own prompt. A turn ended by a terminating tool (`stop_event_loop`) stores its `force_stop_response` as the reply.
+
 ## Requirements
 
 - Python 3.11+

{agent_builder_sdk_aws_transform-1.0.2 → agent_builder_sdk_aws_transform-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-builder-sdk-aws-transform"
-version = "1.0.2"
+version = "1.1.0"
 description = "Base agent SDK for building orchestrator and subagents on AWS Transform"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
@@ -19,12 +19,14 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "agent-builder-types-aws-transform>=1.0",
+    "agent-builder-types-aws-transform>=1.1",
     "agent-builder-mcp-client-aws-transform>=1.0",
     "boto3>=1.28",
     "botocore>=1.28",
     "fastapi>=0.100",
-    "mcp>=1.0",
+    # Pin to the mcp 1.x major the toolkit is tested against; mcp 2.0.0 is a
+    # breaking release (see issue #77). Widen once verified against 2.x.
+    "mcp>=1.0,<2.0",
     "strands-agents>=1.30.0",
     "strands-agents-tools>=0.2",
     "uvicorn>=0.20",
@@ -32,6 +34,10 @@ dependencies = [
     "starlette_context",
     "defusedxml",
     "aws-embedded-metrics>=3.0",
+    "tenacity>=9.0",
+    # Streaming: A2A task states and AG-UI events. Both are pre-1.0, so stay on the tested minor.
+    "a2a-sdk>=0.3.7,<0.4",
+    "ag-ui-protocol>=0.1.19,<0.2",
 ]
 
 [project.optional-dependencies]

{agent_builder_sdk_aws_transform-1.0.2 → agent_builder_sdk_aws_transform-1.1.0}/src/agent_builder_sdk/_auth_token_refresher.py

@@ -4,6 +4,7 @@ import datetime
 import functools
 import logging
 import os
+import signal
 import time
 from multiprocessing import Process
 from typing import TYPE_CHECKING, Any, Dict, Optional
@@ -11,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Dict, Optional
 from botocore.client import BaseClient
 
 from agent_builder_sdk.agentic_framework.api_model import AgenticApiRequestContext
-from agent_builder_sdk.agentic_framework.client_factory import get_agentic_api_client
+from agent_builder_sdk.agentic_framework.client_factory import create_agentic_api_client
 from agent_builder_sdk.env_var import (
     ATX_AUTH_TOKEN_KEY,
     ENV_KEY_AUTH_TOKEN_FILE,
@@ -33,6 +34,7 @@ DEFAULT_SESSION_DURATION = 43200  # 12 hours
 
 # Token refresh timing constants (in seconds)
 TOKEN_REFRESH_BUFFER_SECONDS = 40  # Buffer before token expiration to refresh
+SAFETY_FACTOR = 0.5  # Refresh at 50% of token lifetime for hours of retry headroom
 MIN_SLEEP_SECONDS = 60  # Minimum sleep time between refresh attempts
 ERROR_RETRY_SECONDS = 60  # Retry interval when refresh fails
 
@@ -126,19 +128,36 @@ class AuthTokenRefresher:
         Main function for the token refresh process.
         Continuously refreshes the token and sleeps until next refresh.
         """
+        # Forked from the runtime process, this child inherits the parent's SIGTERM
+        # handler (the server's graceful-shutdown handler), which never terminates this
+        # stateless refresher. Restore the default disposition so Process.terminate()
+        # ends it immediately, instead of the parent waiting out the join timeout before
+        # falling back to SIGKILL — that wait added ~5s to every agent stop.
+        signal.signal(signal.SIGTERM, signal.SIG_DFL)
+
+        # Configure logging in the child process so logs are captured by
+        # the container log driver (CloudWatch).
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            force=True,
+        )
+
         logger.info("Starting token refresh process")
 
-        try:
-            while True:
+        while True:
+            try:
                 time_to_sleep = self._refresh_token()
                 logger.info(f"Sleeping for {time_to_sleep} seconds before next token refresh")
                 time.sleep(time_to_sleep)
-        except KeyboardInterrupt:
-            logger.info("Token refresh process interrupted, shutting down gracefully")
-        except Exception:
-            logger.warning("Token refresh process error: ", exc_info=True)
-        finally:
-            logger.info("Token refresh process stopped")
+            except KeyboardInterrupt:
+                logger.info("Token refresh process interrupted, shutting down gracefully")
+                break
+            except Exception:
+                logger.warning("Token refresh process error, retrying: ", exc_info=True)
+                time.sleep(ERROR_RETRY_SECONDS)
+
+        logger.info("Token refresh process stopped")
 
     def _refresh_token(self) -> int:
         """
@@ -165,7 +184,11 @@ class AuthTokenRefresher:
             now = datetime.datetime.now(datetime.timezone.utc)
 
             # Calculate time difference in seconds, with a buffer to refresh before token expires
-            time_diff = (expiration_timestamp - now).total_seconds() - self.token_refresh_buffer
+            remaining = (expiration_timestamp - now).total_seconds()
+            time_diff = min(
+                remaining * SAFETY_FACTOR,
+                remaining - self.token_refresh_buffer,
+            )
 
             # Ensure we don't sleep for a negative amount of time
             # and that we have at least minimum sleep time between refreshes
@@ -204,10 +227,15 @@ class AuthTokenRefresher:
         """
         logger.info("Calling Agentic API to refresh token")
 
-        # Create client if it doesn't exist (lazy initialization to avoid pickling issues)
+        # Build a fresh, uncached client inside the child process. boto3 clients
+        # are not fork-safe (shared urllib3 connection pools / OpenSSL state can
+        # corrupt requests between parent and child), and the parent populates
+        # the module-level lru_cache before the fork — so calling the cached
+        # factory here would hand back the parent's client. See
+        # https://docs.aws.amazon.com/boto3/latest/guide/clients.html#caveats
         if self.agentic_api_client is None:
             logger.info("Creating agentic API client in child process")
-            self.agentic_api_client = get_agentic_api_client()
+            self.agentic_api_client = create_agentic_api_client()
 
         if not all([self.workspace_id, self.job_id, self.agent_instance_id]):
             context = get_agent_context_from_env()

{agent_builder_sdk_aws_transform-1.0.2 → agent_builder_sdk_aws_transform-1.1.0}/src/agent_builder_sdk/agent_factory.py

@@ -8,6 +8,8 @@ import logging
 import os
 from typing import Any, Optional, Set, TypeVar, Union
 
+from botocore.config import Config as BotocoreConfig
+from strands.hooks import HookProvider
 from strands.models.model import Model
 from strands.tools.mcp.mcp_client import MCPClient
 
@@ -23,6 +25,9 @@ from agent_builder_sdk.orchestrator_strands.base_orchestrator import (
 from agent_builder_sdk.orchestrator_strands.conversation.file_repository import (
     FileMultiSourceConversationRepository,
 )
+from agent_builder_sdk.orchestrator_strands.hooks.blank_reply_hook_provider import (
+    BlankReplyHookProvider,
+)
 from agent_builder_sdk.orchestrator_strands.hooks.conversation_hook_provider import (
     ConversationHookProvider,
 )
@@ -52,6 +57,7 @@ def _create_default_orchestrator(
     additional_custom_tools: Optional[list[Any]] = None,
     model_id: str = "anthropic.claude-sonnet-4-5-20250929-v1:0",
     model: Union[Model, str, None] = None,
+    boto_client_config: Optional[BotocoreConfig] = None,
     with_base_guardrails: bool = False,
     trace_attributes: Optional[dict[str, Any]] = None,
     excluded_mcp_tool_names: Optional[Set[str]] = None,
@@ -59,16 +65,27 @@ def _create_default_orchestrator(
     enable_skills: bool = False,
     skills_dir: Optional[str] = None,
     enable_code_execution: bool = False,
+    enable_blank_reply_continuation: bool = False,
+    enable_prompt_caching: bool = False,
+    locale: Optional[str] = None,
+    conversation_repository: Optional[FileMultiSourceConversationRepository] = None,
+    memory_manager: Optional[MemoryManager] = None,
 ) -> OrchestratorT:
     logger.info("Creating default orchestrator with full feature set")
 
     custom_tools: list[Any] = []
 
-    # Create memory components
-    memory_storage_path = os.path.join(storage_dir, "memories")
-    repository = FileSystemRepository(storage_path=memory_storage_path)
-    episodic_memory = EpisodicMemory(repository=repository)
-    memory_manager = MemoryManager(memories=[episodic_memory])
+    # Create memory components. A shared MemoryManager may be injected (e.g. for concurrent
+    # streaming, so the shared singleton agent and per-user streaming agents use the SAME memory
+    # store for a job — otherwise each agent derives its own <storage_dir>/memories and the same
+    # job's message/send vs message/stream turns read/write disjoint stores). Memory is
+    # job-scoped (the same behavior as the existing shared singleton agent). When not injected,
+    # build a per-agent one as before (backward compatible).
+    if memory_manager is None:
+        memory_storage_path = os.path.join(storage_dir, "memories")
+        repository = FileSystemRepository(storage_path=memory_storage_path)
+        episodic_memory = EpisodicMemory(repository=repository)
+        memory_manager = MemoryManager(memories=[episodic_memory])
 
     # Create memory tool
     memory_tool = MemoryTool(memory_manager)
@@ -103,14 +120,20 @@ def _create_default_orchestrator(
     if additional_custom_tools:
         custom_tools.extend(additional_custom_tools)
 
-    # Create conversation repository
-    conversation_repository = FileMultiSourceConversationRepository(storage_dir=storage_dir)
+    # Create conversation repository. A shared instance may be injected (e.g. for
+    # concurrent streaming, where per-user agents must all read/write the SAME history
+    # store — separate instances on one storage_dir would overwrite each other's saves).
+    # When not injected, build a per-agent one as before (backward compatible).
+    if conversation_repository is None:
+        conversation_repository = FileMultiSourceConversationRepository(storage_dir=storage_dir)
 
     # Create hooks
-    hooks = [
+    hooks: list[HookProvider] = [
         ConversationHookProvider(repository=conversation_repository),
         MemoryHookProvider(memory_manager=memory_manager),
     ]
+    if enable_blank_reply_continuation:
+        hooks.append(BlankReplyHookProvider())
 
     # Use provided system prompt or default
     if system_prompt is None:
@@ -130,10 +153,13 @@ def _create_default_orchestrator(
         custom_tools=custom_tools,
         model_id=model_id,
         model=model,
+        boto_client_config=boto_client_config,
         trace_attributes=trace_attributes,
         excluded_mcp_tool_names=excluded_mcp_tool_names,
         metrics_config=metrics_config,
         plugins=[skills_plugin] if skills_plugin else None,
+        locale=locale,
+        enable_prompt_caching=enable_prompt_caching,
     )
 
     logger.info("Default orchestrator created successfully with memory and conversation support")
@@ -150,6 +176,10 @@ def create_default_orchestrator(
     with_base_guardrails: bool = False,
     trace_attributes: Optional[dict[str, Any]] = None,
     metrics_config: Optional[MetricsConfig] = None,
+    locale: Optional[str] = None,
+    conversation_repository: Optional[FileMultiSourceConversationRepository] = None,
+    memory_manager: Optional[MemoryManager] = None,
+    boto_client_config: Optional[BotocoreConfig] = None,
 ) -> BaseOrchestrator:
     """
     Create a BaseOrchestrator instance with full memory and conversation support.
@@ -187,9 +217,13 @@ def create_default_orchestrator(
         additional_custom_tools=custom_tools,
         model_id=model_id,
         model=model,
+        boto_client_config=boto_client_config,
         with_base_guardrails=with_base_guardrails,
         trace_attributes=trace_attributes,
         metrics_config=metrics_config,
+        locale=locale,
+        conversation_repository=conversation_repository,
+        memory_manager=memory_manager,
     )
 
 
@@ -202,6 +236,10 @@ def create_default_async_orchestrator(
     model: Union[Model, str, None] = None,
     with_base_guardrails: bool = False,
     metrics_config: Optional[MetricsConfig] = None,
+    locale: Optional[str] = None,
+    conversation_repository: Optional[FileMultiSourceConversationRepository] = None,
+    memory_manager: Optional[MemoryManager] = None,
+    boto_client_config: Optional[BotocoreConfig] = None,
 ) -> AsyncBaseOrchestrator:
     """Create a AsyncBaseOrchestrator instance with full memory and conversation support.
 
@@ -235,8 +273,12 @@ def create_default_async_orchestrator(
         additional_custom_tools=custom_tools,
         model_id=model_id,
         model=model,
+        boto_client_config=boto_client_config,
         with_base_guardrails=with_base_guardrails,
         metrics_config=metrics_config,
+        locale=locale,
+        conversation_repository=conversation_repository,
+        memory_manager=memory_manager,
     )
 
 
@@ -249,6 +291,10 @@ def create_default_orchestrator_with_subagent(
     model: Union[Model, str, None] = None,
     with_base_guardrails: bool = False,
     metrics_config: Optional[MetricsConfig] = None,
+    locale: Optional[str] = None,
+    conversation_repository: Optional[FileMultiSourceConversationRepository] = None,
+    memory_manager: Optional[MemoryManager] = None,
+    boto_client_config: Optional[BotocoreConfig] = None,
 ) -> BaseOrchestrator:
     """Create a BaseOrchestrator instance with full memory and conversation support and subagent tools.
 
@@ -287,8 +333,12 @@ def create_default_orchestrator_with_subagent(
         additional_custom_tools=custom_tools,
         model_id=model_id,
         model=model,
+        boto_client_config=boto_client_config,
         with_base_guardrails=with_base_guardrails,
         metrics_config=metrics_config,
+        locale=locale,
+        conversation_repository=conversation_repository,
+        memory_manager=memory_manager,
     )
 
 
@@ -306,6 +356,12 @@ def create_default_async_orchestrator_with_subagent(
     enable_skills: bool = False,
     skills_dir: Optional[str] = None,
     enable_code_execution: bool = False,
+    locale: Optional[str] = None,
+    conversation_repository: Optional[FileMultiSourceConversationRepository] = None,
+    memory_manager: Optional[MemoryManager] = None,
+    enable_blank_reply_continuation: bool = False,
+    enable_prompt_caching: bool = False,
+    boto_client_config: Optional[BotocoreConfig] = None,
 ) -> AsyncBaseOrchestrator:
     """Create a AsyncBaseOrchestrator instance with full memory and conversation support and subagent tools.
 
@@ -337,6 +393,10 @@ def create_default_async_orchestrator_with_subagent(
         enable_code_execution: Enable experimental local Python code execution tool.
             WARNING: Code executes locally without sandboxing. Use with caution.
             For sandboxed execution, AgentCore Code Interpreter integration is planned.
+        enable_blank_reply_continuation: Ask the model once more for its reply when a turn ends
+            empty right after tool results (see BlankReplyHookProvider).
+        enable_prompt_caching: Turn on Bedrock prompt caching for the orchestrator's model (see
+            AsyncBaseOrchestrator). Off by default.
 
     Returns:
         Configured AsyncBaseOrchestrator instance with memory, hooks, and tools
@@ -363,6 +423,7 @@ def create_default_async_orchestrator_with_subagent(
         additional_custom_tools=custom_tools,
         model_id=model_id,
         model=model,
+        boto_client_config=boto_client_config,
         with_base_guardrails=with_base_guardrails,
         trace_attributes=trace_attributes,
         excluded_mcp_tool_names=excluded_mcp_tool_names,
@@ -370,6 +431,11 @@ def create_default_async_orchestrator_with_subagent(
         enable_skills=enable_skills,
         skills_dir=skills_dir,
         enable_code_execution=enable_code_execution,
+        enable_blank_reply_continuation=enable_blank_reply_continuation,
+        enable_prompt_caching=enable_prompt_caching,
+        locale=locale,
+        conversation_repository=conversation_repository,
+        memory_manager=memory_manager,
     )
 
 
@@ -403,6 +469,7 @@ def create_default_subagent(
     model: Union[Model, str, None] = None,
     custom_tools: Optional[list[Any]] = None,
     metrics_config: Optional[MetricsConfig] = None,
+    **kwargs: Any,
 ) -> BaseSubagent:
     """Create a BaseSubagent instance with minimal configuration.
 
@@ -417,6 +484,12 @@ def create_default_subagent(
         model: Optional Strands Model instance or model ID string
         custom_tools: Optional list of additional custom tools to add to the subagent
         metrics_config: Optional MetricsConfig for CloudWatch metrics (default: disabled)
+        **kwargs: Compatibility shim — accepted and ignored. A runtime server calls every agent
+            factory with the *same* keyword arguments, and with streaming enabled that set includes
+            ``conversation_repository`` / ``memory_manager`` (the shared stores an orchestrator
+            needs). A sub-agent is stateless and uses neither, but the factory must still accept
+            them or the server's call would raise ``TypeError``; ``**kwargs`` absorbs them so one
+            call signature works for both agent types.
 
     Returns:
         Configured BaseSubagent instance
@@ -438,6 +511,7 @@ def create_default_async_subagent(
     model: Union[Model, str, None] = None,
     custom_tools: Optional[list[Any]] = None,
     metrics_config: Optional[MetricsConfig] = None,
+    **kwargs: Any,
 ) -> AsyncBaseSubagent:
     """Create an AsyncBaseSubagent instance with minimal configuration.
 
@@ -449,6 +523,12 @@ def create_default_async_subagent(
         model: Optional Strands Model instance or model ID string
         custom_tools: Optional list of additional custom tools to add to the subagent
         metrics_config: Optional MetricsConfig for CloudWatch metrics (default: disabled)
+        **kwargs: Compatibility shim — accepted and ignored. A runtime server calls every agent
+            factory with the *same* keyword arguments, and with streaming enabled that set includes
+            ``conversation_repository`` / ``memory_manager`` (the shared stores an orchestrator
+            needs). A sub-agent is stateless and uses neither, but the factory must still accept
+            them or the server's call would raise ``TypeError``; ``**kwargs`` absorbs them so one
+            call signature works for both agent types.
 
     Returns:
         Configured AsyncBaseSubagent instance

{agent_builder_sdk_aws_transform-1.0.2 → agent_builder_sdk_aws_transform-1.1.0}/src/agent_builder_sdk/agentic_framework/a2a_manager.py

@@ -5,13 +5,17 @@ A2A Manager for SendMessage and GetTask operations.
 """
 
 import logging
+import threading
 from functools import lru_cache
-from typing import Any, Dict
+from typing import Any, Dict, Iterator
 
 from botocore.exceptions import ClientError
 
 from agent_builder_sdk.agentic_framework.agentic_api_helper import AgenticApiHelper
-from agent_builder_sdk.agentic_framework.client_factory import get_agentic_api_client
+from agent_builder_sdk.agentic_framework.client_factory import (
+    get_agentic_api_client,
+    get_streaming_agentic_api_client,
+)
 from agent_builder_sdk.custom_types.common_types import A2AMessage
 from agent_builder_sdk.custom_types.task_types import A2ATask
 from agent_builder_sdk.env_var import get_agent_context_from_env
@@ -19,9 +23,21 @@ from agent_builder_sdk.env_var import get_agent_context_from_env
 logger = logging.getLogger(__name__)
 
 
+# stream_send_message runs in worker threads; this keeps concurrent first calls from each building
+# the streaming client (lru_cache does not lock).
+_streaming_client_lock = threading.Lock()
+
+
 class A2AManager(AgenticApiHelper):
     """Manager for A2A protocol operations (SendMessage, GetTask)."""
 
+    def __init__(self, streaming_client: Any = None, **kwargs: Any) -> None:
+        """``streaming_client`` is the separate ConverseStream (``transformagentsstreamingservice``)
+        client used only by ``stream_send_message``; the sync ``client`` (base class) serves every
+        other op. Built on first use when not provided."""
+        super().__init__(**kwargs)
+        self.streaming_client = streaming_client
+
     def send_message(
         self,
         agent_instance_id: str,
@@ -60,6 +76,59 @@ class A2AManager(AgenticApiHelper):
             logger.exception(f"Failed to send A2A message to agent {agent_instance_id}: {e}")
             raise
 
+    def stream_send_message(
+        self,
+        agent_instance_id: str,
+        message: A2AMessage,
+    ) -> Iterator[Dict[str, Any]]:
+        """Send a message via the A2A ConverseStream API and stream the reply as A2A frames.
+
+        The streaming counterpart of ``send_message``: instead of one buffered reply, the callee's
+        response comes back as a live SSE stream of A2A frames, which this returns as an iterator of
+        frame dicts (parsed by ``sse_reader``).
+
+        Args:
+            agent_instance_id: The agent instance ID to send the message to
+            message: The A2AMessage object to send
+
+        Returns:
+            An iterator of A2A frame dicts. NOTE: the ``converse_stream`` call is issued eagerly, but
+            frames (and any mid-stream transport error, e.g. a dropped connection) surface while
+            iterating, not at call time.
+
+        Raises:
+            ClientError: If the initial ConverseStream call fails.
+        """
+        from agent_builder_sdk.streaming import sse_reader
+
+        # ConverseStream lives in the separate `transformagentsstreamingservice`, not the sync
+        # client (`self.client`), which has no such operation.
+        # Built on first use so buffered-only callers never need the streaming service model.
+        if self.streaming_client is None:
+            with _streaming_client_lock:
+                if self.streaming_client is None:
+                    self.streaming_client = get_streaming_agentic_api_client()
+
+        request_data = {
+            "agentInstanceId": agent_instance_id,
+            "params": {"message": message.to_dict()},
+        }
+        request_with_context = self._inject_request_context(request_data)
+
+        try:
+            logger.info(
+                f"Opening A2A stream to agent {agent_instance_id} with context_id={message.contextId}"
+            )
+            response = self.streaming_client.converse_stream(**request_with_context)
+            logger.info(f"A2A stream opened to agent {agent_instance_id}")
+        except ClientError as e:
+            logger.exception(f"Failed to open A2A stream to agent {agent_instance_id}: {e}")
+            raise
+
+        # The @httpPayload streaming blob surfaces as a StreamingBody under "stream" (see
+        # ConverseStreamResponse in the transformagentsstreamingservice model).
+        return sse_reader.iter_frames(response["stream"])
+
     def send_task(
         self,
         agent_instance_id: str,