haystack-ai 3.4.0.dev20261005000357__tar.gz → 3.4.0.dev20261007000336__tar.gz

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: haystack-ai
-Version: 3.4.0.dev20261005000357
+Version: 3.4.0.dev20261007000336
 Summary: LLM framework to build customizable, production-ready LLM applications. Connect components (models, vector DBs, file converters) to pipelines or agents that can interact with your data.
 Project-URL: CI: GitHub, https://github.com/deepset-ai/haystack/actions
 Project-URL: Docs: RTD, https://haystack.deepset.ai/overview/intro

haystack_ai-3.4.0.dev20261007000336/VERSION.txt

@@ -0,0 +1 @@
+3.4.0.dev20261007000336

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/agents/agent.py

@@ -54,10 +54,13 @@ from haystack.tools import (
     Toolset,
     ToolsType,
     _check_duplicate_tool_names,
+    close_tools,
+    close_tools_async,
     deserialize_tools_or_toolset_inplace,
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
     warm_up_tools,
+    warm_up_tools_async,
 )
 from haystack.utils.async_utils import _execute_component_async
 from haystack.utils.callable_serialization import deserialize_callable, serialize_callable
@@ -241,7 +244,7 @@ class Agent:
 
     ```python
     from haystack.components.agents import Agent
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.components.generators.utils import print_streaming_chunk
     from haystack.dataclasses import ChatMessage
     from haystack.tools import tool
@@ -272,7 +275,7 @@ class Agent:
             "You are a helpful assistant. Use the 'search' tool to find information "
             "about a user's question and the 'calculator' tool to perform math."
         ),
-        chat_generator=OpenAIChatGenerator(),
+        chat_generator=OpenAIResponsesChatGenerator(),
         tools=[search, calculator],
         streaming_callback=print_streaming_chunk,
     )
@@ -293,7 +296,7 @@ class Agent:
 
     ```python
     from haystack.components.agents import Agent
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.tools import tool
     from typing import Annotated
 
