klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/llm/input_common.py

@@ -5,10 +5,10 @@ This module provides shared abstractions for providers that require message grou
 since it uses a flat item list matching our internal protocol.
 """
 
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from klaude_code import const
 
@@ -49,10 +49,6 @@ class AssistantGroup:
 
     text_content: str | None = None
     tool_calls: list[model.ToolCallItem] = field(default_factory=lambda: [])
-    reasoning_text: list[model.ReasoningTextItem] = field(default_factory=lambda: [])
-    reasoning_encrypted: list[model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
-    # Preserve original ordering of reasoning items for providers that
-    # need to emit them as an ordered stream (e.g. OpenRouter).
     reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
 
 
@@ -153,7 +149,7 @@ def parse_message_groups(history: list[model.ConversationItem]) -> list[MessageG
                 for item in items:
                     if isinstance(item, (model.UserMessageItem, model.DeveloperMessageItem)):
                         if item.content:
-                            group.text_parts.append(item.content)
+                            group.text_parts.append(item.content + "\n")
                         if item.images:
                             group.images.extend(item.images)
                 groups.append(group)
@@ -184,10 +180,8 @@ def parse_message_groups(history: list[model.ConversationItem]) -> list[MessageG
                         case model.ToolCallItem():
                             group.tool_calls.append(item)
                         case model.ReasoningTextItem():
-                            group.reasoning_text.append(item)
                             group.reasoning_items.append(item)
                         case model.ReasoningEncryptedItem():
-                            group.reasoning_encrypted.append(item)
                             group.reasoning_items.append(item)
                         case _:
                             pass

klaude_code/llm/openai_compatible/client.py

@@ -1,21 +1,50 @@
 import json
 from collections.abc import AsyncGenerator
-from typing import Literal, override
+from typing import Any, override
 
 import httpx
 import openai
-from openai import APIError, RateLimitError
+from openai.types.chat.completion_create_params import CompletionCreateParamsStreaming
 
-from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
+from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.openai_compatible.input import convert_history_to_input, convert_tool_schema
-from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
+from klaude_code.llm.openai_compatible.stream import DefaultReasoningHandler, parse_chat_completions_stream
 from klaude_code.llm.registry import register
-from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
 
+def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:
+    """Build OpenAI API request parameters."""
+    messages = convert_history_to_input(param.input, param.system, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    extra_body: dict[str, object] = {}
+
+    if param.thinking and param.thinking.type == "enabled":
+        extra_body["thinking"] = {
+            "type": param.thinking.type,
+            "budget": param.thinking.budget_tokens,
+        }
+
+    payload: CompletionCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "stream": True,
+        "messages": messages,
+        "temperature": param.temperature,
+        "max_tokens": param.max_tokens,
+        "tools": tools,
+        "reasoning_effort": param.thinking.reasoning_effort if param.thinking else None,
+        "verbosity": param.verbosity,
+    }
+
+    return payload, extra_body
+
+
 @register(llm_param.LLMClientProtocol.OPENAI)
 class OpenAICompatibleClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
@@ -43,169 +72,48 @@ class OpenAICompatibleClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         param = apply_config_defaults(param, self.get_llm_config())
-        messages = convert_history_to_input(param.input, param.system, param.model)
-        tools = convert_tool_schema(param.tools)
-
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
-
-        extra_body = {}
-        extra_headers = {"extra": json.dumps({"session_id": param.session_id})}
-
-        if param.thinking:
-            extra_body["thinking"] = {
-                "type": param.thinking.type,
-                "budget": param.thinking.budget_tokens,
-            }
-        stream = call_with_logged_payload(
-            self.client.chat.completions.create,
-            model=str(param.model),
-            tool_choice="auto",
-            parallel_tool_calls=True,
-            stream=True,
-            messages=messages,
-            temperature=param.temperature,
-            max_tokens=param.max_tokens,
-            tools=tools,
-            reasoning_effort=param.thinking.reasoning_effort if param.thinking else None,
-            verbosity=param.verbosity,
-            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
-            extra_headers=extra_headers,
-        )
 
-        stage: Literal["waiting", "reasoning", "assistant", "tool", "done"] = "waiting"
-        accumulated_reasoning: list[str] = []
-        accumulated_content: list[str] = []
-        accumulated_tool_calls: ToolCallAccumulatorABC = BasicToolCallAccumulator()
-        emitted_tool_start_indices: set[int] = set()
-        response_id: str | None = None
-
-        def flush_reasoning_items() -> list[model.ConversationItem]:
-            nonlocal accumulated_reasoning
-            if not accumulated_reasoning:
-                return []
-            item = model.ReasoningTextItem(
-                content="".join(accumulated_reasoning),
-                response_id=response_id,
-                model=str(param.model),
-            )
-            accumulated_reasoning = []
-            return [item]
-
-        def flush_assistant_items() -> list[model.ConversationItem]:
-            nonlocal accumulated_content
-            if len(accumulated_content) == 0:
-                return []
-            item = model.AssistantMessageItem(
-                content="".join(accumulated_content),
-                response_id=response_id,
-            )
-            accumulated_content = []
-            return [item]
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        def flush_tool_call_items() -> list[model.ToolCallItem]:
-            nonlocal accumulated_tool_calls
-            items: list[model.ToolCallItem] = accumulated_tool_calls.get()
-            if items:
-                accumulated_tool_calls.chunks_by_step = []  # pyright: ignore[reportAttributeAccessIssue]
-            return items
+        payload, extra_body = build_payload(param)
+        extra_headers: dict[str, str] = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
 
-        try:
-            async for event in await stream:
-                log_debug(
-                    event.model_dump_json(exclude_none=True),
-                    style="blue",
-                    debug_type=DebugType.LLM_STREAM,
-                )
-                if not response_id and event.id:
-                    response_id = event.id
-                    accumulated_tool_calls.response_id = response_id
-                    yield model.StartItem(response_id=response_id)
-                if (
-                    event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison] gcp gemini will return None usage field
-                ):
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
-                if event.model:
-                    metadata_tracker.set_model_name(event.model)
-                if provider := getattr(event, "provider", None):
-                    metadata_tracker.set_provider(str(provider))
-
-                if len(event.choices) == 0:
-                    continue
-                delta = event.choices[0].delta
-
-                # Support Kimi K2's usage field in choice
-                if hasattr(event.choices[0], "usage") and getattr(event.choices[0], "usage"):
-                    metadata_tracker.set_usage(
-                        convert_usage(
-                            openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
-                            param.context_limit,
-                        )
-                    )
-
-                # Reasoning
-                reasoning_content = ""
-                if hasattr(delta, "reasoning") and getattr(delta, "reasoning"):
-                    reasoning_content = getattr(delta, "reasoning")
-                if hasattr(delta, "reasoning_content") and getattr(delta, "reasoning_content"):
-                    reasoning_content = getattr(delta, "reasoning_content")
-                if reasoning_content:
-                    metadata_tracker.record_token()
-                    stage = "reasoning"
-                    accumulated_reasoning.append(reasoning_content)
-
-                # Assistant
-                if delta.content and (
-                    stage == "assistant" or delta.content.strip()
-                ):  # Process all content in assistant stage, filter empty content in reasoning stage
-                    metadata_tracker.record_token()
-                    if stage == "reasoning":
-                        for item in flush_reasoning_items():
-                            yield item
-                    elif stage == "tool":
-                        for item in flush_tool_call_items():
-                            yield item
-                    stage = "assistant"
-                    accumulated_content.append(delta.content)
-                    yield model.AssistantMessageDelta(
-                        content=delta.content,
-                        response_id=response_id,
-                    )
-
-                # Tool
-                if delta.tool_calls and len(delta.tool_calls) > 0:
-                    metadata_tracker.record_token()
-                    if stage == "reasoning":
-                        for item in flush_reasoning_items():
-                            yield item
-                    elif stage == "assistant":
-                        for item in flush_assistant_items():
-                            yield item
-                    stage = "tool"
-                    # Emit ToolCallStartItem for new tool calls
-                    for tc in delta.tool_calls:
-                        if tc.index not in emitted_tool_start_indices and tc.function and tc.function.name:
-                            emitted_tool_start_indices.add(tc.index)
-                            yield model.ToolCallStartItem(
-                                response_id=response_id,
-                                call_id=tc.id or "",
-                                name=tc.function.name,
-                            )
-                    accumulated_tool_calls.add(delta.tool_calls)
-        except (RateLimitError, APIError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
-
-        # Finalize
-        for item in flush_reasoning_items():
-            yield item
+        log_debug(
+            json.dumps({**payload, **extra_body}, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
 
-        for item in flush_assistant_items():
-            yield item
+        try:
+            stream = await self.client.chat.completions.create(
+                **payload,
+                extra_body=extra_body,
+                extra_headers=extra_headers,
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()
+            return
+
+        reasoning_handler = DefaultReasoningHandler(
+            param_model=str(param.model),
+            response_id=None,
+        )
 
-        if stage == "tool":
-            for tool_call_item in flush_tool_call_items():
-                yield tool_call_item
+        def on_event(event: Any) -> None:
+            log_debug(
+                event.model_dump_json(exclude_none=True),
+                style="blue",
+                debug_type=DebugType.LLM_STREAM,
+            )
 
-        metadata_tracker.set_response_id(response_id)
-        yield metadata_tracker.finalize()
+        async for item in parse_chat_completions_stream(
+            stream,
+            param=param,
+            metadata_tracker=metadata_tracker,
+            reasoning_handler=reasoning_handler,
+            on_event=on_event,
+        ):
+            yield item

klaude_code/llm/openai_compatible/input.py

@@ -10,7 +10,8 @@ from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, m
 from klaude_code.protocol import llm_param, model
 
 
-def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
+def user_group_to_openai_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
+    """Convert a UserGroup to an OpenAI-compatible chat message."""
     parts: list[ChatCompletionContentPartParam] = []
     for text in group.text_parts:
         parts.append({"type": "text", "text": text + "\n"})
@@ -21,7 +22,8 @@ def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
     return {"role": "user", "content": parts}
 
 
-def _tool_group_to_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
+def tool_group_to_openai_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
+    """Convert a ToolGroup to an OpenAI-compatible chat message."""
     merged_text = merge_reminder_text(
         group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
         group.reminder_texts,
@@ -82,9 +84,9 @@ def convert_history_to_input(
     for group in parse_message_groups(history):
         match group:
             case UserGroup():
-                messages.append(_user_group_to_message(group))
+                messages.append(user_group_to_openai_message(group))
             case ToolGroup():
-                messages.append(_tool_group_to_message(group))
+                messages.append(tool_group_to_openai_message(group))
             case AssistantGroup():
                 messages.append(_assistant_group_to_message(group))
 

klaude_code/llm/openai_compatible/stream.py

@@ -0,0 +1,273 @@
+"""Shared stream processing utilities for Chat Completions streaming.
+
+This module provides reusable primitives for OpenAI-compatible providers:
+
+- ``StreamStateManager``: accumulates assistant content and tool calls.
+- ``ReasoningHandlerABC``: provider-specific reasoning extraction + buffering.
+- ``parse_chat_completions_stream``: shared stream loop that emits ConversationItems.
+
+OpenRouter uses the same OpenAI Chat Completions API surface but differs in
+how reasoning is represented (``reasoning_details`` vs ``reasoning_content``).
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, Callable
+from dataclasses import dataclass
+from typing import Any, Literal, cast
+
+import httpx
+import openai
+import openai.types
+import pydantic
+from openai import AsyncStream
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
+from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.protocol import llm_param, model
+
+StreamStage = Literal["waiting", "reasoning", "assistant", "tool"]
+
+
+class StreamStateManager:
+    """Manages streaming state and provides flush operations for accumulated content.
+
+    This class encapsulates the common state management logic used by both
+    OpenAI-compatible and OpenRouter clients, reducing code duplication.
+    """
+
+    def __init__(
+        self,
+        param_model: str,
+        response_id: str | None = None,
+        reasoning_flusher: Callable[[], list[model.ConversationItem]] | None = None,
+    ):
+        self.param_model = param_model
+        self.response_id = response_id
+        self.stage: StreamStage = "waiting"
+        self.accumulated_reasoning: list[str] = []
+        self.accumulated_content: list[str] = []
+        self.accumulated_tool_calls: ToolCallAccumulatorABC = BasicToolCallAccumulator()
+        self.emitted_tool_start_indices: set[int] = set()
+        self._reasoning_flusher = reasoning_flusher
+
+    def set_response_id(self, response_id: str) -> None:
+        """Set the response ID once received from the stream."""
+        self.response_id = response_id
+        self.accumulated_tool_calls.response_id = response_id  # pyright: ignore[reportAttributeAccessIssue]
+
+    def flush_reasoning(self) -> list[model.ConversationItem]:
+        """Flush accumulated reasoning content and return items."""
+        if self._reasoning_flusher is not None:
+            return self._reasoning_flusher()
+        if not self.accumulated_reasoning:
+            return []
+        item = model.ReasoningTextItem(
+            content="".join(self.accumulated_reasoning),
+            response_id=self.response_id,
+            model=self.param_model,
+        )
+        self.accumulated_reasoning = []
+        return [item]
+
+    def flush_assistant(self) -> list[model.ConversationItem]:
+        """Flush accumulated assistant content and return items."""
+        if not self.accumulated_content:
+            return []
+        item = model.AssistantMessageItem(
+            content="".join(self.accumulated_content),
+            response_id=self.response_id,
+        )
+        self.accumulated_content = []
+        return [item]
+
+    def flush_tool_calls(self) -> list[model.ToolCallItem]:
+        """Flush accumulated tool calls and return items."""
+        items: list[model.ToolCallItem] = self.accumulated_tool_calls.get()
+        if items:
+            self.accumulated_tool_calls.chunks_by_step = []  # pyright: ignore[reportAttributeAccessIssue]
+        return items
+
+    def flush_all(self) -> list[model.ConversationItem]:
+        """Flush all accumulated content in order: reasoning, assistant, tool calls."""
+        items: list[model.ConversationItem] = []
+        items.extend(self.flush_reasoning())
+        items.extend(self.flush_assistant())
+        if self.stage == "tool":
+            items.extend(self.flush_tool_calls())
+        return items
+
+
+@dataclass(slots=True)
+class ReasoningDeltaResult:
+    """Result of processing a single provider delta for reasoning signals."""
+
+    handled: bool
+    outputs: list[str | model.ConversationItem]
+
+
+class ReasoningHandlerABC(ABC):
+    """Provider-specific reasoning handler for Chat Completions streaming."""
+
+    @abstractmethod
+    def set_response_id(self, response_id: str | None) -> None:
+        """Update the response identifier used for emitted items."""
+
+    @abstractmethod
+    def on_delta(self, delta: object) -> ReasoningDeltaResult:
+        """Process a single delta and return ordered reasoning outputs."""
+
+    @abstractmethod
+    def flush(self) -> list[model.ConversationItem]:
+        """Flush buffered reasoning content (usually at stage transition/finalize)."""
+
+
+class DefaultReasoningHandler(ReasoningHandlerABC):
+    """Handles OpenAI-compatible reasoning fields (reasoning_content / reasoning)."""
+
+    def __init__(
+        self,
+        *,
+        param_model: str,
+        response_id: str | None,
+    ) -> None:
+        self._param_model = param_model
+        self._response_id = response_id
+        self._accumulated: list[str] = []
+
+    def set_response_id(self, response_id: str | None) -> None:
+        self._response_id = response_id
+
+    def on_delta(self, delta: object) -> ReasoningDeltaResult:
+        reasoning_content = getattr(delta, "reasoning_content", None) or getattr(delta, "reasoning", None) or ""
+        if not reasoning_content:
+            return ReasoningDeltaResult(handled=False, outputs=[])
+        text = str(reasoning_content)
+        self._accumulated.append(text)
+        return ReasoningDeltaResult(handled=True, outputs=[text])
+
+    def flush(self) -> list[model.ConversationItem]:
+        if not self._accumulated:
+            return []
+        item = model.ReasoningTextItem(
+            content="".join(self._accumulated),
+            response_id=self._response_id,
+            model=self._param_model,
+        )
+        self._accumulated = []
+        return [item]
+
+
+async def parse_chat_completions_stream(
+    stream: AsyncStream[ChatCompletionChunk],
+    *,
+    param: llm_param.LLMCallParameter,
+    metadata_tracker: MetadataTracker,
+    reasoning_handler: ReasoningHandlerABC,
+    on_event: Callable[[object], None] | None = None,
+) -> AsyncGenerator[model.ConversationItem]:
+    """Parse OpenAI Chat Completions stream into ConversationItems.
+
+    This is shared by OpenAI-compatible and OpenRouter clients.
+    """
+
+    state = StreamStateManager(
+        param_model=str(param.model),
+        reasoning_flusher=reasoning_handler.flush,
+    )
+
+    try:
+        async for event in stream:
+            if on_event is not None:
+                on_event(event)
+
+            if not state.response_id and (event_id := getattr(event, "id", None)):
+                state.set_response_id(str(event_id))
+                reasoning_handler.set_response_id(str(event_id))
+                yield model.StartItem(response_id=str(event_id))
+
+            if (event_usage := getattr(event, "usage", None)) is not None:
+                metadata_tracker.set_usage(convert_usage(event_usage, param.context_limit, param.max_tokens))
+            if event_model := getattr(event, "model", None):
+                metadata_tracker.set_model_name(str(event_model))
+            if provider := getattr(event, "provider", None):
+                metadata_tracker.set_provider(str(provider))
+
+            choices = cast(Any, getattr(event, "choices", None))
+            if not choices:
+                continue
+
+            # Support Moonshot Kimi K2's usage field in choice
+            choice0 = choices[0]
+            if choice_usage := getattr(choice0, "usage", None):
+                try:
+                    usage = openai.types.CompletionUsage.model_validate(choice_usage)
+                    metadata_tracker.set_usage(convert_usage(usage, param.context_limit, param.max_tokens))
+                except pydantic.ValidationError:
+                    pass
+
+            delta = cast(Any, getattr(choice0, "delta", None))
+            if delta is None:
+                continue
+
+            # Reasoning
+            reasoning_result = reasoning_handler.on_delta(delta)
+            if reasoning_result.handled:
+                state.stage = "reasoning"
+                for output in reasoning_result.outputs:
+                    if isinstance(output, str):
+                        if not output:
+                            continue
+                        metadata_tracker.record_token()
+                        yield model.ReasoningTextDelta(content=output, response_id=state.response_id)
+                    else:
+                        yield output
+
+            # Assistant
+            if (content := getattr(delta, "content", None)) and (state.stage == "assistant" or str(content).strip()):
+                metadata_tracker.record_token()
+                if state.stage == "reasoning":
+                    for item in state.flush_reasoning():
+                        yield item
+                elif state.stage == "tool":
+                    for item in state.flush_tool_calls():
+                        yield item
+                state.stage = "assistant"
+                state.accumulated_content.append(str(content))
+                yield model.AssistantMessageDelta(
+                    content=str(content),
+                    response_id=state.response_id,
+                )
+
+            # Tool
+            if (tool_calls := getattr(delta, "tool_calls", None)) and len(tool_calls) > 0:
+                metadata_tracker.record_token()
+                if state.stage == "reasoning":
+                    for item in state.flush_reasoning():
+                        yield item
+                elif state.stage == "assistant":
+                    for item in state.flush_assistant():
+                        yield item
+                state.stage = "tool"
+                for tc in tool_calls:
+                    if tc.index not in state.emitted_tool_start_indices and tc.function and tc.function.name:
+                        state.emitted_tool_start_indices.add(tc.index)
+                        yield model.ToolCallStartItem(
+                            response_id=state.response_id,
+                            call_id=tc.id or "",
+                            name=tc.function.name,
+                        )
+                state.accumulated_tool_calls.add(tool_calls)
+    except (openai.OpenAIError, httpx.HTTPError) as e:
+        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+
+    flushed_items = state.flush_all()
+    if flushed_items:
+        metadata_tracker.record_token()
+    for item in flushed_items:
+        yield item
+
+    metadata_tracker.set_response_id(state.response_id)
+    yield metadata_tracker.finalize()

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -1,9 +1,25 @@
+import re
 from abc import ABC, abstractmethod
 
 from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
 from pydantic import BaseModel, Field
 
 from klaude_code.protocol import model
+from klaude_code.trace.log import log_debug
+
+
+def normalize_tool_name(name: str) -> str:
+    """Normalize tool name from Gemini-3 format.
+
+    Gemini-3 sometimes returns tool names in format like 'tool_Edit_mUoY2p3W3r3z8uO5P2nZ'.
+    This function extracts the actual tool name (e.g., 'Edit').
+    """
+    match = re.match(r"^tool_([A-Za-z]+)_[A-Za-z0-9]+$", name)
+    if match:
+        normalized = match.group(1)
+        log_debug(f"Gemini-3 tool name normalized: {name} -> {normalized}", style="yellow")
+        return normalized
+    return name
 
 
 class ToolCallAccumulatorABC(ABC):
@@ -74,7 +90,7 @@ class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
             if first_chunk.function is None:
                 continue
             if first_chunk.function.name:
-                result[-1].name = first_chunk.function.name
+                result[-1].name = normalize_tool_name(first_chunk.function.name)
             if first_chunk.function.arguments:
                 result[-1].arguments += first_chunk.function.arguments
         return result