fix(brains): forward tool calls through the publisher hand-off

The default chat_handler in both publisher entry points (zhub up and the
multi_brain_publisher example) iterated the brain's stream and yielded
only chunk.delta, silently dropping every tool_call_delta and the
finish_reason on a tool-call turn (the brain emits the call as chunks
whose text delta is empty). The hub keys tool-call auto-resolution off
accumulated tool_call deltas plus a finish_reason=="tool_calls"
terminator, so a brain served this way could never resolve a capability
even though every adapter surfaces the call correctly.

Add brains.stream_for_publish() as the single source of truth for the
hand-off: it yields the whole ChatChunk whenever it carries a delta, a
tool_call_delta, or a finish_reason. The publisher serializers already
understand ChatChunk on both the streaming and non-streaming paths.

Author: Zawwarsami16

examples/multi_brain_publisher.py

@@ -25,7 +25,7 @@
 import sys
 
 from zhub import publish
-from zhub.brains import detect, list_available, REGISTRY
+from zhub.brains import detect, list_available, REGISTRY, stream_for_publish
 
 
 def _resolve_brain(name: str):
@@ -116,15 +116,15 @@ async def chat_handler(messages, options):
                          if m.get("role") == "system"]
         non_system = [m for m in messages if m.get("role") != "system"]
         system = "\n\n".join(p for p in system_parts if p) or None
-        async for chunk in brain.stream(
+        async for chunk in stream_for_publish(
+            brain,
             non_system,
             system=system,
             temperature=float(options.get("temperature", 0.7)),
             max_tokens=int(options.get("max_tokens", 2048)),
             tools=options.get("tools"),
         ):
-            if chunk.delta:
-                yield chunk.delta
+            yield chunk
 
     pub = publish(
         name=args.name,

zhub/brains/__init__.py

@@ -13,7 +13,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, AsyncIterator, Optional
 
 from .base import BrainAdapter, ChatChunk
 from .ollama import OllamaAdapter
@@ -50,6 +50,39 @@ def detect() -> Optional[BrainAdapter]:
     return None
 
 
+async def stream_for_publish(
+    brain: BrainAdapter,
+    messages: list[dict[str, Any]],
+    *,
+    system: Optional[str] = None,
+    temperature: float = 0.7,
+    max_tokens: int = 2048,
+    tools: Optional[list[dict[str, Any]]] = None,
+) -> AsyncIterator[ChatChunk]:
+    """Stream a brain's reply as chunks suitable to yield from a zhub
+    ``chat_handler``.
+
+    Yields the *whole* ChatChunk whenever it carries a text delta, a
+    tool_call_delta, OR a finish_reason — not just ``chunk.delta``. A
+    tool-call turn produces chunks whose ``delta`` is empty but whose
+    ``tool_call_delta`` / ``finish_reason="tool_calls"`` carry the call;
+    yielding only ``chunk.delta`` (the obvious-looking shortcut) silently
+    drops every function call the brain emits, so the hub — which keys
+    tool-call auto-resolution off accumulated tool_call deltas + a
+    ``finish_reason == "tool_calls"`` terminator — never sees them. The
+    publisher serializers (`_serialize_stream_chunk` / `_chunk_fields`)
+    already understand ChatChunk objects, so handing them the chunk
+    verbatim preserves the full shape on both the streaming and
+    non-streaming paths.
+    """
+    async for chunk in brain.stream(
+        messages, system=system, temperature=temperature,
+        max_tokens=max_tokens, tools=tools,
+    ):
+        if chunk.delta or chunk.tool_call_delta or chunk.finish_reason:
+            yield chunk
+
+
 def list_available() -> list[BrainAdapter]:
     import zhub.brains as _self
     out: list[BrainAdapter] = []
@@ -62,7 +95,7 @@ def list_available() -> list[BrainAdapter]:
 
 __all__ = [
     "BrainAdapter", "ChatChunk", "REGISTRY",
-    "detect", "list_available",
+    "detect", "list_available", "stream_for_publish",
     "OllamaAdapter", "GroqAdapter", "OpenAIAdapter",
     "CerebrasAdapter", "AnthropicAdapter",
     "TogetherAdapter", "MistralAdapter", "CohereAdapter",

zhub/cli_up.py

@@ -29,7 +29,7 @@
 from typing import Optional
 
 from . import publish
-from .brains import detect, REGISTRY
+from .brains import detect, REGISTRY, stream_for_publish
 
 
 def _brain_choices() -> str:
@@ -182,14 +182,13 @@ async def chat_handler(messages, options):
                             if m.get("role") == "system"]
             non_system = [m for m in messages if m.get("role") != "system"]
             system = "\n\n".join(p for p in system_parts if p) or None
-            async for chunk in brain.stream(
-                non_system, system=system,
+            async for chunk in stream_for_publish(
+                brain, non_system, system=system,
                 temperature=float(options.get("temperature", 0.7)),
                 max_tokens=int(options.get("max_tokens", 2048)),
                 tools=options.get("tools"),
             ):
-                if chunk.delta:
-                    yield chunk.delta
+                yield chunk
 
         pub = publish(
             name=args.name,