@@ -308,7 +311,7 @@ class Agent:
         return f"[Translated '{text}' to {target_language}]"
 
     agent = Agent(
-        chat_generator=OpenAIChatGenerator(),
+        chat_generator=OpenAIResponsesChatGenerator(),
         tools=[translate],
         system_prompt="You are a helpful translation assistant.",
         user_prompt=\"\"\"{% message role="user"%}
@@ -347,7 +350,7 @@ class Agent:
     ```python
     from haystack.components.agents import Agent
     from haystack.components.agents.state import State
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.dataclasses import ChatMessage
     from haystack.hooks import hook
     from haystack.tools import tool
@@ -369,7 +372,7 @@ class Agent:
 
 
     agent = Agent(
-        chat_generator=OpenAIChatGenerator(),
+        chat_generator=OpenAIResponsesChatGenerator(),
         tools=[save_result],
         hooks={"on_exit": [require_save]},
     )
@@ -601,7 +604,7 @@ class Agent:
 
     async def warm_up_async(self) -> None:
         """Warm up the tools, hooks, and the underlying chat generator on the serving event loop."""
-        warm_up_tools(tools=self.tools)
+        await warm_up_tools_async(tools=self.tools)
         await warm_up_hooks_async(self.hooks)
         if hasattr(self.chat_generator, "warm_up_async"):
             await self.chat_generator.warm_up_async()
@@ -609,13 +612,15 @@ class Agent:
             self.chat_generator.warm_up()
 
     def close(self) -> None:
-        """Release the hooks' and the underlying chat generator's resources."""
+        """Release tools, hooks, and chat generator resources."""
+        close_tools(tools=self.tools)
         close_hooks(self.hooks)
         if hasattr(self.chat_generator, "close"):
             self.chat_generator.close()
 
     async def close_async(self) -> None:
-        """Release the hooks' and the underlying chat generator's async resources."""
+        """Release async tools, hooks, and chat generator resources."""
+        await close_tools_async(tools=self.tools)
         await close_hooks_async(self.hooks)
         if hasattr(self.chat_generator, "close_async"):
             await self.chat_generator.close_async()
@@ -817,9 +822,6 @@ class Agent:
 
         if isinstance(tools, (Toolset, list)):
             selected = cast(ToolsType, tools)  # mypy can't narrow the Union type from the isinstance checks
-            # Per-run tools are not covered by the Agent's own warm_up(), so warm them up here.
-            # warm_up() is expected to be idempotent, so re-warming on every run is cheap.
-            warm_up_tools(tools=selected)
             return _spawn_tools(tools=selected)
 
         raise TypeError(
@@ -847,6 +849,8 @@ class Agent:
             precedence, keys set only at initialization are kept.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
             When passing tool names, tools are selected from the Agent's originally configured tools.
+            Tool and Toolset objects passed here are warmed up automatically; the caller is responsible for
+            closing them if they hold resources.
         :param hook_context: Optional dictionary of request-scoped resources made available to hooks via
             `state.data.get("hook_context")`. Useful in web/server environments to provide per-request objects
             (e.g., WebSocket connections, async queues, Redis pub/sub clients) that a hook can use, for
@@ -874,6 +878,12 @@ class Agent:
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}
         self.warm_up()
+        # warm up tools passed at runtime
+        if isinstance(tools, Toolset):
+            tools_to_warm_up: ToolsType = tools
+        else:
+            tools_to_warm_up = [tool for tool in tools or [] if not isinstance(tool, str)]
+        warm_up_tools(tools=tools_to_warm_up)
 
         exe_context = self._initialize_fresh_execution(
             messages=messages,
@@ -934,6 +944,9 @@ class Agent:
             with the `generation_kwargs` passed at the chat generator's initialization: keys provided here take
             precedence, keys set only at initialization are kept.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
+            When passing tool names, tools are selected from the Agent's originally configured tools.
+            Tool and Toolset objects passed here are warmed up automatically; the caller is responsible for
+            closing them if they hold resources.
         :param hook_context: Optional dictionary of request-scoped resources made available to hooks via
             `state.data.get("hook_context")`. Useful in web/server environments to provide per-request objects
             (e.g., WebSocket connections, async queues, Redis pub/sub clients) that a hook can use, for
@@ -961,6 +974,12 @@ class Agent:
         """
         agent_inputs = {"messages": messages, "streaming_callback": streaming_callback, **kwargs}
         await self.warm_up_async()
+        # warm up tools passed at runtime
+        if isinstance(tools, Toolset):
+            tools_to_warm_up: ToolsType = tools
+        else:
+            tools_to_warm_up = [tool for tool in tools or [] if not isinstance(tool, str)]
+        await warm_up_tools_async(tools=tools_to_warm_up)
 
         exe_context = self._initialize_fresh_execution(
             messages=messages,

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/agents/utils.py

@@ -115,7 +115,7 @@ def _select_tools_by_name(configured_tools: ToolsType, names: list[str]) -> list
     Standalone Tools are kept when their name is requested. A Toolset with run-scoped state (one overriding
     `spawn()`, such as SearchableToolset) is replaced by a per-run copy carrying the requested names, so its
     dynamic behavior (search/lazy-loading) is preserved without mutating the shared, configured Toolset. Any
-    other Toolset is warmed up and reduced to the matching Tools.
+    other Toolset is reduced to the matching Tools. The caller must warm up the tools before selection.
 
     :param configured_tools: The tools configured on the Agent.
     :param names: The requested tool names.

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/builders/chat_prompt_builder.py

@@ -68,13 +68,13 @@ class ChatPromptBuilder:
 
     ```python
     from haystack.components.builders import ChatPromptBuilder
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.dataclasses import ChatMessage
     from haystack import Pipeline
 
     # no parameter init, we don't use any runtime template variables
     prompt_builder = ChatPromptBuilder()
-    llm = OpenAIChatGenerator(model="gpt-5-mini")
+    llm = OpenAIResponsesChatGenerator(model="gpt-5.6-luna")
 
     pipe = Pipeline()
     pipe.add_component("prompt_builder", prompt_builder)
@@ -88,26 +88,18 @@ class ChatPromptBuilder:
 
     res = pipe.run(data={"prompt_builder": {"template_variables": {"location": location, "language": language},
                                         "template": messages}})
-    print(res)
-    # >> {'llm': {'replies': [ChatMessage(_role=<ChatRole.ASSISTANT: 'assistant'>, _content=[TextContent(text=
-    # "Berlin is the capital city of Germany and one of the most vibrant
-    # and diverse cities in Europe. Here are some key things to know...Enjoy your time exploring the vibrant and dynamic
-    # capital of Germany!")], _name=None, _meta={'model': 'gpt-5-mini',
-    # 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 27, 'completion_tokens': 681, 'total_tokens':
-    # 708}})]}}
+    print(res["llm"]["replies"][0].text)
+    # >> Berlin is the capital city of Germany and one of the most vibrant and diverse cities in Europe. Here are some
+    # >> key things to know...Enjoy your time exploring the vibrant and dynamic capital of Germany!
 
     messages = [system_message, ChatMessage.from_user("What's the weather forecast for {{location}} in the next {{day_count}} days?")]
 
     res = pipe.run(data={"prompt_builder": {"template_variables": {"location": location, "day_count": "5"},
                                         "template": messages}})
 
-    print(res)
-    # >> {'llm': {'replies': [ChatMessage(_role=<ChatRole.ASSISTANT: 'assistant'>, _content=[TextContent(text=
-    # "Here is the weather forecast for Berlin in the next 5
-    # days:\\n\\nDay 1: Mostly cloudy with a high of 22°C (72°F) and...so it's always a good idea to check for updates
-    # closer to your visit.")], _name=None, _meta={'model': 'gpt-5-mini',
-    # 'index': 0, 'finish_reason': 'stop', 'usage': {'prompt_tokens': 37, 'completion_tokens': 201,
-    # 'total_tokens': 238}})]}}
+    print(res["llm"]["replies"][0].text)
+    # >> Here is the weather forecast for Berlin in the next 5 days: Day 1: Mostly cloudy with a high of 22°C (72°F)
+    # >> and...so it's always a good idea to check for updates closer to your visit.
     ```
 
     #### String prompt template

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/builders/prompt_builder.py

@@ -47,7 +47,7 @@ class PromptBuilder:
     ```python
     from haystack import Pipeline, Document
     from haystack.utils import Secret
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.components.builders.prompt_builder import PromptBuilder
 
     # in a real world use case documents could come from a retriever, web, or any other source
@@ -64,7 +64,7 @@ class PromptBuilder:
         \"\"\"
     p = Pipeline()
     p.add_component(instance=PromptBuilder(template=prompt_template), name="prompt_builder")
-    p.add_component(instance=OpenAIChatGenerator(api_key=Secret.from_env_var("OPENAI_API_KEY")), name="llm")
+    p.add_component(instance=OpenAIResponsesChatGenerator(api_key=Secret.from_env_var("OPENAI_API_KEY")), name="llm")
     p.connect("prompt_builder", "llm")
 
     question = "Where does Joe live?"

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/extractors/image/llm_document_content_extractor.py

@@ -74,8 +74,8 @@ class LLMDocumentContentExtractor:
     - If the LLM returns a **JSON object with multiple keys**, the value of ``document_content`` (if present) is
       written to content and all other keys are merged into the document's metadata.
 
-    The ChatGenerator can be configured to return JSON (e.g. ``response_format={"type": "json_object"}``
-    in ``generation_kwargs``).
+    The ChatGenerator can be configured to return JSON. For example, with the OpenAIResponsesChatGenerator, pass
+    `{"text": {"format": {"type": "json_schema", ...}}}` in `generation_kwargs` as shown in the usage example below.
 
     Documents that fail extraction are returned in ``failed_documents`` with ``content_extraction_error`` in metadata.
 
@@ -83,7 +83,7 @@ class LLMDocumentContentExtractor:
 
     ```python
     from haystack import Document
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.components.extractors.image import LLMDocumentContentExtractor
 
     prompt = \"\"\"
@@ -95,12 +95,13 @@ class LLMDocumentContentExtractor:
     Return this metadata as additional key-value pairs in the same JSON object.
     \"\"\"
 
-    chat_generator = OpenAIChatGenerator(
+    chat_generator = OpenAIResponsesChatGenerator(
             generation_kwargs={
-                    "response_format": {
-                        "type": "json_schema",
-                        "json_schema": {
+                    "text": {
+                        "format": {
+                            "type": "json_schema",
                             "name": "entity_extraction",
+                            "strict": False,
                             "schema": {
                                 "type": "object",
                                 "properties": {
@@ -148,7 +149,8 @@ class LLMDocumentContentExtractor:
         Initialize the LLMDocumentContentExtractor component.
 
         :param chat_generator: A ChatGenerator that supports vision input. Optionally configured for JSON
-            (e.g. ``response_format={"type": "json_object"}`` in ``generation_kwargs``).
+            (e.g. `{"text": {"format": {"type": "json_schema", ...}}}` in `generation_kwargs` when using the
+            OpenAIResponsesChatGenerator).
         :param prompt: Prompt for extraction. Must not contain Jinja variables.
         :param file_path_meta_field: The metadata field in the Document that contains the file path to the image or PDF.
         :param root_path: The root directory path where document files are located. If provided, file paths in

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/extractors/llm_metadata_extractor.py

@@ -46,7 +46,7 @@ class LLMMetadataExtractor:
     ```python
     from haystack import Document
     from haystack.components.extractors.llm_metadata_extractor import LLMMetadataExtractor
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
 
     NER_PROMPT = '''
     -Goal-
@@ -92,15 +92,13 @@ class LLMMetadataExtractor:
         Document(content="Hugging Face is a company that was founded in New York, USA and is known for its Transformers library")
     ]
 
-    chat_generator = OpenAIChatGenerator(
+    chat_generator = OpenAIResponsesChatGenerator(
         generation_kwargs={
-            "max_completion_tokens": 500,
-            "temperature": 0.0,
-            "seed": 0,
-            "response_format": {
-                "type": "json_schema",
-                "json_schema": {
+            "text": {
+                "format": {
+                    "type": "json_schema",
                     "name": "entity_extraction",
+                    "strict": True,
                     "schema": {
                         "type": "object",
                         "properties": {
@@ -167,8 +165,9 @@ class LLMMetadataExtractor:
             which points to a single document in the list of documents. For example, to access the content of the
             document, use `{{ document.content }}` in the prompt.
         :param chat_generator: a ChatGenerator instance which represents the LLM. In order for the component to work,
-            the LLM should be configured to return a JSON object. For example, when using the OpenAIChatGenerator, you
-            should pass `{"response_format": {"type": "json_object"}}` in the `generation_kwargs`.
+            the LLM should be configured to return a JSON object. For example, when using the
+            OpenAIResponsesChatGenerator, you should pass `{"text": {"format": {"type": "json_schema", ...}}}` in the
+            `generation_kwargs`.
         :param expected_keys: The keys expected in the JSON output from the LLM.
         :param page_range: A range of pages to extract metadata from. For example, page_range=['1', '3'] will extract
             metadata from the first and third pages of each document. It also accepts printable range strings, e.g.:

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/generators/chat/azure.py

@@ -18,7 +18,6 @@ from haystack.tools import (
     deserialize_tools_or_toolset_inplace,
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
-    warm_up_tools,
 )
 from haystack.utils import Secret, deserialize_callable, serialize_callable
 from haystack.utils.http_client import init_http_client
@@ -29,7 +28,7 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
     """
     Generates text using OpenAI's models on Azure.
 
-    It works with the gpt-4 - type models and supports streaming responses
+    It works with OpenAI's GPT models deployed on Azure and supports streaming responses
     from OpenAI API. It uses [ChatMessage](https://docs.haystack.deepset.ai/docs/chatmessage)
     format in input and output.
 
@@ -53,7 +52,7 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
     client = AzureOpenAIChatGenerator(
         azure_endpoint="<Your Azure endpoint e.g. `https://your-company.azure.openai.com/>",
         api_key=Secret.from_token("<your-api-key>"),
-        azure_deployment="<this is a model name, e.g. gpt-4.1-mini>")
+        azure_deployment="<this is a model name, e.g. gpt-5.6-luna>")
     response = client.run(messages)
     print(response)
     ```
@@ -64,7 +63,7 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
         "Natural Language Processing (NLP) is a branch of artificial intelligence that focuses on
          enabling computers to understand, interpret, and generate human language in a way that is useful.")],
          _name=None,
-         _meta={'model': 'gpt-4.1-mini', 'index': 0, 'finish_reason': 'stop',
+         _meta={'model': 'gpt-5.6-luna', 'index': 0, 'finish_reason': 'stop',
          'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]
     }
     ```
@@ -234,7 +233,6 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
 
         self.client: AzureOpenAI | None = None
         self.async_client: AsyncAzureOpenAI | None = None
-        self._tools_warmed_up = False
 
     def _client_kwargs(self) -> dict[str, Any]:
         timeout = self.timeout if self.timeout is not None else float(os.environ.get("OPENAI_TIMEOUT", "30.0"))
@@ -260,16 +258,10 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
             "azure_ad_token_provider": self.azure_ad_token_provider,
         }
 
-    def _warm_up_tools(self) -> None:
-        if not self._tools_warmed_up:
-            warm_up_tools(self.tools)
-            self._tools_warmed_up = True
-
     def warm_up(self) -> None:
         """
-        Warm up the tools and initialize the synchronous Azure OpenAI client.
+        Initialize the synchronous Azure OpenAI client.
         """
-        self._warm_up_tools()
         if self.client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md
@@ -281,9 +273,8 @@ class AzureOpenAIChatGenerator(OpenAIChatGenerator):
 
     async def warm_up_async(self) -> None:  # noqa: RUF029
         """
-        Warm up the tools and initialize the asynchronous Azure OpenAI client on the serving event loop.
+        Initialize the asynchronous Azure OpenAI client on the serving event loop.
         """
-        self._warm_up_tools()
         if self.async_client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/generators/chat/llm.py

@@ -26,10 +26,10 @@ class LLM(Agent):
     ### Usage examples
     ```python
     from haystack.components.generators.chat import LLM
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
 
     llm = LLM(
-        chat_generator=OpenAIChatGenerator(),
+        chat_generator=OpenAIResponsesChatGenerator(),
         system_prompt="You are a helpful translation assistant.",
         user_prompt="Summarize the following document: {{ document }}",
         required_variables=["document"],

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/generators/chat/openai.py

@@ -39,6 +39,7 @@ from haystack.dataclasses import (
     ToolCallDelta,
     select_streaming_callback,
 )
+from haystack.dataclasses.chat_message import _parse_openai_tool_call_arguments
 from haystack.dataclasses.streaming_chunk import _invoke_streaming_callback
 from haystack.tools import (
     ToolsType,
@@ -46,7 +47,6 @@ from haystack.tools import (
     deserialize_tools_or_toolset_inplace,
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
-    warm_up_tools,
 )
 from haystack.utils import Secret, deserialize_callable, serialize_callable
 from haystack.utils.http_client import init_http_client
@@ -59,7 +59,7 @@ class OpenAIChatGenerator:
     """
     Completes chats using OpenAI's large language models (LLMs).
 
-    It works with the gpt-4 and gpt-5 series models and supports streaming responses
+    It works with OpenAI's GPT models through the Chat Completions API and supports streaming responses
     from OpenAI API. It uses [ChatMessage](https://docs.haystack.deepset.ai/docs/chatmessage)
     format in input and output.
 
@@ -211,7 +211,6 @@ class OpenAIChatGenerator:
 
         self.client: OpenAI | None = None
         self.async_client: AsyncOpenAI | None = None
-        self._tools_warmed_up = False
 
     def _client_kwargs(self) -> dict[str, Any]:
         timeout = self.timeout if self.timeout is not None else float(os.environ.get("OPENAI_TIMEOUT", "30.0"))
@@ -226,16 +225,10 @@ class OpenAIChatGenerator:
             "max_retries": max_retries,
         }
 
-    def _warm_up_tools(self) -> None:
-        if not self._tools_warmed_up:
-            warm_up_tools(self.tools)
-            self._tools_warmed_up = True
-
     def warm_up(self) -> None:
         """
-        Warm up the tools and initialize the synchronous OpenAI client.
+        Initialize the synchronous OpenAI client.
         """
-        self._warm_up_tools()
         if self.client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md
@@ -247,9 +240,8 @@ class OpenAIChatGenerator:
 
     async def warm_up_async(self) -> None:  # noqa: RUF029
         """
-        Warm up the tools and initialize the asynchronous OpenAI client on the serving event loop.
+        Initialize the asynchronous OpenAI client on the serving event loop.
         """
-        self._warm_up_tools()
         if self.async_client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md
@@ -668,7 +660,7 @@ def _convert_chat_completion_to_chat_message(
         for openai_tc in openai_tool_calls:
             arguments_str = openai_tc.function.arguments
             try:
-                arguments = json.loads(arguments_str)
+                arguments = _parse_openai_tool_call_arguments(arguments_str)
                 tool_calls.append(ToolCall(id=openai_tc.id, tool_name=openai_tc.function.name, arguments=arguments))
             except json.JSONDecodeError:
                 logger.warning(

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/generators/chat/openai_responses.py

@@ -29,6 +29,7 @@ from haystack.dataclasses import (
     ToolCallDelta,
     select_streaming_callback,
 )
+from haystack.dataclasses.chat_message import _parse_openai_tool_call_arguments
 from haystack.dataclasses.streaming_chunk import FinishReason, _invoke_streaming_callback
 from haystack.tools import (
     ToolsType,
@@ -36,7 +37,6 @@ from haystack.tools import (
     deserialize_tools_or_toolset_inplace,
     flatten_tools_or_toolsets,
     serialize_tools_or_toolset,
-    warm_up_tools,
 )
 from haystack.utils import Secret, deserialize_callable, serialize_callable
 from haystack.utils.http_client import init_http_client
@@ -69,7 +69,7 @@ class OpenAIResponsesChatGenerator:
     """
     Completes chats using OpenAI's Responses API.
 
-    It works with the gpt-4 and o-series models and supports streaming responses
+    It works with OpenAI's GPT and o-series models and supports streaming responses
     from OpenAI API. It uses [ChatMessage](https://docs.haystack.deepset.ai/docs/chatmessage)
     format in input and output.
 
@@ -231,7 +231,6 @@ class OpenAIResponsesChatGenerator:
 
         self.client: OpenAI | None = None
         self.async_client: AsyncOpenAI | None = None
-        self._tools_warmed_up = False
 
     def _client_kwargs(self) -> dict[str, Any]:
         timeout = self.timeout if self.timeout is not None else float(os.environ.get("OPENAI_TIMEOUT", "30.0"))
@@ -247,20 +246,10 @@ class OpenAIResponsesChatGenerator:
             "max_retries": max_retries,
         }
 
-    def _warm_up_tools(self) -> None:
-        if not self._tools_warmed_up:
-            is_openai_tool = isinstance(self.tools, list) and bool(self.tools) and isinstance(self.tools[0], dict)
-            # We only warm up Haystack tools, not OpenAI/MCP tools
-            # The type ignore is needed because mypy cannot infer the type correctly
-            if not is_openai_tool:
-                warm_up_tools(self.tools)  # type: ignore[arg-type]
-            self._tools_warmed_up = True
-
     def warm_up(self) -> None:
         """
-        Warm up the tools and initialize the synchronous OpenAI client.
+        Initialize the synchronous OpenAI client.
         """
-        self._warm_up_tools()
         if self.client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md
@@ -272,9 +261,8 @@ class OpenAIResponsesChatGenerator:
 
     async def warm_up_async(self) -> None:  # noqa: RUF029
         """
-        Warm up the tools and initialize the asynchronous OpenAI client on the serving event loop.
+        Initialize the asynchronous OpenAI client on the serving event loop.
         """
-        self._warm_up_tools()
         if self.async_client is None:
             # openai>=3 annotates http_client as httpx2, but legacy httpx clients are supported at runtime.
             # https://github.com/openai/openai-python/blob/main/httpx2.md
@@ -692,7 +680,7 @@ def _convert_response_to_chat_message(responses: Response | ParsedResponse) -> C
 
         elif output.type == "function_call":
             try:
-                arguments = json.loads(output.arguments)
+                arguments = _parse_openai_tool_call_arguments(output.arguments)
                 tool_calls.append(
                     ToolCall(
                         id=output.id, tool_name=output.name, arguments=arguments, extra={"call_id": output.call_id}

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/joiners/answer_joiner.py

@@ -59,7 +59,7 @@ class AnswerJoiner:
 
     from haystack.core.pipeline import Pipeline
 
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.dataclasses import ChatMessage
 
 
@@ -68,8 +68,8 @@ class AnswerJoiner:
                 ChatMessage.from_user(query)]
 
     pipe = Pipeline()
-    pipe.add_component("llm_1", OpenAIChatGenerator())
-    pipe.add_component("llm_2", OpenAIChatGenerator())
+    pipe.add_component("llm_1", OpenAIResponsesChatGenerator())
+    pipe.add_component("llm_2", OpenAIResponsesChatGenerator())
     pipe.add_component("aba", AnswerBuilder())
     pipe.add_component("abb", AnswerBuilder())
     pipe.add_component("joiner", AnswerJoiner())

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/joiners/branch.py

@@ -33,7 +33,7 @@ class BranchJoiner:
     import json
 
     from haystack import Pipeline
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.components.joiners import BranchJoiner
     from haystack.components.validators import JsonSchemaValidator
     from haystack.dataclasses import ChatMessage
@@ -54,7 +54,7 @@ class BranchJoiner:
 
     # Add components to the pipeline
     pipe.add_component("joiner", BranchJoiner(list[ChatMessage]))
-    pipe.add_component("generator", OpenAIChatGenerator(model="gpt-4.1-mini"))
+    pipe.add_component("generator", OpenAIResponsesChatGenerator(model="gpt-5.6-luna"))
     pipe.add_component("validator", JsonSchemaValidator(json_schema=person_schema))
 
     # And connect them
@@ -64,7 +64,7 @@ class BranchJoiner:
 
     result = pipe.run(
         data={
-        "generator": {"generation_kwargs": {"response_format": {"type": "json_object"}}},
+        "generator": {"generation_kwargs": {"text": {"format": {"type": "json_object"}}}},
         "joiner": {"value": [ChatMessage.from_user("Create json from Peter Parker")]}}
     )
 
@@ -80,9 +80,9 @@ class BranchJoiner:
     connected components and also the type of data that `BranchJoiner` will send through its output.
 
     In the code example, `BranchJoiner` receives a looped back `list[ChatMessage]` from the `JsonSchemaValidator` and
-    sends it down to the `OpenAIChatGenerator` for re-generation. We can have multiple loopback connections in the
-    pipeline. In this instance, the downstream component is only one (the `OpenAIChatGenerator`), but the pipeline could
-    have more than one downstream component.
+    sends it down to the `OpenAIResponsesChatGenerator` for re-generation. We can have multiple loopback connections in
+    the pipeline. In this instance, the downstream component is only one (the `OpenAIResponsesChatGenerator`), but the
+    pipeline could have more than one downstream component.
     """
 
     def __init__(self, type_: type) -> None:

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/joiners/list_joiner.py

@@ -21,7 +21,7 @@ class ListJoiner:
     Usage example:
     ```python
     from haystack.components.builders import ChatPromptBuilder
-    from haystack.components.generators.chat import OpenAIChatGenerator
+    from haystack.components.generators.chat import OpenAIResponsesChatGenerator
     from haystack.dataclasses import ChatMessage
     from haystack import Pipeline
     from haystack.components.joiners import ListJoiner
@@ -39,8 +39,8 @@ class ListJoiner:
 
     prompt_builder = ChatPromptBuilder(template=user_message)
     feedback_prompt_builder = ChatPromptBuilder(template=feedback_message)
-    llm = OpenAIChatGenerator()
-    feedback_llm = OpenAIChatGenerator()
+    llm = OpenAIResponsesChatGenerator()
+    feedback_llm = OpenAIResponsesChatGenerator()
 
     pipe = Pipeline()
     pipe.add_component("prompt_builder", prompt_builder)

{haystack_ai-3.4.0.dev20261005000357 → haystack_ai-3.4.0.dev20261007000336}/haystack/components/joiners/string_joiner.py

@@ -19,9 +19,6 @@ class StringJoiner:
     from haystack.components.builders import PromptBuilder
     from haystack.core.pipeline import Pipeline
 
-    from haystack.components.generators.chat import OpenAIChatGenerator
-    from haystack.dataclasses import ChatMessage
-
     string_1 = "What's Natural Language Processing?"
     string_2 = "What is life?"