vectara-agentic 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

tests/test_bedrock.py

@@ -8,6 +8,7 @@ import threading
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.tools_catalog import ToolsCatalog
 
 import nest_asyncio
 
@@ -15,6 +16,7 @@ nest_asyncio.apply()
 
 from conftest import (
     mult,
+    add,
     fc_config_bedrock,
     STANDARD_TEST_TOPIC,
     STANDARD_TEST_INSTRUCTIONS,
@@ -64,6 +66,105 @@ class TestBedrock(unittest.IsolatedAsyncioTestCase):
 
             self.assertEqual(response3.response, "1050")
 
+    async def test_claude_sonnet_4_multi_tool_chain(self):
+        """Test Claude Sonnet 4 with complex multi-step reasoning chain using multiple tools via Bedrock."""
+        with ARIZE_LOCK:
+            # Use Bedrock config (Claude Sonnet 4)
+            tools_catalog = ToolsCatalog(fc_config_bedrock)
+            tools = [
+                ToolsFactory().create_tool(mult),
+                ToolsFactory().create_tool(add),
+                ToolsFactory().create_tool(tools_catalog.summarize_text),
+                ToolsFactory().create_tool(tools_catalog.rephrase_text),
+            ]
+
+            agent = Agent(
+                agent_config=fc_config_bedrock,
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions="You are a mathematical reasoning agent that explains your work step by step.",
+            )
+
+            # Complex multi-step reasoning task
+            complex_query = (
+                "Perform this calculation step by step: "
+                "First multiply 5 by 9, then add 13 to that result, "
+                "then multiply the new result by 2. "
+                "After getting the final number, summarize the entire mathematical process "
+                "with expertise in 'mathematics education', "
+                "then rephrase that summary as a 10-year-old would explain it."
+            )
+
+            print("\n🔍 Starting Claude Sonnet 4 multi-tool chain test (Bedrock)")
+            print(f"📝 Query: {complex_query}")
+            print("🌊 Streaming response:\n" + "="*50)
+
+            stream = await agent.astream_chat(complex_query)
+
+            # Capture streaming deltas and tool calls
+            streaming_deltas = []
+            tool_calls_made = []
+            full_response = ""
+
+            async for chunk in stream.async_response_gen():
+                if chunk and chunk.strip():
+                    streaming_deltas.append(chunk)
+                    full_response += chunk
+                    # Display each streaming delta
+                    print(f"📡 Delta: {repr(chunk)}")
+
+                    # Track tool calls in the stream
+                    if "mult" in chunk.lower():
+                        if "mult" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "mult", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: mult (#{len(tool_calls_made)})")
+                    if "add" in chunk.lower():
+                        if "add" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "add", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: add (#{len(tool_calls_made)})")
+                    if "summarize" in chunk.lower():
+                        if "summarize_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "summarize_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: summarize_text (#{len(tool_calls_made)})")
+                    if "rephrase" in chunk.lower():
+                        if "rephrase_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "rephrase_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: rephrase_text (#{len(tool_calls_made)})")
+
+            response = await stream.aget_response()
+
+            print("="*50)
+            print(f"✅ Streaming completed. Total deltas: {len(streaming_deltas)}")
+            print(f"🔧 Tool calls made: {[call['tool'] for call in tool_calls_made]}")
+            print(f"📄 Final response length: {len(response.response)} chars")
+            print(f"🎯 Final response: {response.response}")
+
+            # Validate tool usage sequence
+            tools_used = [call["tool"] for call in tool_calls_made]
+            print(f"🧪 Tools used in order: {tools_used}")
+
+            # Check that at least multiplication happened (basic requirement)
+            self.assertIn("mult", tools_used, f"Expected multiplication tool to be used. Tools used: {tools_used}")
+
+            # Check for mathematical results in the full response or streaming deltas
+            # Expected: 5*9=45, 45+13=58, 58*2=116
+            expected_intermediate_results = ["45", "58", "116"]
+            all_text = (full_response + " " + response.response).lower()
+            math_results_found = sum(1 for result in expected_intermediate_results
+                                     if result in all_text)
+
+            print(f"🔢 Mathematical results found: {math_results_found}/3 expected")
+            print(f"🔍 Full text searched: {all_text[:200]}...")
+
+            # More lenient assertion - just check that some mathematical progress was made
+            self.assertGreaterEqual(math_results_found, 1,
+                                    f"Expected at least 1 mathematical result. Found {math_results_found}. "
+                                    f"Full text: {all_text}")
+
+            # Verify that streaming actually produced content
+            self.assertGreater(len(streaming_deltas), 0, "Expected streaming deltas to be produced")
+            self.assertGreater(len(response.response.strip()), 0, "Expected non-empty final response")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_gemini.py

@@ -7,6 +7,7 @@ import unittest
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.tools_catalog import ToolsCatalog
 
 
 import nest_asyncio
@@ -15,6 +16,7 @@ nest_asyncio.apply()
 
 from conftest import (
     mult,
+    add,
     fc_config_gemini,
     STANDARD_TEST_TOPIC,
     STANDARD_TEST_INSTRUCTIONS,
@@ -52,6 +54,68 @@ class TestGEMINI(unittest.TestCase):
         )
         self.assertIn("1050", res.response)
 
+    def test_gemini_25_flash_multi_tool_chain(self):
+        """Test Gemini 2.5 Flash with complex multi-step reasoning chain using multiple tools."""
+        # Use Gemini config (Gemini 2.5 Flash)
+        tools_catalog = ToolsCatalog(fc_config_gemini)
+        tools = [
+            ToolsFactory().create_tool(mult),
+            ToolsFactory().create_tool(add),
+            ToolsFactory().create_tool(tools_catalog.summarize_text),
+            ToolsFactory().create_tool(tools_catalog.rephrase_text),
+        ]
+
+        agent = Agent(
+            agent_config=fc_config_gemini,
+            tools=tools,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions="You are a mathematical reasoning agent that explains your work step by step.",
+        )
+
+        # Complex multi-step reasoning task
+        complex_query = (
+            "Perform this calculation step by step: "
+            "First multiply 3 by 8, then add 14 to that result, "
+            "then multiply the new result by 3. "
+            "After getting the final number, summarize the entire mathematical process "
+            "with expertise in 'mathematics education', "
+            "then rephrase that summary as a 10-year-old would explain it."
+        )
+
+        print("\n🔍 Starting Gemini 2.5 Flash multi-tool chain test")
+        print(f"📝 Query: {complex_query}")
+
+        # Note: Gemini tests use synchronous chat, not async streaming
+        response = agent.chat(complex_query)
+
+        print(f"🎯 Final response: {response.response}")
+        print(f"📄 Final response length: {len(response.response)} chars")
+
+        # Check for mathematical results in the response
+        # Expected: 3*8=24, 24+14=38, 38*3=114
+        expected_intermediate_results = ["24", "38", "114"]
+        response_text = response.response.lower()
+        math_results_found = sum(1 for result in expected_intermediate_results
+                                 if result in response_text)
+
+        print(f"🔢 Mathematical results found: {math_results_found}/3 expected")
+        print(f"🔍 Response text searched: {response_text[:200]}...")
+
+        # More lenient assertion - just check that some mathematical progress was made
+        self.assertGreaterEqual(math_results_found, 1,
+                                f"Expected at least 1 mathematical result. Found {math_results_found}. "
+                                f"Response: {response.response}")
+
+        # Verify response has content and mentions math concepts
+        self.assertGreater(len(response.response.strip()), 50, "Expected substantial response content")
+
+        # Check for indications of multi-tool usage (math, summary, or explanation content)
+        multi_tool_indicators = ["calculate", "multiply", "add", "summary", "explain", "mathematical", "process"]
+        indicators_found = sum(1 for indicator in multi_tool_indicators
+                               if indicator in response_text)
+        self.assertGreaterEqual(indicators_found, 3,
+                                f"Expected multiple tool usage indicators. Found {indicators_found}: {response.response}")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_groq.py

@@ -8,6 +8,7 @@ import threading
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.tools_catalog import ToolsCatalog
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import AgentType, ModelProvider
 
@@ -17,6 +18,7 @@ nest_asyncio.apply()
 
 from conftest import (
     mult,
+    add,
     fc_config_groq,
     STANDARD_TEST_TOPIC,
     STANDARD_TEST_INSTRUCTIONS,
@@ -67,9 +69,9 @@ class TestGROQ(unittest.IsolatedAsyncioTestCase):
             self.assertEqual(response3.response, "1050")
 
     async def test_gpt_oss_120b(self):
-        """Test GPT-OSS-120B model with GROQ provider."""
+        """Test GPT-OSS-120B model with complex multi-step reasoning chain using multiple tools via GROQ."""
         with ARIZE_LOCK:
-            # Create config specifically for GPT-OSS-120B via GROQ
+            # Create config for GPT-OSS-120B via GROQ
             gpt_oss_config = AgentConfig(
                 agent_type=AgentType.FUNCTION_CALLING,
                 main_llm_provider=ModelProvider.GROQ,
@@ -78,25 +80,208 @@ class TestGROQ(unittest.IsolatedAsyncioTestCase):
                 tool_llm_model_name="openai/gpt-oss-120b",
             )
 
-            tools = [ToolsFactory().create_tool(mult)]
+            # Create multiple tools for complex reasoning
+            tools_catalog = ToolsCatalog(gpt_oss_config)
+            tools = [
+                ToolsFactory().create_tool(mult),
+                ToolsFactory().create_tool(add),
+                ToolsFactory().create_tool(tools_catalog.summarize_text),
+                ToolsFactory().create_tool(tools_catalog.rephrase_text),
+            ]
+
             agent = Agent(
                 agent_config=gpt_oss_config,
                 tools=tools,
                 topic=STANDARD_TEST_TOPIC,
-                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+                custom_instructions="You are a mathematical reasoning agent that explains your work step by step.",
             )
 
-            # Test simple multiplication: 8 * 6 = 48
-            stream = await agent.astream_chat(
-                "What is 8 times 6? Only give the answer, nothing else"
+            # Complex multi-step reasoning task
+            complex_query = (
+                "Perform this calculation step by step: "
+                "First multiply 7 by 8, then add 15 to that result, "
+                "then multiply the new result by 3. "
+                "After getting the final number, summarize the entire mathematical process "
+                "with expertise in 'mathematics education', "
+                "then rephrase that summary as a 10-year-old would explain it."
             )
-            # Consume the stream
+
+            print("\n🔍 Starting GPT-OSS-120B multi-tool chain test (GROQ)")
+            print(f"📝 Query: {complex_query}")
+            print("🌊 Streaming response:\n" + "="*50)
+
+            stream = await agent.astream_chat(complex_query)
+
+            # Capture streaming deltas and tool calls
+            streaming_deltas = []
+            tool_calls_made = []
+            full_response = ""
+
             async for chunk in stream.async_response_gen():
-                pass
+                if chunk and chunk.strip():
+                    streaming_deltas.append(chunk)
+                    full_response += chunk
+                    # Display each streaming delta
+                    print(f"📡 Delta: {repr(chunk)}")
+
+                    # Track tool calls in the stream
+                    if "mult" in chunk.lower():
+                        if "mult" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "mult", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: mult (#{len(tool_calls_made)})")
+                    if "add" in chunk.lower():
+                        if "add" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "add", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: add (#{len(tool_calls_made)})")
+                    if "summarize" in chunk.lower():
+                        if "summarize_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "summarize_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: summarize_text (#{len(tool_calls_made)})")
+                    if "rephrase" in chunk.lower():
+                        if "rephrase_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "rephrase_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: rephrase_text (#{len(tool_calls_made)})")
+
+            response = await stream.aget_response()
+
+            print("="*50)
+            print(f"✅ Streaming completed. Total deltas: {len(streaming_deltas)}")
+            print(f"🔧 Tool calls made: {[call['tool'] for call in tool_calls_made]}")
+            print(f"📄 Final response length: {len(response.response)} chars")
+            print(f"🎯 Final response: {response.response}")
+
+            # Validate tool usage sequence
+            tools_used = [call["tool"] for call in tool_calls_made]
+            print(f"🧪 Tools used in order: {tools_used}")
+
+            # Check that at least multiplication happened (basic requirement)
+            self.assertIn("mult", tools_used, f"Expected multiplication tool to be used. Tools used: {tools_used}")
+
+            # Check for mathematical results in the full response or streaming deltas
+            expected_intermediate_results = ["56", "71", "213"]
+            all_text = (full_response + " " + response.response).lower()
+            math_results_found = sum(1 for result in expected_intermediate_results
+                                     if result in all_text)
+
+            print(f"🔢 Mathematical results found: {math_results_found}/3 expected")
+            print(f"🔍 Full text searched: {all_text[:200]}...")
+
+            # More lenient assertion - just check that some mathematical progress was made
+            self.assertGreaterEqual(math_results_found, 1,
+                                    f"Expected at least 1 mathematical result. Found {math_results_found}. "
+                                    f"Full text: {all_text}")
+
+            # Verify that streaming actually produced content
+            self.assertGreater(len(streaming_deltas), 0, "Expected streaming deltas to be produced")
+            self.assertGreater(len(response.response.strip()), 0, "Expected non-empty final response")
+
+    async def test_gpt_oss_20b(self):
+        """Test GPT-OSS-20B model with complex multi-step reasoning chain using multiple tools via GROQ."""
+        with ARIZE_LOCK:
+            # Create config for GPT-OSS-20B via GROQ
+            gpt_oss_20b_config = AgentConfig(
+                agent_type=AgentType.FUNCTION_CALLING,
+                main_llm_provider=ModelProvider.GROQ,
+                main_llm_model_name="openai/gpt-oss-20b",
+                tool_llm_provider=ModelProvider.GROQ,
+                tool_llm_model_name="openai/gpt-oss-20b",
+            )
+
+            # Create multiple tools for complex reasoning
+            tools_catalog = ToolsCatalog(gpt_oss_20b_config)
+            tools = [
+                ToolsFactory().create_tool(mult),
+                ToolsFactory().create_tool(add),
+                ToolsFactory().create_tool(tools_catalog.summarize_text),
+                ToolsFactory().create_tool(tools_catalog.rephrase_text),
+            ]
+
+            agent = Agent(
+                agent_config=gpt_oss_20b_config,
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions="You are a mathematical reasoning agent that explains your work step by step.",
+            )
+
+            # Complex multi-step reasoning task
+            complex_query = (
+                "Perform this calculation step by step: "
+                "First multiply 6 by 9, then add 12 to that result, "
+                "then multiply the new result by 2. "
+                "After getting the final number, summarize the entire mathematical process "
+                "with expertise in 'mathematics education', "
+                "then rephrase that summary as a 10-year-old would explain it."
+            )
+
+            print("\n🔍 Starting GPT-OSS-20B multi-tool chain test (GROQ)")
+            print(f"📝 Query: {complex_query}")
+            print("🌊 Streaming response:\n" + "="*50)
+
+            stream = await agent.astream_chat(complex_query)
+
+            # Capture streaming deltas and tool calls
+            streaming_deltas = []
+            tool_calls_made = []
+            full_response = ""
+
+            async for chunk in stream.async_response_gen():
+                if chunk and chunk.strip():
+                    streaming_deltas.append(chunk)
+                    full_response += chunk
+                    # Display each streaming delta
+                    print(f"📡 Delta: {repr(chunk)}")
+
+                    # Track tool calls in the stream
+                    if "mult" in chunk.lower():
+                        if "mult" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "mult", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: mult (#{len(tool_calls_made)})")
+                    if "add" in chunk.lower():
+                        if "add" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "add", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: add (#{len(tool_calls_made)})")
+                    if "summarize" in chunk.lower():
+                        if "summarize_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "summarize_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: summarize_text (#{len(tool_calls_made)})")
+                    if "rephrase" in chunk.lower():
+                        if "rephrase_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "rephrase_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: rephrase_text (#{len(tool_calls_made)})")
+
             response = await stream.aget_response()
 
-            # Verify the response contains the correct answer
-            self.assertIn("48", response.response)
+            print("="*50)
+            print(f"✅ Streaming completed. Total deltas: {len(streaming_deltas)}")
+            print(f"🔧 Tool calls made: {[call['tool'] for call in tool_calls_made]}")
+            print(f"📄 Final response length: {len(response.response)} chars")
+            print(f"🎯 Final response: {response.response}")
+
+            # Validate tool usage sequence
+            tools_used = [call["tool"] for call in tool_calls_made]
+            print(f"🧪 Tools used in order: {tools_used}")
+
+            # Check that at least multiplication happened (basic requirement)
+            self.assertIn("mult", tools_used, f"Expected multiplication tool to be used. Tools used: {tools_used}")
+
+            # Check for mathematical results in the full response or streaming deltas
+            # Expected: 6*9=54, 54+12=66, 66*2=132
+            expected_intermediate_results = ["54", "66", "132"]
+            all_text = (full_response + " " + response.response).lower()
+            math_results_found = sum(1 for result in expected_intermediate_results
+                                     if result in all_text)
+
+            print(f"🔢 Mathematical results found: {math_results_found}/3 expected")
+            print(f"🔍 Full text searched: {all_text[:200]}...")
+
+            # More lenient assertion - just check that some mathematical progress was made
+            self.assertGreaterEqual(math_results_found, 1,
+                                    f"Expected at least 1 mathematical result. Found {math_results_found}. "
+                                    f"Full text: {all_text}")
+
+            # Verify that streaming actually produced content
+            self.assertGreater(len(streaming_deltas), 0, "Expected streaming deltas to be produced")
+            self.assertGreater(len(response.response.strip()), 0, "Expected non-empty final response")
 
 
 if __name__ == "__main__":

tests/test_openai.py

@@ -8,6 +8,7 @@ import threading
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.tools_catalog import ToolsCatalog
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import AgentType, ModelProvider
 
@@ -18,6 +19,7 @@ nest_asyncio.apply()
 from conftest import (
     fc_config_openai,
     mult,
+    add,
     STANDARD_TEST_TOPIC,
     STANDARD_TEST_INSTRUCTIONS,
 )
@@ -155,6 +157,105 @@ class TestOpenAI(unittest.IsolatedAsyncioTestCase):
 
             self.assertIn("25", response.response)
 
+    async def test_gpt_41_mini_multi_tool_chain(self):
+        """Test GPT-4.1-mini with complex multi-step reasoning chain using multiple tools."""
+        with ARIZE_LOCK:
+            # Use default OpenAI config (gpt-4.1-mini)
+            tools_catalog = ToolsCatalog(fc_config_openai)
+            tools = [
+                ToolsFactory().create_tool(mult),
+                ToolsFactory().create_tool(add),
+                ToolsFactory().create_tool(tools_catalog.summarize_text),
+                ToolsFactory().create_tool(tools_catalog.rephrase_text),
+            ]
+
+            agent = Agent(
+                agent_config=fc_config_openai,
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions="You are a mathematical reasoning agent that explains your work step by step.",
+            )
+
+            # Complex multi-step reasoning task
+            complex_query = (
+                "Perform this calculation step by step: "
+                "First multiply 4 by 7, then add 18 to that result, "
+                "then multiply the new result by 2. "
+                "After getting the final number, summarize the entire mathematical process "
+                "with expertise in 'mathematics education', "
+                "then rephrase that summary as a 10-year-old would explain it."
+            )
+
+            print("\n🔍 Starting GPT-4.1-mini multi-tool chain test (OpenAI)")
+            print(f"📝 Query: {complex_query}")
+            print("🌊 Streaming response:\n" + "="*50)
+
+            stream = await agent.astream_chat(complex_query)
+
+            # Capture streaming deltas and tool calls
+            streaming_deltas = []
+            tool_calls_made = []
+            full_response = ""
+
+            async for chunk in stream.async_response_gen():
+                if chunk and chunk.strip():
+                    streaming_deltas.append(chunk)
+                    full_response += chunk
+                    # Display each streaming delta
+                    print(f"📡 Delta: {repr(chunk)}")
+
+                    # Track tool calls in the stream
+                    if "mult" in chunk.lower():
+                        if "mult" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "mult", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: mult (#{len(tool_calls_made)})")
+                    if "add" in chunk.lower():
+                        if "add" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "add", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: add (#{len(tool_calls_made)})")
+                    if "summarize" in chunk.lower():
+                        if "summarize_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "summarize_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: summarize_text (#{len(tool_calls_made)})")
+                    if "rephrase" in chunk.lower():
+                        if "rephrase_text" not in [call["tool"] for call in tool_calls_made]:
+                            tool_calls_made.append({"tool": "rephrase_text", "order": len(tool_calls_made) + 1})
+                            print(f"🔧 Tool call detected: rephrase_text (#{len(tool_calls_made)})")
+
+            response = await stream.aget_response()
+
+            print("="*50)
+            print(f"✅ Streaming completed. Total deltas: {len(streaming_deltas)}")
+            print(f"🔧 Tool calls made: {[call['tool'] for call in tool_calls_made]}")
+            print(f"📄 Final response length: {len(response.response)} chars")
+            print(f"🎯 Final response: {response.response}")
+
+            # Validate tool usage sequence
+            tools_used = [call["tool"] for call in tool_calls_made]
+            print(f"🧪 Tools used in order: {tools_used}")
+
+            # Check that at least multiplication happened (basic requirement)
+            self.assertIn("mult", tools_used, f"Expected multiplication tool to be used. Tools used: {tools_used}")
+
+            # Check for mathematical results in the full response or streaming deltas
+            # Expected: 4*7=28, 28+18=46, 46*2=92
+            expected_intermediate_results = ["28", "46", "92"]
+            all_text = (full_response + " " + response.response).lower()
+            math_results_found = sum(1 for result in expected_intermediate_results
+                                     if result in all_text)
+
+            print(f"🔢 Mathematical results found: {math_results_found}/3 expected")
+            print(f"🔍 Full text searched: {all_text[:200]}...")
+
+            # More lenient assertion - just check that some mathematical progress was made
+            self.assertGreaterEqual(math_results_found, 1,
+                                    f"Expected at least 1 mathematical result. Found {math_results_found}. "
+                                    f"Full text: {all_text}")
+
+            # Verify that streaming actually produced content
+            self.assertGreater(len(streaming_deltas), 0, "Expected streaming deltas to be produced")
+            self.assertGreater(len(response.response.strip()), 0, "Expected non-empty final response")
+
 
 if __name__ == "__main__":
     unittest.main()