abstractcore 2.9.1__py3-none-any.whl → 2.11.2__py3-none-any.whl

abstractcore/providers/streaming.py

@@ -15,6 +15,7 @@ from ..core.types import GenerateResponse
 from ..tools.core import ToolCall
 from ..utils.jsonish import loads_dict_like
 from ..utils.structured_logging import get_logger
+from ..utils.truncation import preview_text
 
 logger = get_logger(__name__)
 
@@ -120,7 +121,7 @@ class IncrementalToolDetector:
             return [self.patterns["qwen"], self.patterns["llama"], self.patterns["xml"]]
 
         # XML-wrapped tools.
-        if tool_format == "xml":
+        if tool_format in {"xml", "glm_xml"}:
             return [self.patterns["xml"], self.patterns["llama"], self.patterns["qwen"]]
 
         # LLaMA-style prompted tools.
@@ -420,26 +421,54 @@ class IncrementalToolDetector:
         if not json_content or not json_content.strip():
             return None
 
+        cleaned = json_content.strip()
+
+        # Handle missing braces (best-effort).
+        if cleaned.count("{") > cleaned.count("}"):
+            missing = cleaned.count("{") - cleaned.count("}")
+            cleaned += "}" * missing
+
+        tool_data: Optional[Dict[str, Any]] = None
         try:
-            cleaned_json = json_content.strip()
+            tool_data = loads_dict_like(cleaned)
+        except Exception as e:
+            logger.debug(f"Tool JSON-ish parse error: {e}, content: {repr(json_content)}")
+            tool_data = None
 
-            # Handle missing braces
-            if cleaned_json.count('{') > cleaned_json.count('}'):
-                missing_braces = cleaned_json.count('{') - cleaned_json.count('}')
-                cleaned_json += '}' * missing_braces
+        if not isinstance(tool_data, dict):
+            return None
 
-            tool_data = json.loads(cleaned_json)
+        name: Any = tool_data.get("name")
+        arguments: Any = tool_data.get("arguments")
+        call_id: Any = tool_data.get("call_id") or tool_data.get("id")
+
+        # OpenAI-style wrapper payload: {"id":"...","type":"function","function":{"name":...,"arguments":"{...}"}}
+        function = tool_data.get("function") if isinstance(tool_data.get("function"), dict) else None
+        if function:
+            if not isinstance(name, str) or not name.strip():
+                name = function.get("name")
+            if arguments is None:
+                arguments = function.get("arguments")
+
+        # Anthropic-ish key used by some tool payloads.
+        if arguments is None and "input" in tool_data:
+            arguments = tool_data.get("input")
+
+        # Normalize arguments to a dict.
+        if isinstance(arguments, str):
+            parsed_args = loads_dict_like(arguments)
+            arguments = parsed_args if isinstance(parsed_args, dict) else {}
+        if not isinstance(arguments, dict):
+            arguments = {}
+
+        if not isinstance(name, str) or not name.strip():
+            return None
 
-            if isinstance(tool_data, dict) and "name" in tool_data:
-                return ToolCall(
-                    name=tool_data["name"],
-                    arguments=tool_data.get("arguments", {}),
-                    call_id=tool_data.get("id")
-                )
-        except json.JSONDecodeError as e:
-            logger.debug(f"JSON parse error: {e}, content: {repr(json_content)}")
+        call_id_str: Optional[str] = None
+        if isinstance(call_id, str) and call_id.strip():
+            call_id_str = call_id.strip()
 
-        return None
+        return ToolCall(name=name.strip(), arguments=arguments, call_id=call_id_str)
 
     def finalize(self) -> List[ToolCall]:
         """Finalize and return any remaining tool calls."""
