vectara-agentic 0.3.3__py3-none-any.whl → 0.4.1__py3-none-any.whl

tests/test_agent_type.py

@@ -1,198 +1,141 @@
-import unittest
-
-from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import ToolsFactory
-from vectara_agentic.types import ModelProvider
-
-import nest_asyncio
-nest_asyncio.apply()
+# Suppress external dependency warnings before any other imports
+import warnings
 
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
-
-
-react_config_anthropic = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.ANTHROPIC,
-    tool_llm_provider=ModelProvider.ANTHROPIC,
-)
-
-# React with Google does not work with Gemini 2.5-flash
-react_config_gemini = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.GEMINI,
-    main_llm_model_name="models/gemini-2.0-flash",
-    tool_llm_provider=ModelProvider.GEMINI,
-    tool_llm_model_name="models/gemini-2.0-flash",
-)
-
-react_config_together = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.TOGETHER,
-    tool_llm_provider=ModelProvider.TOGETHER,
-)
-
-react_config_groq = AgentConfig(
-    agent_type=AgentType.REACT,
-    main_llm_provider=ModelProvider.GROQ,
-    tool_llm_provider=ModelProvider.GROQ,
-)
+warnings.simplefilter("ignore", DeprecationWarning)
 
-fc_config_anthropic = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.ANTHROPIC,
-    tool_llm_provider=ModelProvider.ANTHROPIC,
-)
-
-fc_config_gemini = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GEMINI,
-    tool_llm_provider=ModelProvider.GEMINI,
-)
-
-fc_config_together = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.TOGETHER,
-    tool_llm_provider=ModelProvider.TOGETHER,
-)
+import unittest
 
-fc_config_groq = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GROQ,
-    tool_llm_provider=ModelProvider.GROQ,
+import sys
+import os
+sys.path.insert(0, os.path.dirname(__file__))
+
+from conftest import (
+    AgentTestMixin,
+    mult,
+    STANDARD_TEST_TOPIC,
+    STANDARD_TEST_INSTRUCTIONS,
+    default_config,
+    react_config_anthropic,
+    react_config_gemini,
+    react_config_together,
+    fc_config_anthropic,
+    fc_config_gemini,
+    fc_config_together,
 )
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import ToolsFactory
 
+class TestAgentType(unittest.TestCase, AgentTestMixin):
 
-openai_config = AgentConfig(
-    agent_type=AgentType.OPENAI,
-)
-
-class TestAgentType(unittest.TestCase):
+    def setUp(self):
+        self.tools = [ToolsFactory().create_tool(mult)]
+        self.topic = STANDARD_TEST_TOPIC
+        self.instructions = STANDARD_TEST_INSTRUCTIONS
 
