llama-stack-haystack 1.1.1__tar.gz → 1.3.0__tar.gz

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [integrations/llama_stack-v1.2.0] - 2025-10-24
+
+### 🚀 Features
+
+- `LlamaStackChatGenerator` update tools param to ToolsType (#2436)
+
+### 📚 Documentation
+
+- Add pydoc configurations for Docusaurus (#2411)
+
+
+## [integrations/llama_stack-v1.1.1] - 2025-08-22
+
+
+### 🧹 Chores
+
+- Standardize readmes - part 2 (#2205)
+
+### 🌀 Miscellaneous
+
+- Fix: Remove openai pin in llama-stack integration (#2210)
+
 ## [integrations/llama_stack-v1.1.0] - 2025-08-08
 
 
@@ -12,7 +34,7 @@
 ### 🐛 Bug Fixes
 
 - Update the command for Llama Stack server (#2097)
-- Pin openai to `<=1.99.1` avoid errors in Llama Stack integration (#2169)
+- Pin openai to `<=1.99.2` avoid errors in Llama Stack integration (#2169)
 
 
 ## [integrations/llama_stack-v1.0.0] - 2025-07-11

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llama-stack-haystack
-Version: 1.1.1
+Version: 1.3.0
 Summary: Use Llama Stack framework for text generation
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama-stack#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.12
-Requires-Dist: haystack-ai>=2.14
+Requires-Dist: haystack-ai>=2.19.0
 Requires-Dist: llama-stack>=0.2.17
 Description-Content-Type: text/markdown
 

llama_stack_haystack-1.3.0/examples/chatgenerator_with_structured_outputs.py

@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: 2024-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+# This example demonstrates how to use the LlamaStackChatGenerator component
+# with structured outputs.
+# To run this example, you will need to
+# set up Llama Stack Server and have a model available
+
+from haystack.dataclasses import ChatMessage
+from pydantic import BaseModel
+
+from haystack_integrations.components.generators.llama_stack import LlamaStackChatGenerator
+
+
+class NobelPrizeInfo(BaseModel):
+    recipient_name: str
+    award_year: int
+    category: str
+    achievement_description: str
+    nationality: str
+
+
+chat_messages = [
+    ChatMessage.from_user(
+        "In 2021, American scientist David Julius received the Nobel Prize in"
+        " Physiology or Medicine for his groundbreaking discoveries on how the human body"
+        " senses temperature and touch."
+    )
+]
+component = LlamaStackChatGenerator(generation_kwargs={"response_format": NobelPrizeInfo})
+results = component.run(chat_messages)
+
+# print(results)

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/examples/llama-stack-with-tools.py

@@ -34,7 +34,7 @@ weather_tool = Tool(
 tool_invoker = ToolInvoker(tools=[weather_tool])
 
 client = LlamaStackChatGenerator(
-    model="llama3.2:3b",  # model name varies depending on the inference provider used for the Llama Stack Server.
+    model="ollama/llama3.2:3b",  # model depends on the inference provider used for the Llama Stack Server.
     api_base_url="http://localhost:8321/v1/openai/v1",
 )
 messages = [ChatMessage.from_user("What's the weather in Tokyo?")]

llama_stack_haystack-1.3.0/pydoc/config_docusaurus.yml

@@ -0,0 +1,28 @@
+loaders:
+- ignore_when_discovered:
+  - __init__
+  modules:
+  - haystack_integrations.components.generators.llama_stack.chat.chat_generator
+  search_path:
+  - ../src
+  type: haystack_pydoc_tools.loaders.CustomPythonLoader
+processors:
+- do_not_filter_modules: false
+  documented_only: true
+  expression: null
+  skip_empty_modules: true
+  type: filter
+- type: smart
+- type: crossref
+renderer:
+  description: Llama Stack integration for Haystack
+  id: integrations-llama-stack
+  markdown:
+    add_member_class_prefix: false
+    add_method_class_prefix: true
+    classdef_code_block: false
+    descriptive_class_title: false
+    descriptive_module_title: true
+    filename: llama_stack.md
+  title: Llama Stack
+  type: haystack_pydoc_tools.renderers.DocusaurusRenderer

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/pyproject.toml

@@ -20,7 +20,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.14", "llama-stack>=0.2.17"]
+dependencies = ["haystack-ai>=2.19.0", "llama-stack>=0.2.17"]
 
 [project.urls]
 Documentation = "https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/llama-stack#readme"
@@ -60,8 +60,8 @@ dependencies = [
 [tool.hatch.envs.test.scripts]
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
-all = 'pytest {args:tests}'
-cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+all = 'pytest --reruns 3 --reruns-delay 30 -x {args:tests}'
+cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
 
 types = "mypy -p haystack_integrations.components.generators.llama_stack {args}"
 
@@ -73,7 +73,7 @@ disallow_incomplete_defs = true
 
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py39"
 line-length = 120
 
 [tool.ruff.lint]

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/src/haystack_integrations/components/generators/llama_stack/chat/chat_generator.py

@@ -2,14 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional
 
 from haystack import component, default_from_dict, default_to_dict, logging
 from haystack.components.generators.chat import OpenAIChatGenerator
 from haystack.dataclasses import StreamingCallbackT
-from haystack.tools import Tool, Toolset, deserialize_tools_or_toolset_inplace, serialize_tools_or_toolset
+from haystack.tools import ToolsType, deserialize_tools_or_toolset_inplace, serialize_tools_or_toolset
 from haystack.utils import deserialize_callable, serialize_callable
 from haystack.utils.auth import Secret
+from openai.lib._pydantic import to_strict_json_schema
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +43,7 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
 
     messages = [ChatMessage.from_user("What's Natural Language Processing?")]
 
-    client = LlamaStackChatGenerator(model="llama3.2:3b")
+    client = LlamaStackChatGenerator(model="ollama/llama3.2:3b")
     response = client.run(messages)
     print(response)
 
@@ -49,7 +51,7 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
     is a branch of artificial intelligence
     >>that focuses on enabling computers to understand, interpret, and generate human language in a way that is
     >>meaningful and useful.')], _role=<ChatRole.ASSISTANT: 'assistant'>, _name=None,
-    >>_meta={'model': 'llama3.2:3b', 'index': 0, 'finish_reason': 'stop',
+    >>_meta={'model': 'ollama/llama3.2:3b', 'index': 0, 'finish_reason': 'stop',
     >>'usage': {'prompt_tokens': 15, 'completion_tokens': 36, 'total_tokens': 51}})]}
     """
 
@@ -60,12 +62,12 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
         api_base_url: str = "http://localhost:8321/v1/openai/v1",
         organization: Optional[str] = None,
         streaming_callback: Optional[StreamingCallbackT] = None,
-        generation_kwargs: Optional[Dict[str, Any]] = None,
+        generation_kwargs: Optional[dict[str, Any]] = None,
         timeout: Optional[int] = None,
-        tools: Optional[Union[List[Tool], Toolset]] = None,
+        tools: Optional[ToolsType] = None,
         tools_strict: bool = False,
         max_retries: Optional[int] = None,
-        http_client_kwargs: Optional[Dict[str, Any]] = None,
+        http_client_kwargs: Optional[dict[str, Any]] = None,
     ):
         """
         Creates an instance of LlamaStackChatGenerator. To use this chat generator,
@@ -94,12 +96,19 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
                 events as they become available, with the stream terminated by a data: [DONE] message.
             - `safe_prompt`: Whether to inject a safety prompt before all conversations.
             - `random_seed`: The seed to use for random sampling.
+            - `response_format`: A JSON schema or a Pydantic model that enforces the structure of the model's response.
+                If provided, the output will always be validated against this
+                format (unless the model returns a tool call).
+                For details, see the [OpenAI Structured Outputs documentation](https://platform.openai.com/docs/guides/structured-outputs).
+                Notes:
+                - For structured outputs with streaming,
+                  the `response_format` must be a JSON schema and not a Pydantic model.
         :param timeout:
             Timeout for client calls using OpenAI API. If not set, it defaults to either the
             `OPENAI_TIMEOUT` environment variable, or 30 seconds.
         :param tools:
-            A list of tools or a Toolset for which the model can prepare calls. This parameter can accept either a
-            list of `Tool` objects or a `Toolset` instance.
+            A list of Tool and/or Toolset objects, or a single Toolset for which the model can prepare calls.
+            Each tool should have a unique name.
         :param tools_strict:
             Whether to enable strict schema adherence for tool calls. If set to `True`, the model will follow exactly
             the schema provided in the `parameters` field of the tool definition, but this may increase latency.
@@ -129,7 +138,7 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
             http_client_kwargs=http_client_kwargs,
         )
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """
         Serialize this component to a dictionary.
 
@@ -137,13 +146,29 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
             The serialized component as a dictionary.
         """
         callback_name = serialize_callable(self.streaming_callback) if self.streaming_callback else None
+        generation_kwargs = self.generation_kwargs.copy()
+        response_format = generation_kwargs.get("response_format")
+        # If the response format is a Pydantic model, it's converted to openai's json schema format
+        # If it's already a json schema, it's left as is
+        if response_format and isinstance(response_format, type) and issubclass(response_format, BaseModel):
+            json_schema = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": response_format.__name__,
+                    "strict": True,
+                    "schema": to_strict_json_schema(response_format),
+                },
+            }
+
+            generation_kwargs["response_format"] = json_schema
+
         return default_to_dict(
             self,
             model=self.model,
             streaming_callback=callback_name,
             api_base_url=self.api_base_url,
             organization=self.organization,
-            generation_kwargs=self.generation_kwargs,
+            generation_kwargs=generation_kwargs,
             timeout=self.timeout,
             max_retries=self.max_retries,
             tools=serialize_tools_or_toolset(self.tools),
@@ -152,7 +177,7 @@ class LlamaStackChatGenerator(OpenAIChatGenerator):
         )
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "LlamaStackChatGenerator":
+    def from_dict(cls, data: dict[str, Any]) -> "LlamaStackChatGenerator":
         """
         Deserialize this component from a dictionary.
 

{llama_stack_haystack-1.1.1 → llama_stack_haystack-1.3.0}/tests/test_llama_stack_chat_generator.py

@@ -1,3 +1,4 @@
+import json
 from datetime import datetime
 from unittest.mock import patch
 
@@ -5,13 +6,25 @@ import pytest
 import pytz
 from haystack.components.generators.utils import print_streaming_chunk
 from haystack.dataclasses import ChatMessage, ChatRole, StreamingChunk, ToolCall
-from haystack.tools import Tool
+from haystack.tools import Tool, Toolset
 from openai.types.chat import ChatCompletion, ChatCompletionMessage
 from openai.types.chat.chat_completion import Choice
+from pydantic import BaseModel
 
 from haystack_integrations.components.generators.llama_stack.chat.chat_generator import LlamaStackChatGenerator
 
 
+class CalendarEvent(BaseModel):
+    event_name: str
+    event_date: str
+    event_location: str
+
+
+@pytest.fixture
+def calendar_event_model():
+    return CalendarEvent
+
+
 @pytest.fixture
 def chat_messages():
     return [
@@ -25,6 +38,11 @@ def weather(city: str):
     return f"The weather in {city} is sunny and 32°C"
 
 
+def population(city: str):
+    """Get population for a given city."""
+    return f"The population of {city} is 2.2 million"
+
+
 @pytest.fixture
 def tools():
     tool_parameters = {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}
@@ -38,6 +56,25 @@ def tools():
     return [tool]
 
 
+@pytest.fixture
+def mixed_tools():
+    """Fixture that returns a mixed list of Tool and Toolset."""
+    weather_tool = Tool(
+        name="weather",
+        description="useful to determine the weather in a given location",
+        parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+        function=weather,
+    )
+    population_tool = Tool(
+        name="population",
+        description="useful to determine the population of a given location",
+        parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+        function=population,
+    )
+    toolset = Toolset([population_tool])
+    return [weather_tool, toolset]
+
+
 @pytest.fixture
 def mock_chat_completion():
     """
@@ -46,7 +83,7 @@ def mock_chat_completion():
     with patch("openai.resources.chat.completions.Completions.create") as mock_chat_completion_create:
         completion = ChatCompletion(
             id="foo",
-            model="llama3.2:3b",
+            model="ollama/llama3.2:3b",
             object="chat.completion",
             choices=[
                 Choice(
@@ -66,27 +103,27 @@ def mock_chat_completion():
 
 class TestLlamaStackChatGenerator:
     def test_init_default(self):
-        component = LlamaStackChatGenerator(model="llama3.2:3b")
-        assert component.model == "llama3.2:3b"
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b")
+        assert component.model == "ollama/llama3.2:3b"
         assert component.api_base_url == "http://localhost:8321/v1/openai/v1"
         assert component.streaming_callback is None
         assert not component.generation_kwargs
 
     def test_init_with_parameters(self):
         component = LlamaStackChatGenerator(
-            model="llama3.2:3b",
+            model="ollama/llama3.2:3b",
             streaming_callback=print_streaming_chunk,
             api_base_url="test-base-url",
             generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"},
         )
-        assert component.model == "llama3.2:3b"
+        assert component.model == "ollama/llama3.2:3b"
         assert component.streaming_callback is print_streaming_chunk
         assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"}
 
     def test_to_dict_default(
         self,
     ):
-        component = LlamaStackChatGenerator(model="llama3.2:3b")
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b")
         data = component.to_dict()
 
         assert (
@@ -95,7 +132,7 @@ class TestLlamaStackChatGenerator:
         )
 
         expected_params = {
-            "model": "llama3.2:3b",
+            "model": "ollama/llama3.2:3b",
             "streaming_callback": None,
             "api_base_url": "http://localhost:8321/v1/openai/v1",
             "generation_kwargs": {},
@@ -111,12 +148,17 @@ class TestLlamaStackChatGenerator:
 
     def test_to_dict_with_parameters(
         self,
+        calendar_event_model,
     ):
         component = LlamaStackChatGenerator(
-            model="llama3.2:3b",
+            model="ollama/llama3.2:3b",
             streaming_callback=print_streaming_chunk,
             api_base_url="test-base-url",
-            generation_kwargs={"max_tokens": 10, "some_test_param": "test-params"},
+            generation_kwargs={
+                "max_tokens": 10,
+                "some_test_param": "test-params",
+                "response_format": calendar_event_model,
+            },
             timeout=10,
             max_retries=10,
             tools=None,
@@ -131,10 +173,31 @@ class TestLlamaStackChatGenerator:
         )
 
         expected_params = {
-            "model": "llama3.2:3b",
+            "model": "ollama/llama3.2:3b",
             "api_base_url": "test-base-url",
             "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
-            "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"},
+            "generation_kwargs": {
+                "max_tokens": 10,
+                "some_test_param": "test-params",
+                "response_format": {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": "CalendarEvent",
+                        "strict": True,
+                        "schema": {
+                            "properties": {
+                                "event_name": {"title": "Event Name", "type": "string"},
+                                "event_date": {"title": "Event Date", "type": "string"},
+                                "event_location": {"title": "Event Location", "type": "string"},
+                            },
+                            "required": ["event_name", "event_date", "event_location"],
+                            "title": "CalendarEvent",
+                            "type": "object",
+                            "additionalProperties": False,
+                        },
+                    },
+                },
+            },
             "timeout": 10,
             "max_retries": 10,
             "tools": None,
@@ -153,7 +216,7 @@ class TestLlamaStackChatGenerator:
                 "haystack_integrations.components.generators.llama_stack.chat.chat_generator.LlamaStackChatGenerator"
             ),
             "init_parameters": {
-                "model": "llama3.2:3b",
+                "model": "ollama/llama3.2:3b",
                 "api_base_url": "test-base-url",
                 "streaming_callback": "haystack.components.generators.utils.print_streaming_chunk",
                 "generation_kwargs": {"max_tokens": 10, "some_test_param": "test-params"},
@@ -165,7 +228,7 @@ class TestLlamaStackChatGenerator:
             },
         }
         component = LlamaStackChatGenerator.from_dict(data)
-        assert component.model == "llama3.2:3b"
+        assert component.model == "ollama/llama3.2:3b"
         assert component.streaming_callback is print_streaming_chunk
         assert component.api_base_url == "test-base-url"
         assert component.generation_kwargs == {"max_tokens": 10, "some_test_param": "test-params"}
@@ -175,8 +238,33 @@ class TestLlamaStackChatGenerator:
         assert component.max_retries == 10
         assert not component.tools_strict
 
+    def test_init_with_mixed_tools(self):
+        def tool_fn(city: str) -> str:
+            return city
+
+        weather_tool = Tool(
+            name="weather",
+            description="Weather lookup",
+            parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+            function=tool_fn,
+        )
+        population_tool = Tool(
+            name="population",
+            description="Population lookup",
+            parameters={"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]},
+            function=tool_fn,
+        )
+        toolset = Toolset([population_tool])
+
+        generator = LlamaStackChatGenerator(
+            model="ollama/llama3.2:3b",
+            tools=[weather_tool, toolset],
+        )
+
+        assert generator.tools == [weather_tool, toolset]
+
     def test_run(self, chat_messages, mock_chat_completion):  # noqa: ARG002
-        component = LlamaStackChatGenerator(model="llama3.2:3b")
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b")
         response = component.run(chat_messages)
 
         # check that the component returns the correct ChatMessage response
@@ -188,7 +276,7 @@ class TestLlamaStackChatGenerator:
 
     def test_run_with_params(self, chat_messages, mock_chat_completion):
         component = LlamaStackChatGenerator(
-            model="llama3.2:3b",
+            model="ollama/llama3.2:3b",
             generation_kwargs={"max_tokens": 10, "temperature": 0.5},
         )
         response = component.run(chat_messages)
@@ -208,7 +296,7 @@ class TestLlamaStackChatGenerator:
     @pytest.mark.integration
     def test_live_run(self):
         chat_messages = [ChatMessage.from_user("What's the capital of France")]
-        component = LlamaStackChatGenerator(model="llama3.2:3b")
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b")
         results = component.run(chat_messages)
         assert len(results["replies"]) == 1
         message: ChatMessage = results["replies"][0]
@@ -228,7 +316,7 @@ class TestLlamaStackChatGenerator:
                 self.responses += chunk.content if chunk.content else ""
 
         callback = Callback()
-        component = LlamaStackChatGenerator(model="llama3.2:3b", streaming_callback=callback)
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b", streaming_callback=callback)
         results = component.run([ChatMessage.from_user("What's the capital of France?")])
 
         assert len(results["replies"]) == 1
@@ -244,7 +332,7 @@ class TestLlamaStackChatGenerator:
     @pytest.mark.integration
     def test_live_run_with_tools(self, tools):
         chat_messages = [ChatMessage.from_user("What's the weather like in Paris?")]
-        component = LlamaStackChatGenerator(model="llama3.2:3b", tools=tools)
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b", tools=tools)
         results = component.run(chat_messages)
         assert len(results["replies"]) == 1
         message = results["replies"][0]
@@ -263,7 +351,7 @@ class TestLlamaStackChatGenerator:
         Integration test that the LlamaStackChatGenerator component can run with tools and get a response.
         """
         initial_messages = [ChatMessage.from_user("What's the weather like in Paris?")]
-        component = LlamaStackChatGenerator(model="llama3.2:3b", tools=tools)
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b", tools=tools)
         results = component.run(messages=initial_messages, generation_kwargs={"tool_choice": "auto"})
 
         assert len(results["replies"]) > 0, "No replies received"
@@ -298,3 +386,112 @@ class TestLlamaStackChatGenerator:
         assert not final_message.tool_call
         assert len(final_message.text) > 0
         assert "paris" in final_message.text.lower()
+
+    @pytest.mark.integration
+    def test_live_run_with_mixed_tools(self, mixed_tools):
+        """
+        Integration test that verifies LlamaStackChatGenerator works with mixed Tool and Toolset.
+        This tests that the LLM can correctly invoke tools from both a standalone Tool and a Toolset.
+        """
+        initial_messages = [
+            ChatMessage.from_user("What's the weather like in Paris and what is the population of Berlin?")
+        ]
+        component = LlamaStackChatGenerator(model="ollama/llama3.2:3b", tools=mixed_tools)
+        results = component.run(messages=initial_messages)
+
+        assert len(results["replies"]) > 0, "No replies received"
+
+        # Find the message with tool calls
+        tool_call_message = None
+        for message in results["replies"]:
+            if message.tool_calls:
+                tool_call_message = message
+                break
+
+        assert tool_call_message is not None, "No message with tool call found"
+        assert isinstance(tool_call_message, ChatMessage), "Tool message is not a ChatMessage instance"
+        assert ChatMessage.is_from(tool_call_message, ChatRole.ASSISTANT), "Tool message is not from the assistant"
+
+        tool_calls = tool_call_message.tool_calls
+        assert len(tool_calls) == 2, f"Expected 2 tool calls, got {len(tool_calls)}"
+
+        # Verify we got calls to both weather and population tools
+        tool_names = {tc.tool_name for tc in tool_calls}
+        assert "weather" in tool_names, "Expected 'weather' tool call"
+        assert "population" in tool_names, "Expected 'population' tool call"
+
+        # Verify tool call details
+        for tool_call in tool_calls:
+            assert tool_call.id, "Tool call does not contain value for 'id' key"
+            assert tool_call.tool_name in ["weather", "population"]
+            assert "city" in tool_call.arguments
+            assert tool_call.arguments["city"] in ["Paris", "Berlin"]
+            assert tool_call_message.meta["finish_reason"] == "tool_calls"
+
+        # Mock the response we'd get from ToolInvoker
+        tool_result_messages = []
+        for tool_call in tool_calls:
+            if tool_call.tool_name == "weather":
+                result = "The weather in Paris is sunny and 32°C"
+            else:  # population
+                result = "The population of Berlin is 2.2 million"
+            tool_result_messages.append(ChatMessage.from_tool(tool_result=result, origin=tool_call))
+
+        new_messages = [*initial_messages, tool_call_message, *tool_result_messages]
+        results = component.run(new_messages)
+
+        assert len(results["replies"]) == 1
+        final_message = results["replies"][0]
+        assert not final_message.tool_call
+        assert len(final_message.text) > 0
+        assert "paris" in final_message.text.lower()
+        assert "berlin" in final_message.text.lower()
+
+    @pytest.mark.integration
+    def test_live_run_with_response_format_json_schema(self):
+        response_schema = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": "CapitalCity",
+                "strict": True,
+                "schema": {
+                    "title": "CapitalCity",
+                    "type": "object",
+                    "properties": {
+                        "city": {"title": "City", "type": "string"},
+                        "country": {"title": "Country", "type": "string"},
+                    },
+                    "required": ["city", "country"],
+                    "additionalProperties": False,
+                },
+            },
+        }
+
+        chat_messages = [ChatMessage.from_user("What's the capital of France?")]
+        comp = LlamaStackChatGenerator(
+            model="ollama/llama3.2:3b", generation_kwargs={"response_format": response_schema}
+        )
+        results = comp.run(chat_messages)
+        assert len(results["replies"]) == 1
+        message: ChatMessage = results["replies"][0]
+        msg = json.loads(message.text)
+        assert "Paris" in msg["city"]
+        assert isinstance(msg["country"], str)
+        assert "France" in msg["country"]
+        assert message.meta["finish_reason"] == "stop"
+
+    @pytest.mark.integration
+    def test_live_run_with_response_format_pydantic_model(self, calendar_event_model):
+        chat_messages = [
+            ChatMessage.from_user("The marketing summit takes place on October 12th at the Hilton Hotel downtown.")
+        ]
+        component = LlamaStackChatGenerator(
+            model="ollama/llama3.2:3b", generation_kwargs={"response_format": calendar_event_model}
+        )
+        results = component.run(chat_messages)
+        assert len(results["replies"]) == 1
+        message: ChatMessage = results["replies"][0]
+        msg = json.loads(message.text)
+        assert "Marketing Summit" in msg["event_name"]
+        assert isinstance(msg["event_date"], str)
+        assert isinstance(msg["event_location"], str)