fix issues with no tools for message array that contains tool calls

Author: afarntrog

src/strands/agent/agent.py

@@ -748,18 +748,14 @@ async def _execute_event_loop_cycle(self, output_schema: Optional[OutputSchema],
         # Add output_schema for structured output support
         invocation_state["output_schema"] = output_schema
 
-        # Register structured output tools once per invocation (better architecture)
-        registered_tool_names = []
         if output_schema:
             from ..output.modes import ToolMode
             if isinstance(output_schema.mode, ToolMode):
                 structured_output_tool_instances = output_schema.mode.get_tool_instances(output_schema.type)
                 for tool_instance in structured_output_tool_instances:
                     tool_name = tool_instance.tool_spec["name"]
-                    # Check if tool is already registered to prevent duplicates
                     if self.tool_registry.get_tool(tool_name) is None:
                         self.tool_registry.register_dynamic_tool(tool_instance)
-                        registered_tool_names.append(tool_name)
                         logger.debug(f"Registered structured output tool for invocation: {tool_name}")
 
         try:
@@ -784,11 +780,6 @@ async def _execute_event_loop_cycle(self, output_schema: Optional[OutputSchema],
             async for event in events:
                 yield event
 
-        finally:
-            # Cleanup: Deregister structured output tools after invocation
-            for tool_name in registered_tool_names:
-                self.tool_registry.unregister_dynamic_tool(tool_name)
-                logger.debug(f"Deregistered structured output tool after invocation: {tool_name}")
 
     def _convert_prompt_to_messages(self, prompt: AgentInput) -> Messages:
         messages: Messages | None = None

src/strands/output/base.py

@@ -4,9 +4,10 @@
 from typing import Any, Type, Union, Optional, TYPE_CHECKING
 from pydantic import BaseModel
 
+
 if TYPE_CHECKING:
     from strands.models.model import Model
-    from strands.tools.tool_spec import ToolSpec
+    from strands.types.tools import ToolSpec
 
 
 class OutputMode(ABC):
@@ -56,8 +57,6 @@ def __init__(
         self,
         type: Type[BaseModel],
         mode: Optional[OutputMode] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
     ):
         """Initialize output schema.
         
@@ -71,6 +70,4 @@ def __init__(
         if mode is None:
             from .modes import ToolMode
             mode = ToolMode()
-        self.mode = mode
-        self.name = name
-        self.description = description
+        self.mode = mode

src/strands/output/modes.py

@@ -7,7 +7,7 @@
 
 if TYPE_CHECKING:
     from strands.models.model import Model
-    from strands.tools.tool_spec import ToolSpec
+    from strands.types.tools import ToolSpec
     from strands.tools.structured_output_tool import StructuredOutputTool
 
 
@@ -54,16 +54,16 @@ class NativeMode(OutputMode):
 
     def get_tool_specs(self, output_type: Type[BaseModel]) -> list["ToolSpec"]:
         """Return empty list - will use native JSON schema instead."""
-        return []
+        raise NotImplementedError()
 
     def extract_result(self, model_response: Any) -> Any:
         """Extract result from native structured output."""
         # Implementation will be added when integrating with model providers
-        return model_response
+        raise NotImplementedError()
 
     def is_supported_by_model(self, model: "Model") -> bool:
         """Check if model supports native structured output."""
-        return model.supports_native_structured_output()
+        raise NotImplementedError()
 
 
 class PromptMode(OutputMode):
@@ -83,13 +83,12 @@ def __init__(self, template: Optional[str] = None):
 
     def get_tool_specs(self, output_type: Type[BaseModel]) -> list["ToolSpec"]:
         """Return empty list - will inject schema into system prompt instead."""
-        return []
+        raise NotImplementedError()
 
     def extract_result(self, model_response: Any) -> Any:
         """Extract result from prompted response."""
-        # Implementation will be added when integrating with event loop
-        return model_response
+        raise NotImplementedError()
 
     def is_supported_by_model(self, model: "Model") -> bool:
         """Prompting-based output works with all models."""
-        return True
+        raise NotImplementedError()