-    def test_openai(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
+    def test_default_function_calling(self):
         agent = Agent(
-            agent_config=openai_config,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            agent_config=default_config,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
 
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat(
+            "multiply the results of the last two multiplications. Only give the answer, nothing else."
+        )
         self.assertIn("1050", res.response)
 
     def test_gemini(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-
         agent = Agent(
             agent_config=react_config_gemini,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat(
+            "what is the result of multiplying the results of the last two "
+            "multiplications. Only give the answer, nothing else."
+        )
         self.assertIn("1050", res.response)
 
         agent = Agent(
             agent_config=fc_config_gemini,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat(
+            "what is the result of multiplying the results of the last two "
+            "multiplications. Only give the answer, nothing else."
+        )
         self.assertIn("1050", res.response)
 
     def test_together(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-
+        # Test ReAct agent with Together
         agent = Agent(
             agent_config=react_config_together,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
-
-        agent = Agent(
-            agent_config=fc_config_together,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
 
-    def test_groq(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
+        with self.with_provider_fallback("Together AI"):
+            agent.chat("What is 5 times 10. Only give the answer, nothing else")
+            agent.chat("what is 3 times 7. Only give the answer, nothing else")
+            res = agent.chat(
+                "multiply the results of the last two multiplications. Only give the answer, nothing else."
+            )
+            self.check_response_and_skip(res, "Together AI")
+            self.assertIn("1050", res.response)
 
+        # Test Function Calling agent with Together
         agent = Agent(
-            agent_config=react_config_groq,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            agent_config=fc_config_together,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
 
-        agent = Agent(
-            agent_config=fc_config_groq,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
-        self.assertIn("1050", res.response)
+        with self.with_provider_fallback("Together AI"):
+            agent.chat("What is 5 times 10. Only give the answer, nothing else")
+            agent.chat("what is 3 times 7. Only give the answer, nothing else")
+            res = agent.chat(
+                "multiply the results of the last two multiplications. Only give the answer, nothing else."
+            )
+            self.check_response_and_skip(res, "Together AI")
+            self.assertIn("1050", res.response)
 
     def test_anthropic(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-
         agent = Agent(
             agent_config=react_config_anthropic,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat(
+            "multiply the results of the last two multiplications. Only give the answer, nothing else."
+        )
         self.assertIn("1050", res.response)
 
         agent = Agent(
             agent_config=fc_config_anthropic,
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.instructions,
         )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        res = agent.chat(
+            "multiply the results of the last two multiplications. Only give the answer, nothing else."
+        )
         self.assertIn("1050", res.response)
 
 

tests/test_api_endpoint.py

@@ -1,3 +1,7 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 from uuid import UUID
 

tests/test_bedrock.py

@@ -1,41 +1,60 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
+import threading
 
-from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
-from vectara_agentic.types import ModelProvider
 
 import nest_asyncio
 nest_asyncio.apply()
 
-
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
-
-
-fc_config_bedrock = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.BEDROCK,
-    tool_llm_provider=ModelProvider.BEDROCK,
-)
-
-class TestBedrock(unittest.TestCase):
-
-    def test_multiturn(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
-        self.assertEqual(res.response, "1050")
+from conftest import mult, fc_config_bedrock, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+
+ARIZE_LOCK = threading.Lock()
+
+class TestBedrock(unittest.IsolatedAsyncioTestCase):
+
+    async def test_multiturn(self):
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            agent = Agent(
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+                agent_config=fc_config_bedrock,
+            )
+
+            # First calculation: 5 * 10 = 50
+            stream1 = await agent.astream_chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            )
+            # Consume the stream
+            async for chunk in stream1.async_response_gen():
+                pass
+            _ = await stream1.aget_response()
+
+            # Second calculation: 3 * 7 = 21
+            stream2 = await agent.astream_chat(
+                "what is 3 times 7. Only give the answer, nothing else"
+            )
+            # Consume the stream
+            async for chunk in stream2.async_response_gen():
+                pass
+            _ = await stream2.aget_response()
+
+            # Final calculation: 50 * 21 = 1050
+            stream3 = await agent.astream_chat(
+                "multiply the results of the last two questions. Output only the answer."
+            )
+            # Consume the stream
+            async for chunk in stream3.async_response_gen():
+                pass
+            response3 = await stream3.aget_response()
+
+            self.assertEqual(response3.response, "1050")
 
 
 if __name__ == "__main__":

tests/test_fallback.py

@@ -1,3 +1,7 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import os
 import unittest
 import subprocess

tests/test_gemini.py

@@ -1,16 +1,18 @@
-import unittest
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
 
-from pydantic import Field, BaseModel
+import unittest
 
-from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import VectaraToolFactory
-from vectara_agentic.types import ModelProvider
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import ToolsFactory
 
 
 import nest_asyncio
 nest_asyncio.apply()
 
+from conftest import mult, fc_config_gemini, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+
 tickers = {
     "C": "Citigroup",
     "COF": "Capital One",
@@ -32,11 +34,6 @@ tickers = {
 years = list(range(2015, 2025))
 
 
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
-
-
 def get_company_info() -> list[str]:
     """
     Returns a dictionary of companies you can query about. Always check this before using any other tool.
@@ -54,61 +51,32 @@ def get_valid_years() -> list[str]:
     return years
 
 
-fc_config_gemini = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GEMINI,
-    tool_llm_provider=ModelProvider.GEMINI,
-)
-
-
 class TestGEMINI(unittest.TestCase):
+    def test_gemini(self):
+        tools = [ToolsFactory().create_tool(mult)]
 
-    def test_tool_with_many_arguments(self):
-
-        vectara_corpus_key = "vectara-docs_1"
-        vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
-        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
-
-        class QueryToolArgs(BaseModel):
-            arg1: str = Field(description="the first argument", examples=["val1"])
-            arg2: str = Field(description="the second argument", examples=["val2"])
-            arg3: str = Field(description="the third argument", examples=["val3"])
-            arg4: str = Field(description="the fourth argument", examples=["val4"])
-            arg5: str = Field(description="the fifth argument", examples=["val5"])
-            arg6: str = Field(description="the sixth argument", examples=["val6"])
-            arg7: str = Field(description="the seventh argument", examples=["val7"])
-            arg8: str = Field(description="the eighth argument", examples=["val8"])
-            arg9: str = Field(description="the ninth argument", examples=["val9"])
-            arg10: str = Field(description="the tenth argument", examples=["val10"])
-            arg11: str = Field(description="the eleventh argument", examples=["val11"])
-            arg12: str = Field(description="the twelfth argument", examples=["val12"])
-            arg13: str = Field(
-                description="the thirteenth argument", examples=["val13"]
-            )
-            arg14: str = Field(
-                description="the fourteenth argument", examples=["val14"]
-            )
-            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
-
-        query_tool_1 = vec_factory.create_rag_tool(
-            tool_name="rag_tool",
-            tool_description="""
-            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
-            We are using this tool to test the tool factory works and does not crash with OpenAI.
-            """,
-            tool_args_schema=QueryToolArgs,
+        agent = Agent(
+            agent_config=fc_config_gemini,
+            tools=tools,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=STANDARD_TEST_INSTRUCTIONS,
         )
+        _ = agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        _ = agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("what is the result of multiplying the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+    def test_gemini_single_prompt(self):
+        tools = [ToolsFactory().create_tool(mult)]
 
         agent = Agent(
-            tools=[query_tool_1],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments",
             agent_config=fc_config_gemini,
+            tools=tools,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=STANDARD_TEST_INSTRUCTIONS,
         )
-        res = agent.chat("What is the stock price?")
-        self.assertTrue(
-            any(sub in str(res) for sub in ["I don't know", "I do not have"])
-        )
+        res = agent.chat("First, multiply 5 by 10. Then, multiply 3 by 7. Finally, multiply the results of the first two calculations.")
+        self.assertIn("1050", res.response)
 
 
 if __name__ == "__main__":

tests/test_groq.py

@@ -1,41 +1,60 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
+import threading
 
-from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
-from vectara_agentic.types import ModelProvider
 
 import nest_asyncio
 nest_asyncio.apply()
 
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
-
-
-fc_config_groq = AgentConfig(
-    agent_type=AgentType.FUNCTION_CALLING,
-    main_llm_provider=ModelProvider.GROQ,
-    tool_llm_provider=ModelProvider.GROQ,
-)
-
-
-class TestGROQ(unittest.TestCase):
-
-    def test_multiturn(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
-
-        agent.chat("What is 5 times 10. Only give the answer, nothing else")
-        agent.chat("what is 3 times 7. Only give the answer, nothing else")
-        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
-        self.assertEqual(res.response, "1050")
+from conftest import mult, fc_config_groq, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+
+ARIZE_LOCK = threading.Lock()
+
+class TestGROQ(unittest.IsolatedAsyncioTestCase):
+
+    async def test_multiturn(self):
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            agent = Agent(
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+                agent_config=fc_config_groq,
+            )
+
+            # First calculation: 5 * 10 = 50
+            stream1 = await agent.astream_chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            )
+            # Consume the stream
+            async for chunk in stream1.async_response_gen():
+                pass
+            _ = await stream1.aget_response()
+
+            # Second calculation: 3 * 7 = 21
+            stream2 = await agent.astream_chat(
+                "what is 3 times 7. Only give the answer, nothing else"
+            )
+            # Consume the stream
+            async for chunk in stream2.async_response_gen():
+                pass
+            _ = await stream2.aget_response()
+
+            # Final calculation: 50 * 21 = 1050
+            stream3 = await agent.astream_chat(
+                "multiply the results of the last two questions. Output only the answer."
+            )
+            # Consume the stream
+            async for chunk in stream3.async_response_gen():
+                pass
+            response3 = await stream3.aget_response()
+
+            self.assertEqual(response3.response, "1050")
 
 
 if __name__ == "__main__":

tests/test_private_llm.py

@@ -1,3 +1,7 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import os
 import unittest
 import subprocess
@@ -48,19 +52,24 @@ class TestPrivateLLM(unittest.TestCase):
         topic = "calculator"
         custom_instructions = "you are an agent specializing in math, assisting a user."
         config = AgentConfig(
-            agent_type=AgentType.REACT,
+            agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.PRIVATE,
             main_llm_model_name="gpt-4.1",
             private_llm_api_base=f"http://127.0.0.1:{FLASK_PORT}/v1",
             private_llm_api_key="TEST_API_KEY",
         )
         agent = Agent(agent_config=config, tools=tools, topic=topic,
-                      custom_instructions=custom_instructions)
+                      custom_instructions=custom_instructions, verbose=False)
 
         # To run this test, you must have OPENAI_API_KEY in your environment
         res = agent.chat(
             "What is 5 times 10. Only give the answer, nothing else."
         ).response
+        if res is None:
+            self.fail("Agent returned None response")
+        # Convert to string for comparison if it's a number
+        if isinstance(res, (int, float)):
+            res = str(int(res))
         self.assertEqual(res, "50")
 
 

tests/test_return_direct.py

@@ -1,3 +1,7 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 
 from vectara_agentic.agent import Agent
@@ -26,7 +30,7 @@ class TestAgentPackage(unittest.TestCase):
             custom_instructions="You are a helpful assistant.",
         )
         res = agent.chat("What is Vectara?")
-        self.assertIn("Vectara is an end-to-end platform designed", str(res))
+        self.assertIn("Vectara is an end-to-end platform", str(res))
 
     def test_from_corpus(self):
         agent = Agent.from_corpus(
@@ -38,7 +42,7 @@ class TestAgentPackage(unittest.TestCase):
             return_direct=True,
         )
         res = agent.chat("What is Vectara?")
-        self.assertIn("Vectara is an end-to-end platform designed", str(res))
+        self.assertIn("Vectara is an end-to-end platform", str(res))
 
 
 if __name__ == "__main__":