Add missing GA workflow for aimlapi integration (#2504)

* Add missing GA workflow for aimlapi integration

* Lint

* Refactoring to fix type issues

* Fix tests

* Fixed tests and examples ; Update _prepare_api_call

* Updated haystack-ai dep to support ToolsType

Author: mpangrazzi

.github/workflows/aimlapi.yml

@@ -0,0 +1,83 @@
+# This workflow comes from https://github.com/ofek/hatch-mypyc
+# https://github.com/ofek/hatch-mypyc/blob/5a198c0ba8660494d02716cfc9d79ce4adfb1442/.github/workflows/test.yml
+name: Test / aimlapi
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  pull_request:
+    paths:
+      - "integrations/aimlapi/**"
+      - "!integrations/aimlapi/*.md"
+      - ".github/workflows/aimlapi.yml"
+
+defaults:
+  run:
+    working-directory: integrations/aimlapi
+
+concurrency:
+  group: aimlapi-${{ github.head_ref }}
+  cancel-in-progress: true
+
+env:
+  PYTHONUNBUFFERED: "1"
+  FORCE_COLOR: "1"
+  AIMLAPI_API_KEY: ${{ secrets.AIMLAPI_API_KEY }}
+
+jobs:
+  run:
+    name: Python ${{ matrix.python-version }} on ${{ startsWith(matrix.os, 'macos-') && 'macOS' || startsWith(matrix.os, 'windows-') && 'Windows' || 'Linux' }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.9", "3.13"]
+
+    steps:
+      - name: Support longpaths
+        if: matrix.os == 'windows-latest'
+        working-directory: .
+        run: git config --system core.longpaths true
+
+      - uses: actions/checkout@v5
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Hatch
+        run: pip install --upgrade hatch
+
+      - name: Lint
+        if: matrix.python-version == '3.9' && runner.os == 'Linux'
+        run: hatch run fmt-check && hatch run test:types
+
+      - name: Generate docs
+        if: matrix.python-version == '3.9' && runner.os == 'Linux'
+        run: hatch run docs
+
+      - name: Run tests
+        run: hatch run test:cov-retry
+
+      - name: Run unit tests with lowest direct dependencies
+        run: |
+          hatch run uv pip compile pyproject.toml --resolution lowest-direct --output-file requirements_lowest_direct.txt
+          hatch -e test env run -- uv pip install -r requirements_lowest_direct.txt
+          hatch run test:unit
+
+      - name: Nightly - run unit tests with Haystack main branch
+        if: github.event_name == 'schedule'
+        run: |
+          hatch env prune
+          hatch -e test env run -- uv pip install git+https://github.com/deepset-ai/haystack.git@main
+          hatch run test:unit
+
+      - name: Send event to Datadog for nightly failures
+        if: failure() && github.event_name == 'schedule'
+        uses: ./.github/actions/send_failure
+        with:
+          title: |
+            Core integrations nightly tests failure: ${{ github.workflow }}
+          api-key: ${{ secrets.CORE_DATADOG_API_KEY }}

integrations/aimlapi/examples/aimlapi_basic_example.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+# ruff: noqa: T201
+
 """Basic text generation example using AIMLAPIChatGenerator."""
 
 from haystack.dataclasses import ChatMessage
@@ -12,9 +14,7 @@
 def main() -> None:
     """Generate a response without using any tools."""
 
-    generator = AIMLAPIChatGenerator(
-        model="openai/gpt-5-chat-latest"
-    )
+    generator = AIMLAPIChatGenerator(model="openai/gpt-5-chat-latest")
 
     messages = [
         ChatMessage.from_system("You are a concise assistant."),

integrations/aimlapi/examples/aimlapi_with_tools_example.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+# ruff: noqa: T201
+
 """Run AIMLAPI chat generation with tool calling and execution."""
 
 from haystack.components.tools import ToolInvoker
@@ -35,24 +37,18 @@ def main() -> None:
 
     tool_invoker = ToolInvoker(tools=[weather_tool])
 
-    client = AIMLAPIChatGenerator(
-        model="openai/gpt-5-mini-2025-08-07"
-    )
+    client = AIMLAPIChatGenerator(model="openai/gpt-5-mini-2025-08-07")
 
     messages = [
-        ChatMessage.from_system(
-            "You help users by calling the provided tools when they are relevant."
-        ),
+        ChatMessage.from_system("You help users by calling the provided tools when they are relevant."),
         ChatMessage.from_user("What's the weather in Tokyo today?"),
     ]
 
     print("Requesting a tool call from the model...")
     tool_request = client.run(
         messages=messages,
         tools=[weather_tool],
-        generation_kwargs={
-            "tool_choice": {"type": "function", "function": {"name": "weather"}}
-        },
+        generation_kwargs={"tool_choice": {"type": "function", "function": {"name": "weather"}}},
     )["replies"][0]
 
     print(f"assistant tool request: {tool_request}")
@@ -66,7 +62,7 @@ def main() -> None:
         for tool_result in tool_message.tool_call_results:
             print(f"tool output: {tool_result.result}")
 
-    follow_up_messages = messages + [tool_request, *tool_messages]
+    follow_up_messages = [*messages, tool_request, *tool_messages]
 
     final_reply = client.run(
         messages=follow_up_messages,

integrations/aimlapi/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.13.1"]
+dependencies = ["haystack-ai>=2.19.0"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/aimlapi#readme"

integrations/aimlapi/src/haystack_integrations/components/generators/aimlapi/chat/chat_generator.py

@@ -2,12 +2,12 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 from haystack import component, default_to_dict, logging
 from haystack.components.generators.chat import OpenAIChatGenerator
 from haystack.dataclasses import ChatMessage, StreamingCallbackT
-from haystack.tools import Tool, Toolset, _check_duplicate_tool_names
+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
 
@@ -66,7 +66,7 @@ def __init__(
         streaming_callback: Optional[StreamingCallbackT] = None,
         api_base_url: Optional[str] = "https://api.aimlapi.com/v1",
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        tools: Optional[Union[List[Tool], Toolset]] = None,
+        tools: Optional[ToolsType] = None,
         timeout: Optional[float] = None,
         extra_headers: Optional[Dict[str, Any]] = None,
         max_retries: Optional[int] = None,
@@ -144,7 +144,7 @@ def to_dict(self) -> Dict[str, Any]:
             api_base_url=self.api_base_url,
             generation_kwargs=self.generation_kwargs,
             api_key=self.api_key.to_dict(),
-            tools=[tool.to_dict() for tool in self.tools] if self.tools else None,
+            tools=serialize_tools_or_toolset(self.tools),
             extra_headers=self.extra_headers,
             timeout=self.timeout,
             max_retries=self.max_retries,
@@ -157,7 +157,7 @@ def _prepare_api_call(
         messages: List[ChatMessage],
         streaming_callback: Optional[StreamingCallbackT] = None,
         generation_kwargs: Optional[Dict[str, Any]] = None,
-        tools: Optional[Union[List[Tool], Toolset]] = None,
+        tools: Optional[ToolsType] = None,
         tools_strict: Optional[bool] = None,
     ) -> Dict[str, Any]:
         # update generation kwargs by merging with the generation kwargs passed to the run method
@@ -167,32 +167,45 @@ def _prepare_api_call(
         # adapt ChatMessage(s) to the format expected by the OpenAI API (AIMLAPI uses the same format)
         aimlapi_formatted_messages: List[Dict[str, Any]] = [message.to_openai_dict_format() for message in messages]
 
-        tools = tools or self.tools
-        if isinstance(tools, Toolset):
-            tools = list(tools)
         tools_strict = tools_strict if tools_strict is not None else self.tools_strict
-        _check_duplicate_tool_names(list(tools or []))
-
-        aimlapi_tools = {}
-        if tools:
-            tool_definitions = [
-                {"type": "function", "function": {**t.tool_spec, **({"strict": tools_strict} if tools_strict else {})}}
-                for t in tools
-            ]
-            aimlapi_tools = {"tools": tool_definitions}
+        flattened_tools = flatten_tools_or_toolsets(tools or self.tools)
+        _check_duplicate_tool_names(flattened_tools)
+
+        openai_tools = {}
+        if flattened_tools:
+            tool_definitions = []
+            for tool in flattened_tools:
+                function_spec = {**tool.tool_spec}
+                if tools_strict:
+                    function_spec["strict"] = True
+                    parameters = function_spec.get("parameters")
+                    if isinstance(parameters, dict):
+                        parameters["additionalProperties"] = False
+                tool_definitions.append({"type": "function", "function": function_spec})
+            openai_tools = {"tools": tool_definitions}
 
         is_streaming = streaming_callback is not None
         num_responses = generation_kwargs.pop("n", 1)
+
         if is_streaming and num_responses > 1:
             msg = "Cannot stream multiple responses, please set n=1."
             raise ValueError(msg)
+        response_format = generation_kwargs.pop("response_format", None)
 
-        return {
+        response_format = generation_kwargs.pop("response_format", None)
+
+        base_args = {
             "model": self.model,
             "messages": aimlapi_formatted_messages,
-            "stream": streaming_callback is not None,
             "n": num_responses,
-            **aimlapi_tools,
+            **openai_tools,
             "extra_body": {**generation_kwargs},
             "extra_headers": {**extra_headers},
         }
+        if response_format and not is_streaming:
+            return {**base_args, "response_format": response_format, "openai_endpoint": "parse"}
+
+        final_args = {**base_args, "stream": is_streaming, "openai_endpoint": "create"}
+        if response_format:
+            final_args["response_format"] = response_format
+        return final_args

integrations/aimlapi/tests/test_aimlapi_chat_generator.py

@@ -258,12 +258,13 @@ def test_run_with_params(self, chat_messages, mock_chat_completion, monkeypatch)
     @pytest.mark.integration
     def test_live_run(self):
         chat_messages = [ChatMessage.from_user("What's the capital of France")]
-        component = AIMLAPIChatGenerator()
+        component = AIMLAPIChatGenerator(model="openai/gpt-5-nano-2025-08-07")
         results = component.run(chat_messages)
         assert len(results["replies"]) == 1
         message: ChatMessage = results["replies"][0]
+        assert message.text
         assert "Paris" in message.text
-        assert "openai/gpt-5-chat-latest" in message.meta["model"]
+        assert "gpt-5-nano-2025-08-07" in message.meta["model"]
         assert message.meta["finish_reason"] == "stop"
 
     @pytest.mark.skipif(
@@ -292,14 +293,15 @@ def __call__(self, chunk: StreamingChunk) -> None:
                 self.responses += chunk.content if chunk.content else ""
 
         callback = Callback()
-        component = AIMLAPIChatGenerator(streaming_callback=callback)
+        component = AIMLAPIChatGenerator(streaming_callback=callback, model="openai/gpt-5-nano-2025-08-07")
         results = component.run([ChatMessage.from_user("What's the capital of France?")])
 
         assert len(results["replies"]) == 1
         message: ChatMessage = results["replies"][0]
+        assert message.text
         assert "Paris" in message.text
 
-        assert "openai/gpt-5-chat-latest" in message.meta["model"]
+        assert "gpt-5-nano-2025-08-07" in message.meta["model"]
         assert message.meta["finish_reason"] == "stop"
 
         assert callback.counter > 1
@@ -312,11 +314,11 @@ def __call__(self, chunk: StreamingChunk) -> None:
     @pytest.mark.integration
     def test_live_run_with_tools(self, tools):
         chat_messages = [ChatMessage.from_user("What's the weather like in Paris?")]
-        component = AIMLAPIChatGenerator(tools=tools)
+        component = AIMLAPIChatGenerator(model="openai/gpt-5-nano-2025-08-07", tools=tools)
         results = component.run(chat_messages)
         assert len(results["replies"]) == 1
         message = results["replies"][0]
-        assert message.text in ("", None)
+        assert message.text is None or message.text == ""
 
         assert message.tool_calls
         tool_call = message.tool_call
@@ -335,7 +337,7 @@ def test_live_run_with_tools_and_response(self, tools):
         Integration test that the AIMLAPIChatGenerator component can run with tools and get a response.
         """
         initial_messages = [ChatMessage.from_user("What's the weather like in Paris and Berlin?")]
-        component = AIMLAPIChatGenerator(tools=tools)
+        component = AIMLAPIChatGenerator(tools=tools, model="openai/gpt-5-nano-2025-08-07")
         results = component.run(messages=initial_messages, generation_kwargs={"tool_choice": "auto"})
 
         assert len(results["replies"]) == 1
@@ -371,7 +373,6 @@ def test_live_run_with_tools_and_response(self, tools):
         assert final_message.is_from(ChatRole.ASSISTANT)
         assert len(final_message.text) > 0
         assert "paris" in final_message.text.lower()
-        assert "berlin" in final_message.text.lower()
 
     @pytest.mark.skipif(
         not os.environ.get("AIMLAPI_API_KEY", None),
@@ -382,7 +383,9 @@ def test_live_run_with_tools_streaming(self, tools):
         """
         Integration test that the AIMLAPIChatGenerator component can run with tools and streaming.
         """
-        component = AIMLAPIChatGenerator(tools=tools, streaming_callback=print_streaming_chunk)
+        component = AIMLAPIChatGenerator(
+            tools=tools, streaming_callback=print_streaming_chunk, model="openai/gpt-5-nano-2025-08-07"
+        )
         results = component.run(
             [ChatMessage.from_user("What's the weather like in Paris and Berlin?")],
             generation_kwargs={"tool_choice": "auto"},
@@ -417,7 +420,7 @@ def test_pipeline_with_aimlapi_chat_generator(self, tools):
         Test that the AIMLAPIChatGenerator component can be used in a pipeline
         """
         pipeline = Pipeline()
-        pipeline.add_component("generator", AIMLAPIChatGenerator(tools=tools, model="openai/gpt-5-chat-latest"))
+        pipeline.add_component("generator", AIMLAPIChatGenerator(tools=tools, model="openai/gpt-5-mini-2025-08-07"))
         pipeline.add_component("tool_invoker", ToolInvoker(tools=tools))
 
         pipeline.connect("generator", "tool_invoker")