abstractcore 2.6.9__py3-none-any.whl → 2.9.0__py3-none-any.whl

abstractcore/providers/openai_compatible_provider.py

@@ -91,7 +91,16 @@ class OpenAICompatibleProvider(BaseProvider):
         except Exception as e:
             # Fallback with default timeout if client creation fails
             try:
-                self.client = httpx.Client(timeout=300.0)
+                fallback_timeout = None
+                try:
+                    from ..config.manager import get_config_manager
+
+                    fallback_timeout = float(get_config_manager().get_default_timeout())
+                except Exception:
+                    fallback_timeout = 7200.0
+                if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                    fallback_timeout = None
+                self.client = httpx.Client(timeout=fallback_timeout)
             except Exception:
                 raise RuntimeError(f"Failed to create HTTP client for OpenAI-compatible provider: {e}")
 
@@ -193,19 +202,24 @@ class OpenAICompatibleProvider(BaseProvider):
         chat_messages = []
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when the model supports them. Only inject a prompted tool list
+        # when native tool calling is not available.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Add system message if provided
-        if enhanced_system_prompt:
+        if final_system_prompt:
             chat_messages.append({
                 "role": "system",
-                "content": enhanced_system_prompt
+                "content": final_system_prompt
             })
 
         # Add conversation history
@@ -283,6 +297,11 @@ class OpenAICompatibleProvider(BaseProvider):
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+
         # Add additional generation parameters if provided (OpenAI-compatible)
         if "frequency_penalty" in kwargs:
             payload["frequency_penalty"] = kwargs["frequency_penalty"]
@@ -330,8 +349,9 @@ class OpenAICompatibleProvider(BaseProvider):
 
             # Track generation time
             start_time = time.time()
+            request_url = f"{self.base_url}/chat/completions"
             response = self.client.post(
-                f"{self.base_url}/chat/completions",
+                request_url,
                 json=payload,
                 headers=self._get_headers()
             )
@@ -343,10 +363,19 @@ class OpenAICompatibleProvider(BaseProvider):
             # Extract response from OpenAI format
             if "choices" in result and len(result["choices"]) > 0:
                 choice = result["choices"][0]
-                content = choice.get("message", {}).get("content", "")
+                message = choice.get("message") or {}
+                if not isinstance(message, dict):
+                    message = {}
+
+                content = message.get("content", "")
+                tool_calls = message.get("tool_calls")
+                if tool_calls is None:
+                    # Some servers surface tool calls at the choice level.
+                    tool_calls = choice.get("tool_calls")
                 finish_reason = choice.get("finish_reason", "stop")
             else:
                 content = "No response generated"
+                tool_calls = None
                 finish_reason = "error"
 
             # Extract usage info
@@ -357,6 +386,13 @@ class OpenAICompatibleProvider(BaseProvider):
                 model=self.model,
                 finish_reason=finish_reason,
                 raw_response=result,
