openrouter-haystack 1.2.0__tar.gz → 1.3.0__tar.gz

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [integrations/openrouter-v1.2.0] - 2026-07-06
+
+### 🐛 Bug Fixes
+
+- Support Haystack 3.0's lazy OpenAI client initialization in OpenAI-inheriting generators (#3536)
+
+### 🧪 Testing
+
+- Trust test modules under Haystack 3.0's deserialization allowlist (#3537)
+- Make Tool/Agent serialization assertions version-agnostic for Haystack 2.x/3.x (#3533)
+- Guard ToolInvoker imports so chat-generator tests run under Haystack 3.0 (#3535)
+
+
 ## [integrations/openrouter-v1.1.0] - 2026-06-08
 
 ### 🚀 Features
@@ -85,10 +98,6 @@
 
 ## [integrations/openrouter-v0.2.0] - 2025-07-01
 
-### 🚀 Features
-
-- Add OpenRouter integration (#1723)
-
 ### 🐛 Bug Fixes
 
 - Fix openrouter types + add py.typed (#2029)
@@ -103,4 +112,10 @@
 
 - Test: Remove `test_check_abnormal_completions` - already tested in Haystack (#1842)
 
+## [integrations/openrouter-v0.1.0] - 2025-05-16
+
+### 🚀 Features
+
+- Add OpenRouter integration (#1723)
+
 <!-- generated by git-cliff -->

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/LICENSE.txt

@@ -58,7 +58,7 @@ APPENDIX: How to apply the Apache License to your work.
 
 To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.
 
-Copyright [yyyy] [name of copyright owner]
+Copyright 2023-present deepset GmbH
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: openrouter-haystack
-Version: 1.2.0
+Version: 1.3.0
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/openrouter#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/openrouter
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 # openrouter-haystack
 
 [![PyPI - Version](https://img.shields.io/pypi/v/openrouter-haystack.svg)](https://pypi.org/project/openrouter-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openrouter-haystack.svg)](https://pypi.org/project/openrouterhaystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openrouter-haystack.svg)](https://pypi.org/project/openrouter-haystack)
 
 - [Integration page](https://haystack.deepset.ai/integrations/openrouter)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/openrouter/CHANGELOG.md)

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/README.md

@@ -1,7 +1,7 @@
 # openrouter-haystack
 
 [![PyPI - Version](https://img.shields.io/pypi/v/openrouter-haystack.svg)](https://pypi.org/project/openrouter-haystack)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openrouter-haystack.svg)](https://pypi.org/project/openrouterhaystack)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/openrouter-haystack.svg)](https://pypi.org/project/openrouter-haystack)
 
 - [Integration page](https://haystack.deepset.ai/integrations/openrouter)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/openrouter/CHANGELOG.md)

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/pyproject.toml

@@ -127,6 +127,7 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  "PLR0917",
   # Misc
   "B008",
   "S101",

{openrouter_haystack-1.2.0 → openrouter_haystack-1.3.0}/src/haystack_integrations/components/generators/openrouter/chat/chat_generator.py

@@ -2,24 +2,38 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
+import inspect
 import json
+from dataclasses import replace
 from typing import Any
 
 from haystack import component, default_to_dict, logging
 from haystack.components.generators.chat import OpenAIChatGenerator
-from haystack.components.generators.chat.openai import _check_finish_reason
-from haystack.components.generators.utils import _normalize_messages, _serialize_object
+from haystack.components.generators.chat.openai import (
+    _check_finish_reason,
+    _convert_chat_completion_chunk_to_streaming_chunk,
+)
+from haystack.components.generators.utils import (
+    _convert_streaming_chunks_to_chat_message,
+    _normalize_messages,
+    _serialize_object,
+)
 from haystack.dataclasses import (
     ChatMessage,
+    ComponentInfo,
     ReasoningContent,
     StreamingCallbackT,
+    StreamingChunk,
+    SyncStreamingCallbackT,
     ToolCall,
     select_streaming_callback,
 )
 from haystack.tools import ToolsType, _check_duplicate_tool_names, flatten_tools_or_toolsets, serialize_tools_or_toolset
 from haystack.utils import serialize_callable
 from haystack.utils.auth import Secret
-from openai.types.chat import ChatCompletion, ParsedChatCompletion
+from openai import AsyncStream, Stream
+from openai.types.chat import ChatCompletion, ChatCompletionChunk, ParsedChatCompletion
 from openai.types.chat.chat_completion import Choice
 
 logger = logging.getLogger(__name__)
@@ -101,6 +115,109 @@ def _convert_openrouter_completion_to_chat_message(
     return ChatMessage.from_assistant(text=text, tool_calls=tool_calls, meta=meta, reasoning=reasoning)
 
 
+def _convert_openrouter_chunk_to_streaming_chunks(
+    chunk: ChatCompletionChunk, previous_chunks: list[StreamingChunk], component_info: ComponentInfo
+) -> list[StreamingChunk]:
+    """
+    Convert an OpenRouter streaming chunk to StreamingChunks, including reasoning content.
+
+    A `StreamingChunk` holds either reasoning or content/tool calls, so a delta carrying both is split into a
+    reasoning chunk followed by the content or tool call chunk.
+    """
+    streaming_chunk = _convert_chat_completion_chunk_to_streaming_chunk(
+        chunk=chunk, previous_chunks=previous_chunks, component_info=component_info
+    )
+    # the parent converter ignores the `reasoning`/`reasoning_details` fields OpenRouter adds to the delta
+    reasoning = _extract_reasoning(chunk.choices[0].delta) if chunk.choices else None
+    has_payload = bool(streaming_chunk.content or streaming_chunk.tool_calls)
+    # the last chunk with reasoning, content, or tool calls tells which block the stream is currently in
+    last_block = next((c for c in reversed(previous_chunks) if c.reasoning or c.content or c.tool_calls), None)
+
+    streaming_chunks = []
+    if reasoning is not None:
+        details = reasoning.extra.get("reasoning_details", [])
+        # adopt the index of the first reasoning detail, as the parent does with the first tool call index
+        index = next((d["index"] for d in details if isinstance(d.get("index"), int)), 0)
+        reasoning_chunk = StreamingChunk(
+            content="",
+            reasoning=reasoning,
+            index=index,
+            start=last_block is None or last_block.reasoning is None or last_block.index != index,
+            # a reasoning-only delta replaces the parent's empty chunk, so it carries its finish reason
+            finish_reason=None if has_payload else streaming_chunk.finish_reason,
+            component_info=component_info,
+            meta=streaming_chunk.meta,
+        )
+        if not has_payload:
+            return [reasoning_chunk]
+        streaming_chunks.append(reasoning_chunk)
+        last_block = reasoning_chunk
+
+    if streaming_chunk.content:
+        # the parent converter marks the second chunk of a stream as start, assuming the first one only carries `role`,
+        # and gives text chunks index None when `role` is set. OpenRouter sets `role` on every chunk and can stream text
+        # in the first one, so derive start and index from the previous block instead. Text after tool calls keeps the
+        # parent's start and index, so the whitespace some models stream between tool calls gets no header.
+        if last_block is None:
+            streaming_chunk = replace(streaming_chunk, start=True)
+        elif last_block.reasoning is not None:
+            streaming_chunk = replace(streaming_chunk, start=True, index=(last_block.index or 0) + 1)
+        elif last_block.content:
+            streaming_chunk = replace(streaming_chunk, start=False, index=last_block.index)
+    elif streaming_chunk.tool_calls and last_block is not None:
+        # the parent converter uses the provider's tool call index as chunk index, which collides with the reasoning
+        # or text block before the tool calls, so shift the chunk index past that block. Later tool calls keep the
+        # shift of the first one, even if text is streamed between them. `ToolCallDelta.index` keeps the provider's
+        # index, which the tool calls are assembled by.
+        previous_tool_chunk = next((c for c in reversed(previous_chunks) if c.tool_calls), None)
+        if previous_tool_chunk is not None and previous_tool_chunk.tool_calls:
+            offset = (previous_tool_chunk.index or 0) - previous_tool_chunk.tool_calls[0].index
+        else:
+            offset = (last_block.index or 0) + 1
+        streaming_chunk = replace(streaming_chunk, index=streaming_chunk.tool_calls[0].index + offset)
+    streaming_chunks.append(streaming_chunk)
+    return streaming_chunks
+
+
+def _merge_reasoning_details(details: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    Merge streamed `reasoning_details` fragments into complete entries.
+
+    OpenRouter streams each reasoning detail as fragments sharing its `index` and `type`. String payloads are
+    concatenated in order, other fields keep their latest non-null value, such as a `signature` that only arrives
+    with the last fragment.
+    """
+    merged: dict[tuple[Any, Any], dict[str, Any]] = {}
+    for detail in details:
+        key = (detail.get("index"), detail.get("type"))
+        if key not in merged:
+            merged[key] = dict(detail)
+            continue
+        entry = merged[key]
+        for field, value in detail.items():
+            if field in ("text", "summary", "data") and isinstance(value, str):
+                entry[field] = (entry.get(field) or "") + value
+            elif value is not None:
+                entry[field] = value
+    return list(merged.values())
+
+
+def _convert_openrouter_streaming_chunks_to_chat_message(chunks: list[StreamingChunk]) -> ChatMessage:
+    """Connect OpenRouter streaming chunks into a single ChatMessage, keeping the merged `reasoning_details`."""
+    message = _convert_streaming_chunks_to_chat_message(chunks=chunks)
+    # the core helper only joins the reasoning text, but OpenRouter expects the details back in multi-turn conversations
+    details = [d for c in chunks if c.reasoning for d in c.reasoning.extra.get("reasoning_details", [])]
+    if not details:
+        return message
+    reasoning = ReasoningContent(
+        reasoning_text=message.reasoning.reasoning_text if message.reasoning else "",
+        extra={"reasoning_details": _merge_reasoning_details(details)},
+    )
+    return ChatMessage.from_assistant(
+        text=message.text, tool_calls=message.tool_calls, meta=message.meta, reasoning=reasoning
+    )
+
+
 @component
 class OpenRouterChatGenerator(OpenAIChatGenerator):
     """
@@ -118,7 +235,8 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
     - **Customizability**: Supports all parameters supported by the OpenRouter chat completion endpoint.
     - **Reasoning Support**: Extracts reasoning/thinking content from models that support it
       (e.g., DeepSeek R1, Claude with extended thinking) and stores it in the `ReasoningContent`
-      field on `ChatMessage`. Reasoning content is only captured for non-streaming requests.
+      field on `ChatMessage`. When streaming, reasoning is also passed to the `streaming_callback`
+      in `StreamingChunk.reasoning`.
 
     This component uses the ChatMessage format for structuring both input and output,
     ensuring coherent and contextually relevant responses in chat-based text generation scenarios.
@@ -190,7 +308,6 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
             - `random_seed`: The seed to use for random sampling.
             - `reasoning`: A dict to configure reasoning/thinking tokens for models that support it.
                 Example: `{"effort": "high"}` or `{"max_tokens": 2000}`.
-                Reasoning content is only captured for non-streaming requests.
                 See [OpenRouter reasoning docs](https://openrouter.ai/docs/use-cases/reasoning-tokens).
             - `response_format`: A JSON schema or a Pydantic model that enforces the structure of the model's response.
         :param tools:
@@ -321,6 +438,42 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
             final_args["response_format"] = response_format
         return final_args
 
+    def _handle_stream_response(
+        self, chat_completion: Stream[ChatCompletionChunk], callback: SyncStreamingCallbackT
+    ) -> list[ChatMessage]:
+        component_info = ComponentInfo.from_component(self)
+        chunks: list[StreamingChunk] = []
+        for chunk in chat_completion:
+            assert len(chunk.choices) <= 1, "Streaming responses should have at most one choice."
+            for streaming_chunk in _convert_openrouter_chunk_to_streaming_chunks(
+                chunk=chunk, previous_chunks=chunks, component_info=component_info
+            ):
+                chunks.append(streaming_chunk)
+                callback(streaming_chunk)
+        return [_convert_openrouter_streaming_chunks_to_chat_message(chunks=chunks)]
+
+    async def _handle_async_stream_response(
+        self, chat_completion: AsyncStream[ChatCompletionChunk], callback: StreamingCallbackT
+    ) -> list[ChatMessage]:
+        component_info = ComponentInfo.from_component(self)
+        chunks: list[StreamingChunk] = []
+        try:
+            async for chunk in chat_completion:
+                assert len(chunk.choices) <= 1, "Streaming responses should have at most one choice."
+                for streaming_chunk in _convert_openrouter_chunk_to_streaming_chunks(
+                    chunk=chunk, previous_chunks=chunks, component_info=component_info
+                ):
+                    chunks.append(streaming_chunk)
+                    # haystack-ai >= 3.0 also accepts sync callbacks in async runs, so only await async ones
+                    callback_result = callback(streaming_chunk)
+                    if inspect.isawaitable(callback_result):
+                        await callback_result
+        except asyncio.CancelledError:
+            # shield the close so the stream is released even though the task is being cancelled
+            await asyncio.shield(chat_completion.close())
+            raise
+        return [_convert_openrouter_streaming_chunks_to_chat_message(chunks=chunks)]
+
     @component.output_types(replies=list[ChatMessage])
     def run(
         self,
@@ -340,8 +493,9 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
         :param streaming_callback:
             A callback function that is called when a new token is received from the stream.
         :param generation_kwargs:
-            Additional keyword arguments for text generation. These parameters will
-            override the parameters passed during component initialization.
+            Additional keyword arguments for text generation. These are merged per key with the
+            `generation_kwargs` passed at initialization: keys provided here take precedence, keys set only
+            at initialization are kept.
             For details on OpenRouter API parameters, see
             [OpenRouter docs](https://openrouter.ai/docs/quickstart).
         :param tools: A list of Tool and/or Toolset objects, or a single Toolset for which the model can prepare calls.
@@ -363,16 +517,6 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
             init_callback=self.streaming_callback, runtime_callback=streaming_callback, requires_async=False
         )
 
-        # Reasoning content is reconstructed from the full response message, which is not available while
-        # streaming, so we warn the user that it will not be captured in this mode.
-        if streaming_callback is not None:
-            merged_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}
-            if merged_kwargs.get("reasoning"):
-                logger.warning(
-                    "Streaming with reasoning is active. Reasoning content will not be captured during "
-                    "streaming. Use non-streaming mode to extract reasoning content."
-                )
-
         api_args = self._prepare_api_call(
             messages=messages,
             streaming_callback=streaming_callback,
@@ -385,7 +529,6 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
         chat_completion = getattr(self.client.chat.completions, openai_endpoint)(**api_args)  # type: ignore[union-attr]
 
         if streaming_callback is not None:
-            # streaming uses the inherited handler so reasoning extraction is intentionally skipped
             completions = self._handle_stream_response(chat_completion, streaming_callback)
         else:
             assert isinstance(chat_completion, ChatCompletion), "Unexpected response type for non-streaming request."
@@ -419,7 +562,9 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
             A callback function that is called when a new token is received from the stream.
             Must be a coroutine.
         :param generation_kwargs:
-            Additional keyword arguments for text generation.
+            Additional keyword arguments for text generation. These are merged per key with the
+            `generation_kwargs` passed at initialization: keys provided here take precedence, keys set only
+            at initialization are kept.
         :param tools: A list of Tool and/or Toolset objects, or a single Toolset.
         :param tools_strict:
             Whether to enable strict schema adherence for tool calls.
@@ -442,16 +587,6 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
             init_callback=self.streaming_callback, runtime_callback=streaming_callback, requires_async=True
         )
 
-        # Reasoning content is reconstructed from the full response message, which is not available while
-        # streaming, so we warn the user that it will not be captured in this mode.
-        if streaming_callback is not None:
-            merged_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}
-            if merged_kwargs.get("reasoning"):
-                logger.warning(
-                    "Streaming with reasoning is active. Reasoning content will not be captured during "
-                    "streaming. Use non-streaming mode to extract reasoning content."
-                )
-
         api_args = self._prepare_api_call(
             messages=messages,
             streaming_callback=streaming_callback,
@@ -464,7 +599,6 @@ class OpenRouterChatGenerator(OpenAIChatGenerator):
         chat_completion = await getattr(self.async_client.chat.completions, openai_endpoint)(**api_args)  # type: ignore[union-attr]
 
         if streaming_callback is not None:
-            # streaming uses the inherited handler so reasoning extraction is intentionally skipped
             completions = await self._handle_async_stream_response(chat_completion, streaming_callback)
         else:
             assert isinstance(chat_completion, ChatCompletion), "Unexpected response type for non-streaming request."