@@ -560,7 +589,47 @@ class UnifiedStreamProcessor:
             GenerateResponse: Processed chunks with rewritten tags
         """
         try:
+            def _canonical_tool_call_key(call: Dict[str, Any]) -> Optional[tuple]:
+                """Best-effort key for deduplicating canonical tool-call payloads."""
+                name = call.get("name")
+                if not isinstance(name, str) or not name.strip():
+                    return None
+
+                call_id = call.get("call_id") or call.get("id")
+                call_id_norm: Optional[str]
+                if isinstance(call_id, str) and call_id.strip():
+                    call_id_norm = call_id.strip()
+                else:
+                    call_id_norm = None
+
+                args = call.get("arguments")
+                if isinstance(args, dict):
+                    try:
+                        args_norm = json.dumps(args, sort_keys=True, separators=(",", ":"))
+                    except Exception:
+                        args_norm = str(args)
+                else:
+                    args_norm = str(args)
+
+                return (name.strip(), args_norm, call_id_norm)
+
             for chunk in response_stream:
+                # Preserve provider-emitted tool calls (native tools / server-side tool_calls).
+                incoming_tool_calls = (
+                    chunk.tool_calls
+                    if isinstance(getattr(chunk, "tool_calls", None), list) and chunk.tool_calls
+                    else None
+                )
+
+                incoming_tool_call_keys = set()
+                if incoming_tool_calls:
+                    for call in incoming_tool_calls:
+                        if not isinstance(call, dict):
+                            continue
+                        key = _canonical_tool_call_key(call)
+                        if key:
+                            incoming_tool_call_keys.add(key)
+
                 if not chunk.content:
                     yield chunk
                     continue
@@ -586,7 +655,25 @@ class UnifiedStreamProcessor:
                         model=chunk.model,
                         finish_reason=chunk.finish_reason,
                         usage=chunk.usage,
-                        raw_response=chunk.raw_response
+                        raw_response=chunk.raw_response,
+                        metadata=chunk.metadata,
+                        tool_calls=incoming_tool_calls,
+                    )
+
+                    # If we emitted content alongside provider-emitted tool calls, do not emit them again.
+                    incoming_tool_calls = None
+
+                # If the incoming chunk had tool_calls but we did not emit any content (buffering/tag parsing),
+                # still surface the tool_calls to downstream hosts.
+                if incoming_tool_calls:
+                    yield GenerateResponse(
+                        content="",
+                        tool_calls=incoming_tool_calls,
+                        model=chunk.model,
+                        finish_reason=chunk.finish_reason,
+                        usage=chunk.usage,
+                        raw_response=chunk.raw_response,
+                        metadata=chunk.metadata,
                     )
 
                 # Yield tool calls for server processing
@@ -601,14 +688,25 @@ class UnifiedStreamProcessor:
                         for tc in completed_tools
                         if getattr(tc, "name", None)
                     ]
-                    yield GenerateResponse(
-                        content="",
-                        tool_calls=tool_payload,
-                        model=chunk.model,
-                        finish_reason=chunk.finish_reason,
-                        usage=chunk.usage,
-                        raw_response=chunk.raw_response
-                    )
+                    if incoming_tool_call_keys:
+                        tool_payload = [
+                            call
+                            for call in tool_payload
+                            if (
+                                isinstance(call, dict)
+                                and _canonical_tool_call_key(call) not in incoming_tool_call_keys
+                            )
+                        ]
+                    if tool_payload:
+                        yield GenerateResponse(
+                            content="",
+                            tool_calls=tool_payload,
+                            model=chunk.model,
+                            finish_reason=chunk.finish_reason,
+                            usage=chunk.usage,
+                            raw_response=chunk.raw_response,
+                            metadata=chunk.metadata,
+                        )
 
             # Finalize - get any remaining tools and handle remaining content
             final_tools = self.detector.finalize()
@@ -786,9 +884,11 @@ class UnifiedStreamProcessor:
             # Use direct text rewriting since we have complete tool calls
             rewritten = self.tag_rewriter.rewrite_text(content)
             if rewritten != content:
-                logger.debug(f"Tag rewriting successful: {content[:50]} -> {rewritten[:50]}")
+                logger.debug(
+                    f"Tag rewriting successful: {preview_text(content, max_chars=50)} -> {preview_text(rewritten, max_chars=50)}"
+                )
             else:
-                logger.debug(f"Tag rewriting had no effect on: {content[:50]}")
+                logger.debug(f"Tag rewriting had no effect on: {preview_text(content, max_chars=50)}")
             return rewritten
         except Exception as e:
             logger.debug(f"Tag rewriting failed: {e}")
@@ -831,8 +931,8 @@ class UnifiedStreamProcessor:
                         # Extract JSON content
                         json_content = match.group(1).strip()
 
-                        # Parse the JSON to validate and extract fields
-                        tool_data = json.loads(json_content)
+                        # Parse the JSON-ish payload to validate and extract fields.
+                        tool_data = loads_dict_like(json_content)
 
                         if not isinstance(tool_data, dict) or "name" not in tool_data:
                             logger.warning(f"Invalid tool call JSON: {json_content[:100]}")
@@ -847,7 +947,15 @@ class UnifiedStreamProcessor:
                             "type": "function",
                             "function": {
                                 "name": tool_data["name"],
-                                "arguments": json.dumps(tool_data.get("arguments", {}))
+                                "arguments": json.dumps(
+                                    (tool_data.get("arguments") if isinstance(tool_data.get("arguments"), dict) else None)
+                                    or (
+                                        loads_dict_like(tool_data.get("arguments"))
+                                        if isinstance(tool_data.get("arguments"), str)
+                                        else None
+                                    )
+                                    or {}
+                                ),
                             }
                         }
 
@@ -857,9 +965,6 @@ class UnifiedStreamProcessor:
 
                         logger.debug(f"Converted {format_type} tool call to OpenAI format: {openai_json[:100]}")
 
-                    except json.JSONDecodeError as e:
-                        logger.warning(f"Failed to parse tool call JSON: {e}")
-                        continue
                     except Exception as e:
                         logger.error(f"Error converting tool call to OpenAI format: {e}")
                         continue