+                tool_calls=tool_calls if isinstance(tool_calls, list) else None,
+                metadata={
+                    "_provider_request": {
+                        "url": request_url,
+                        "payload": payload,
+                    }
+                },
                 usage={
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
@@ -386,7 +422,7 @@ class OpenAICompatibleProvider(BaseProvider):
                     # If model discovery also fails, provide a generic error
                     raise ModelNotFoundError(f"Model '{self.model}' not found on OpenAI-compatible server and could not fetch available models")
             else:
-                raise ProviderAPIError(f"OpenAI-compatible server API error: {str(e)}")
+                raise
 
     def _stream_generate(self, payload: Dict[str, Any]) -> Iterator[GenerateResponse]:
         """Generate streaming response"""
@@ -418,13 +454,17 @@ class OpenAICompatibleProvider(BaseProvider):
                                 if "choices" in chunk and len(chunk["choices"]) > 0:
                                     choice = chunk["choices"][0]
                                     delta = choice.get("delta", {})
+                                    if not isinstance(delta, dict):
+                                        delta = {}
                                     content = delta.get("content", "")
+                                    tool_calls = delta.get("tool_calls") or choice.get("tool_calls")
                                     finish_reason = choice.get("finish_reason")
 
                                     yield GenerateResponse(
                                         content=content,
                                         model=self.model,
                                         finish_reason=finish_reason,
+                                        tool_calls=tool_calls if isinstance(tool_calls, list) else None,
                                         raw_response=chunk
                                     )
 
@@ -455,19 +495,23 @@ class OpenAICompatibleProvider(BaseProvider):
         chat_messages = []
 
         # Add tools to system prompt if provided
-        enhanced_system_prompt = system_prompt
-        if tools and self.tool_handler.supports_prompted:
-            tool_prompt = self.tool_handler.format_tools_prompt(tools)
-            if enhanced_system_prompt:
-                enhanced_system_prompt += f"\n\n{tool_prompt}"
+        final_system_prompt = system_prompt
+        # Prefer native tools when available; only inject prompted tool syntax as fallback.
+        if tools and self.tool_handler.supports_prompted and not self.tool_handler.supports_native:
+            include_tool_list = True
+            if final_system_prompt and "## Tools (session)" in final_system_prompt:
+                include_tool_list = False
+            tool_prompt = self.tool_handler.format_tools_prompt(tools, include_tool_list=include_tool_list)
+            if final_system_prompt:
+                final_system_prompt += f"\n\n{tool_prompt}"
             else:
-                enhanced_system_prompt = tool_prompt
+                final_system_prompt = tool_prompt
 
         # Add system message if provided
-        if enhanced_system_prompt:
+        if final_system_prompt:
             chat_messages.append({
                 "role": "system",
-                "content": enhanced_system_prompt
+                "content": final_system_prompt
             })
 
         # Add conversation history
@@ -523,6 +567,11 @@ class OpenAICompatibleProvider(BaseProvider):
             "top_p": kwargs.get("top_p", 0.9),
         }
 
+        # Native tools (OpenAI-compatible): send structured tools/tool_choice when supported.
+        if tools and self.tool_handler.supports_native:
+            payload["tools"] = self.tool_handler.prepare_tools_for_native(tools)
+            payload["tool_choice"] = kwargs.get("tool_choice", "auto")
+
         # Add additional parameters
         if "frequency_penalty" in kwargs:
             payload["frequency_penalty"] = kwargs["frequency_penalty"]
@@ -563,8 +612,9 @@ class OpenAICompatibleProvider(BaseProvider):
         try:
             # Track generation time
             start_time = time.time()
+            request_url = f"{self.base_url}/chat/completions"
             response = await self.async_client.post(
-                f"{self.base_url}/chat/completions",
+                request_url,
                 json=payload,
                 headers=self._get_headers()
             )
@@ -590,6 +640,12 @@ class OpenAICompatibleProvider(BaseProvider):
                 model=self.model,
                 finish_reason=finish_reason,
                 raw_response=result,
+                metadata={
+                    "_provider_request": {
+                        "url": request_url,
+                        "payload": payload,
+                    }
+                },
                 usage={
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
@@ -696,7 +752,16 @@ class OpenAICompatibleProvider(BaseProvider):
                     self.logger.warning(f"Failed to update HTTP client timeout: {e}")
                 # Try to create a new client with default timeout
                 try:
-                    self.client = httpx.Client(timeout=300.0)
+                    fallback_timeout = None
+                    try:
+                        from ..config.manager import get_config_manager
+
+                        fallback_timeout = float(get_config_manager().get_default_timeout())
+                    except Exception:
+                        fallback_timeout = 7200.0
+                    if isinstance(fallback_timeout, (int, float)) and float(fallback_timeout) <= 0:
+                        fallback_timeout = None
+                    self.client = httpx.Client(timeout=fallback_timeout)
                 except Exception:
                     pass  # Best effort - don't fail the operation
 

abstractcore/providers/openai_provider.py

@@ -196,15 +196,18 @@ class OpenAIProvider(BaseProvider):
                 formatted = self._format_response(response)
                 # Add generation time to response
                 formatted.gen_time = gen_time
+                # Runtime observability: capture the exact client payload we sent.
+                formatted.metadata = dict(formatted.metadata or {})
+                formatted.metadata["_provider_request"] = {"call_params": call_params}
 
                 # Handle tool execution for OpenAI native responses
                 if tools and formatted.has_tool_calls():
                     formatted = self._handle_tool_execution(formatted, tools)
 
                 return formatted
-        except Exception as e:
-            # Model validation is done at initialization, so this is likely an API error
-            raise ProviderAPIError(f"OpenAI API error: {str(e)}")
+        except Exception:
+            # Let BaseProvider normalize (timeouts/auth/rate limits) consistently.
+            raise
 
     async def _agenerate_internal(self,
                                    prompt: str,
@@ -324,23 +327,23 @@ class OpenAIProvider(BaseProvider):
                 formatted = self._format_response(response)
                 # Add generation time to response
                 formatted.gen_time = gen_time
+                formatted.metadata = dict(formatted.metadata or {})
+                formatted.metadata["_provider_request"] = {"call_params": call_params}
 
                 # Handle tool execution for OpenAI native responses
                 if tools and formatted.has_tool_calls():
                     formatted = self._handle_tool_execution(formatted, tools)
 
                 return formatted
-        except Exception as e:
-            # Model validation is done at initialization, so this is likely an API error
-            raise ProviderAPIError(f"OpenAI API error: {str(e)}")
+        except Exception:
+            raise
 
     async def _async_stream_response(self, call_params: Dict[str, Any], tools: Optional[List[Dict[str, Any]]] = None) -> AsyncIterator[GenerateResponse]:
         """Native async streaming responses from OpenAI."""
         try:
             stream = await self.async_client.chat.completions.create(**call_params)
-        except Exception as e:
-            # Model validation is done at initialization, so this is likely an API error
-            raise ProviderAPIError(f"OpenAI API error: {str(e)}")
+        except Exception:
+            raise
 
         # For streaming with tools, we need to collect the complete response
         collected_content = ""

abstractcore/providers/streaming.py

@@ -13,6 +13,7 @@ from enum import Enum
 
 from ..core.types import GenerateResponse
 from ..tools.core import ToolCall
+from ..utils.jsonish import loads_dict_like
 from ..utils.structured_logging import get_logger
 
 logger = get_logger(__name__)
@@ -56,6 +57,12 @@ class IncrementalToolDetector:
                 'start': r'<\|tool_call\|>',
                 'end': r'</\|tool_call\|>',
             },
+            # Harmony/ChatML-style tool transcript (no explicit closing tag; ends at end of JSON after <|message|>).
+            'harmony': {
+                'start': r'<\|channel\|>',
+                'end': None,
+                'kind': 'harmony',
+            },
             'llama': {
                 'start': r'<function_call>',
                 'end': r'</function_call>',
@@ -86,18 +93,42 @@ class IncrementalToolDetector:
         if not model_name:
             return list(self.patterns.values())
 
-        model_lower = model_name.lower()
+        # Centralized model capability/syntax lookup.
+        # Use `architecture_formats.json` as the source of truth instead of string heuristics.
+        try:
+            from ..architectures import detect_architecture, get_architecture_format
 
-        if 'gemma' in model_lower:
-            return [self.patterns['gemma']]
-        elif 'llama' in model_lower:
-            return [self.patterns['llama'], self.patterns['xml']]
-        else:
-            return [
-                self.patterns['qwen'],
-                self.patterns['llama'],
-                self.patterns['xml']
-            ]
+            architecture = detect_architecture(model_name)
+            arch_format = get_architecture_format(architecture)
+            tool_format = str(arch_format.get("tool_format", "") or "").strip().lower()
+            message_format = str(arch_format.get("message_format", "") or "").strip().lower()
+        except Exception:
+            tool_format = ""
+            message_format = ""
+            architecture = "generic"
+
+        # Harmony/ChatML tool transcripts (GPT-OSS).
+        if message_format == "harmony":
+            return [self.patterns["harmony"]]
+
+        # Pythonic tool blocks (Gemma-style).
+        if tool_format == "pythonic":
+            return [self.patterns["gemma"]]
+
+        # Special-token tools (Qwen-style). Some "prompted" models share this convention.
+        if tool_format == "special_token" or (tool_format == "prompted" and message_format == "im_start_end"):
+            return [self.patterns["qwen"], self.patterns["llama"], self.patterns["xml"]]
+
+        # XML-wrapped tools.
+        if tool_format == "xml":
+            return [self.patterns["xml"], self.patterns["llama"], self.patterns["qwen"]]
+
+        # LLaMA-style prompted tools.
+        if tool_format == "prompted" and "llama" in str(architecture):
+            return [self.patterns["llama"], self.patterns["xml"]]
+
+        # Default: try the common tag-based formats as fallbacks.
+        return [self.patterns["qwen"], self.patterns["llama"], self.patterns["xml"]]
 
     def process_chunk(self, chunk_content: str) -> Tuple[str, List[ToolCall]]:
         """
@@ -181,6 +212,10 @@ class IncrementalToolDetector:
         # Add new content to tool content
         self.current_tool_content += chunk_content
 
+        # Harmony/ChatML tool transcript: detect completion by balanced JSON after <|message|>.
+        if self.current_pattern and self.current_pattern.get('kind') == 'harmony':
+            return self._collect_harmony_tool_content()
+
         # Check for tool end pattern
         end_pattern = self.current_pattern['end']
         end_match = re.search(end_pattern, self.current_tool_content, re.IGNORECASE)
@@ -217,6 +252,107 @@ class IncrementalToolDetector:
 
         return streamable_content, completed_tools
 
+    def _collect_harmony_tool_content(self) -> Tuple[str, List[ToolCall]]:
+        """Collect and parse a Harmony/ChatML tool transcript block."""
+        streamable_content = ""
+        completed_tools: List[ToolCall] = []
+
+        msg_tag = "<|message|>"
+        msg_idx = self.current_tool_content.find(msg_tag)
+        if msg_idx == -1:
+            return streamable_content, completed_tools
+
+        # Extract tool name from the header (between <|channel|> and <|message|>).
+        header = self.current_tool_content[:msg_idx]
+        name_match = re.search(r"\bto=([a-zA-Z0-9_\-\.]+)\b", header)
+        if not name_match:
+            return streamable_content, completed_tools
+        tool_name = str(name_match.group(1) or "").strip()
+        if tool_name.startswith("functions."):
+            tool_name = tool_name.split(".", 1)[1].strip()
+        if not tool_name:
+            return streamable_content, completed_tools
+
+        brace_start = self.current_tool_content.find("{", msg_idx + len(msg_tag))
+        if brace_start == -1:
+            return streamable_content, completed_tools
+        between = self.current_tool_content[msg_idx + len(msg_tag) : brace_start]
+        if between and any(not c.isspace() for c in between):
+            return streamable_content, completed_tools
+
+        def _find_matching_brace(text: str, start: int) -> int:
+            depth = 0
+            in_string = False
+            quote = ""
+            escaped = False
+            for i in range(start, len(text)):
+                ch = text[i]
+                if in_string:
+                    if escaped:
+                        escaped = False
+                        continue
+                    if ch == "\\":
+                        escaped = True
+                        continue
+                    if ch == quote:
+                        in_string = False
+                        quote = ""
+                    continue
+                if ch in ("'", '"'):
+                    in_string = True
+                    quote = ch
+                    continue
+                if ch == "{":
+                    depth += 1
+                    continue
+                if ch == "}":
+                    depth -= 1
+                    if depth == 0:
+                        return i
+            return -1
+
+        brace_end = _find_matching_brace(self.current_tool_content, brace_start)
+        if brace_end == -1:
+            return streamable_content, completed_tools
+
+        raw_args = self.current_tool_content[brace_start : brace_end + 1]
+        args: Dict[str, Any] = {}
+        call_id: Optional[str] = None
+        loaded = loads_dict_like(raw_args)
+        if isinstance(loaded, dict):
+            # Some models emit a wrapper payload:
+            #   {"name":"tool","arguments":{...},"call_id": "..."}
+            inner_args = loaded.get("arguments")
+            if isinstance(inner_args, dict):
+                args = inner_args
+            elif isinstance(inner_args, str):
+                parsed_inner = loads_dict_like(inner_args)
+                args = parsed_inner if isinstance(parsed_inner, dict) else loaded
+            else:
+                args = loaded
+
+            call_id_value = loaded.get("call_id") or loaded.get("id")
+            if isinstance(call_id_value, str) and call_id_value.strip():
+                call_id = call_id_value.strip()
+
+        completed_tools.append(ToolCall(name=tool_name, arguments=args, call_id=call_id))
+
+        if self.rewrite_tags:
+            # When rewriting, stream the full accumulated content (including the tool transcript).
+            streamable_content = self.accumulated_content
+            self.accumulated_content = ""
+
+        remaining_content = self.current_tool_content[brace_end + 1 :]
+        self.reset()
+
+        if remaining_content:
+            self.accumulated_content = remaining_content
+            additional_streamable, additional_tools = self._scan_for_tool_start("")
+            streamable_content += additional_streamable
+            completed_tools.extend(additional_tools)
+
+        return streamable_content, completed_tools
+
     def _might_have_partial_tool_call(self) -> bool:
         """Check if accumulated content might contain start of a tool call."""
         # Check for partial tool tags more aggressively to handle character-by-character streaming
@@ -227,7 +363,9 @@ class IncrementalToolDetector:
             '<', '<|', '<f', '</', '<t', '`', '``',
             '<fu', '<fun', '<func', '<funct', '<functi', '<functio', '<function',  # <function_call>
             '<tool', '<tool_', '<tool_c', '<tool_ca', '<tool_cal',  # <tool_call>
-            '<|t', '<|to', '<|too', '<|tool', '<|tool_', '<|tool_c'  # <|tool_call|>
+            '<|t', '<|to', '<|too', '<|tool', '<|tool_', '<|tool_c',  # <|tool_call|>
+            '<|c', '<|ch', '<|cha', '<|chan', '<|chann', '<|channe', '<|channel',  # <|channel|>
+            '<|m', '<|me', '<|mes', '<|mess', '<|messa', '<|messag', '<|message',  # <|message|>
         ]
 
         # Check if tail ends with any potential partial start
@@ -239,6 +377,8 @@ class IncrementalToolDetector:
         for pattern_partial in ['<function', '<tool_call', '<|tool', '```tool']:
             if pattern_partial in tail:
                 return True
+        if '<|channel' in tail or '<|message' in tail:
+            return True
 
         # Check if we have an incomplete tool call (start tag but no end tag)
         for pattern_info in self.active_patterns:
@@ -347,16 +487,17 @@ class UnifiedStreamProcessor:
     """
 
     def __init__(self, model_name: str, execute_tools: bool = False,
-                 tool_call_tags: Optional[str] = None,
+                 tool_call_tags: Optional[object] = None,
                  default_target_format: str = "qwen3"):
         """Initialize the stream processor."""
         self.model_name = model_name
-        # Note: execute_tools parameter is kept for backward compatibility but ignored
-        # Tool execution is now handled by the client (CLI)
+        # Note: execute_tools is kept for backward compatibility and introspection,
+        # but tool execution is handled by the client/runtime (AbstractRuntime).
+        self.execute_tools = execute_tools
         self.tool_call_tags = tool_call_tags
         self.default_target_format = default_target_format
 
-        # Always initialize tag rewriter - either custom tags or default target format
+        # Initialize tag rewriter only when explicit format conversion is requested.
         self.tag_rewriter = None
         # Backwards compatibility: tag_rewrite_buffer attribute (unused in current implementation)
         self.tag_rewrite_buffer = ""
@@ -364,31 +505,35 @@ class UnifiedStreamProcessor:
         # Flag to indicate if we're converting to OpenAI JSON format (not text rewriting)
         self.convert_to_openai_json = False
 
-        # Determine whether tool_call_tags contains predefined format or custom tags
+        # Determine whether tool_call_tags contains predefined format or custom tags.
         if tool_call_tags:
-            # Check if tool_call_tags is a predefined format name
-            predefined_formats = ["qwen3", "openai", "llama3", "xml", "gemma"]
-
-            if tool_call_tags in predefined_formats:
-                # It's a predefined format - use default rewriter
-                self._initialize_default_rewriter(tool_call_tags)
-                logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as predefined format")
-            elif ',' in tool_call_tags:
-                # It contains comma - likely custom tags like "START,END"
+            # Accept pre-built tag rewriters/config objects (used by some internal callers/tests).
+            if not isinstance(tool_call_tags, str):
                 self._initialize_tag_rewriter(tool_call_tags)
-                logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as custom comma-separated tags")
             else:
-                # Single string that's not a predefined format - could be custom single tag
-                # Try as custom first, fall back to treating as predefined format
-                try:
-                    self._initialize_tag_rewriter(tool_call_tags)
-                    logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as custom single tag")
-                except Exception as e:
-                    logger.debug(f"Failed to initialize as custom tag, trying as predefined format: {e}")
+                # Check if tool_call_tags is a predefined format name
+                predefined_formats = ["qwen3", "openai", "llama3", "xml", "gemma"]
+
+                if tool_call_tags in predefined_formats:
+                    # It's a predefined format - use default rewriter
                     self._initialize_default_rewriter(tool_call_tags)
+                    logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as predefined format")
+                elif ',' in tool_call_tags:
+                    # It contains comma - likely custom tags like "START,END"
+                    self._initialize_tag_rewriter(tool_call_tags)
+                    logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as custom comma-separated tags")
+                else:
+                    # Single string that's not a predefined format - could be custom single tag
+                    # Try as custom first, fall back to treating as predefined format
+                    try:
+                        self._initialize_tag_rewriter(tool_call_tags)
+                        logger.debug(f"Treating tool_call_tags '{tool_call_tags}' as custom single tag")
+                    except Exception as e:
+                        logger.debug(f"Failed to initialize as custom tag, trying as predefined format: {e}")
+                        self._initialize_default_rewriter(tool_call_tags)
         else:
-            # No custom tags - initialize default rewriter to target format
-            self._initialize_default_rewriter(default_target_format)
+            # No explicit format conversion requested - no text rewriting.
+            self.tag_rewriter = None
 
         # Create detector - preserve tool calls when user explicitly wants format conversion
         # Filter out tool calls for clean UX when no explicit format conversion is requested
@@ -447,9 +592,18 @@ class UnifiedStreamProcessor:
                 # Yield tool calls for server processing
                 if completed_tools:
                     logger.debug(f"Detected {len(completed_tools)} tools - yielding for server processing")
+                    tool_payload = [
+                        {
+                            "name": tc.name,
+                            "arguments": tc.arguments,
+                            "call_id": tc.call_id,
+                        }
+                        for tc in completed_tools
+                        if getattr(tc, "name", None)
+                    ]
                     yield GenerateResponse(
                         content="",
-                        tool_calls=completed_tools,
+                        tool_calls=tool_payload,
                         model=chunk.model,
                         finish_reason=chunk.finish_reason,
                         usage=chunk.usage,
@@ -477,9 +631,18 @@ class UnifiedStreamProcessor:
 
             if final_tools:
                 logger.debug(f"Finalized {len(final_tools)} tools - yielding for server processing")
+                tool_payload = [
+                    {
+                        "name": tc.name,
+                        "arguments": tc.arguments,
+                        "call_id": tc.call_id,
+                    }
+                    for tc in final_tools
+                    if getattr(tc, "name", None)
+                ]
                 yield GenerateResponse(
                     content="",
-                    tool_calls=final_tools,
+                    tool_calls=tool_payload,
                     model=self.model_name,
                     finish_reason="tool_calls"
                 )
@@ -705,4 +868,3 @@ class UnifiedStreamProcessor:
                 break
 
         return converted_content
-