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

tests/conftest.py

@@ -101,9 +101,9 @@ react_config_anthropic = AgentConfig(
 react_config_gemini = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.GEMINI,
-    main_llm_model_name="models/gemini-2.5-flash",
+    main_llm_model_name="models/gemini-2.5-flash-lite",
     tool_llm_provider=ModelProvider.GEMINI,
-    tool_llm_model_name="models/gemini-2.5-flash",
+    tool_llm_model_name="models/gemini-2.5-flash-lite",
 )
 
 react_config_together = AgentConfig(
@@ -112,29 +112,36 @@ react_config_together = AgentConfig(
     tool_llm_provider=ModelProvider.TOGETHER,
 )
 
+react_config_openai = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.OPENAI,
+    tool_llm_provider=ModelProvider.OPENAI,
+)
+
 react_config_groq = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.GROQ,
     tool_llm_provider=ModelProvider.GROQ,
 )
 
+
 # Private LLM configurations
 private_llm_react_config = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.PRIVATE,
-    main_llm_model_name="gpt-4o",
+    main_llm_model_name="gpt-4.1-mini",
     private_llm_api_base="http://localhost:8000/v1",
     tool_llm_provider=ModelProvider.PRIVATE,
-    tool_llm_model_name="gpt-4o",
+    tool_llm_model_name="gpt-4.1-mini",
 )
 
 private_llm_fc_config = AgentConfig(
     agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.PRIVATE,
-    main_llm_model_name="gpt-4.1",
+    main_llm_model_name="gpt-4.1-mini",
     private_llm_api_base="http://localhost:8000/v1",
     tool_llm_provider=ModelProvider.PRIVATE,
-    tool_llm_model_name="gpt-4.1",
+    tool_llm_model_name="gpt-4.1-mini",
 )
 
 
@@ -161,14 +168,6 @@ def is_rate_limited(response_text: str) -> bool:
         "rate limit",
         "quota exceeded",
         "usage limit",
-        # GROQ-specific
-        "tokens per day",
-        "TPD",
-        "service tier",
-        "on_demand",
-        "deepseek-r1-distill-llama-70b",
-        "Upgrade to Dev Tier",
-        "console.groq.com/settings/billing",
         # OpenAI-specific
         "requests per minute",
         "RPM",
@@ -188,6 +187,9 @@ def is_rate_limited(response_text: str) -> bool:
         # Additional rate limit patterns
         "Limit.*Used.*Requested",
         "Need more tokens",
+        # Provider failure patterns
+        "failure can't be resolved after",
+        "Got empty message",
     ]
 
     response_lower = response_text.lower()
@@ -279,10 +281,10 @@ class AgentTestMixin:
             provider: Provider name for error messages
 
         Usage:
-            with self.with_provider_fallback("GROQ"):
+            with self.with_provider_fallback("OpenAI"):
                 response = agent.chat("test")
 
-            with self.with_provider_fallback("GROQ"):
+            with self.with_provider_fallback("OpenAI"):
                 async for chunk in agent.astream_chat("test"):
                     pass
 

tests/endpoint.py

@@ -10,12 +10,13 @@ app = Flask(__name__)
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 app.logger.setLevel(logging.INFO)
-werkzeug_log = logging.getLogger('werkzeug')
+werkzeug_log = logging.getLogger("werkzeug")
 werkzeug_log.setLevel(logging.ERROR)
 
 # Load expected API key from environment (fallback for testing)
 EXPECTED_API_KEY = "TEST_API_KEY"
 
+
 # Authentication decorator
 def require_api_key(f):
     @wraps(f)
@@ -27,12 +28,15 @@ def require_api_key(f):
         if api_key != EXPECTED_API_KEY:
             return jsonify({"error": "Unauthorized"}), 401
         return f(*args, **kwargs)
+
     return decorated_function
 
+
 @app.before_request
 def log_request_info():
     app.logger.info("%s %s", request.method, request.path)
 
+
 @app.route("/v1/chat/completions", methods=["POST"])
 @require_api_key
 def chat_completions():
@@ -46,7 +50,7 @@ def chat_completions():
         return jsonify({"error": "Invalid JSON payload"}), 400
 
     client = OpenAI()
-    is_stream = data.get('stream', False)
+    is_stream = data.get("stream", False)
 
     if is_stream:
         # Stream each chunk to the client as Server-Sent Events
@@ -62,9 +66,9 @@ def chat_completions():
                 yield f"data: {error_msg}\n\n"
 
         headers = {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive'
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
         }
         return Response(generate(), headers=headers)
 

tests/run_tests.py

@@ -35,6 +35,8 @@ def suppress_pydantic_warnings():
         ".*unclosed transport.*",
         ".*unclosed <socket\\.socket.*",
         ".*unclosed event loop.*",
+        ".*unclosed resource <TCPTransport.*",
+        ".*Implicitly cleaning up <TemporaryDirectory.*",
     ]
 
     for pattern in pydantic_patterns:
@@ -64,6 +66,7 @@ def main():
 
     # Add tests directory to Python path for relative imports
     import os
+
     sys.path.insert(0, os.path.abspath("tests"))
 
     # Discover and run tests

tests/test_agent.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -18,7 +19,32 @@ from conftest import mult, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
 
 ARIZE_LOCK = threading.Lock()
 
+
 class TestAgentPackage(unittest.TestCase):
+    def setUp(self):
+        self.agents_to_cleanup = []
+
+    def tearDown(self):
+        import gc
+        import asyncio
+
+        for agent in self.agents_to_cleanup:
+            if hasattr(agent, "cleanup"):
+                agent.cleanup()
+
+        # Force garbage collection to clean up any remaining references
+        gc.collect()
+
+        # Cancel any remaining asyncio tasks without closing the event loop
+        try:
+            loop = asyncio.get_event_loop()
+            if not loop.is_closed():
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+        except RuntimeError:
+            pass
+
     def test_get_prompt(self):
         prompt_template = "{chat_topic} on {today} with {custom_instructions}"
         topic = "Programming"
@@ -29,12 +55,16 @@ class TestAgentPackage(unittest.TestCase):
             + " with Always do as your mother tells you!"
         )
         self.assertEqual(
-            format_prompt(prompt_template, GENERAL_INSTRUCTIONS, topic, custom_instructions), expected_output
+            format_prompt(
+                prompt_template, GENERAL_INSTRUCTIONS, topic, custom_instructions
+            ),
+            expected_output,
         )
 
     def test_agent_init(self):
         tools = [ToolsFactory().create_tool(mult)]
         agent = Agent(tools, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS)
+        self.agents_to_cleanup.append(agent)
         self.assertEqual(agent.agent_type, AgentType.FUNCTION_CALLING)
         self.assertEqual(agent._topic, STANDARD_TEST_TOPIC)
         self.assertEqual(agent._custom_instructions, STANDARD_TEST_INSTRUCTIONS)
@@ -56,21 +86,26 @@ class TestAgentPackage(unittest.TestCase):
                 main_llm_model_name="claude-sonnet-4-20250514",
                 tool_llm_provider=ModelProvider.TOGETHER,
                 tool_llm_model_name="moonshotai/Kimi-K2-Instruct",
-                observer=ObserverType.ARIZE_PHOENIX
+                observer=ObserverType.ARIZE_PHOENIX,
             )
 
             agent = Agent(
                 tools=tools,
                 topic=STANDARD_TEST_TOPIC,
                 custom_instructions=STANDARD_TEST_INSTRUCTIONS,
-                agent_config=config
+                agent_config=config,
             )
+            self.agents_to_cleanup.append(agent)
             self.assertEqual(agent._topic, STANDARD_TEST_TOPIC)
             self.assertEqual(agent._custom_instructions, STANDARD_TEST_INSTRUCTIONS)
             self.assertEqual(agent.agent_type, AgentType.REACT)
             self.assertEqual(agent.agent_config.observer, ObserverType.ARIZE_PHOENIX)
-            self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
-            self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
+            self.assertEqual(
+                agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC
+            )
+            self.assertEqual(
+                agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER
+            )
 
             # To run this test, you must have ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
             self.assertEqual(
@@ -90,10 +125,13 @@ class TestAgentPackage(unittest.TestCase):
                 topic=topic,
                 custom_instructions=instructions,
             )
+            self.agents_to_cleanup.append(agent)
 
             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.")
+            res = agent.chat(
+                "multiply the results of the last two questions. Output only the answer."
+            )
             self.assertEqual(res.response, "1050")
 
     def test_from_corpus(self):
@@ -104,6 +142,7 @@ class TestAgentPackage(unittest.TestCase):
             data_description="information",
             assistant_specialty="question answering",
         )
+        self.agents_to_cleanup.append(agent)
 
         self.assertIsInstance(agent, Agent)
         self.assertEqual(agent._topic, "question answering")
@@ -116,14 +155,17 @@ class TestAgentPackage(unittest.TestCase):
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
-            chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
+            chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")],
         )
+        self.agents_to_cleanup.append(agent)
 
         data = agent.dumps()
         clone = Agent.loads(data)
         assert clone.memory.get() == agent.memory.get()
 
-        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        res = agent.chat(
+            "multiply the results of the last two questions. Output only the answer."
+        )
         self.assertEqual(res.response, "1050")
 
     def test_custom_general_instruction(self):
@@ -136,8 +178,10 @@ class TestAgentPackage(unittest.TestCase):
             assistant_specialty="question answering",
             general_instructions=general_instructions,
         )
+        self.agents_to_cleanup.append(agent)
 
         res = agent.chat("What is the meaning of the universe?")
+        print(f"Response: {res.response}")
         self.assertEqual(res.response, "I DIDN'T DO IT")
 
 

tests/test_agent_type.py

@@ -7,6 +7,7 @@ import unittest
 
 import sys
 import os
+
 sys.path.insert(0, os.path.dirname(__file__))
 
 from conftest import (
@@ -25,6 +26,7 @@ from conftest import (
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
 
+
 class TestAgentType(unittest.TestCase, AgentTestMixin):
 
     def setUp(self):

tests/test_api_endpoint.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -21,6 +22,7 @@ class DummyAgent(Agent):
     def chat(self, message: str) -> str:
         return f"Echo: {message}"
 
+
 class APITestCase(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
@@ -42,7 +44,9 @@ class APITestCase(unittest.TestCase):
         self.assertIn("No message provided", r.json()["detail"])
 
     def test_chat_unauthorized(self):
-        r = self.client.get("/chat", params={"message": "hello"}, headers={"X-API-Key": "bad"})
+        r = self.client.get(
+            "/chat", params={"message": "hello"}, headers={"X-API-Key": "bad"}
+        )
         self.assertEqual(r.status_code, 403)
 
     def test_completions_success(self):
@@ -69,14 +73,13 @@ class APITestCase(unittest.TestCase):
 
     def test_completions_unauthorized(self):
         payload = {"model": "m1", "prompt": "hi"}
-        r = self.client.post("/v1/completions", json=payload, headers={"X-API-Key": "bad"})
+        r = self.client.post(
+            "/v1/completions", json=payload, headers={"X-API-Key": "bad"}
+        )
         self.assertEqual(r.status_code, 403)
 
     def test_chat_completion_success(self):
-        payload = {
-            "model": "m1",
-            "messages": [{"role": "user", "content": "hello"}]
-        }
+        payload = {"model": "m1", "messages": [{"role": "user", "content": "hello"}]}
         r = self.client.post("/v1/chat", json=payload, headers=self.headers)
         self.assertEqual(r.status_code, 200)
         data = r.json()
@@ -99,8 +102,8 @@ class APITestCase(unittest.TestCase):
                 {"role": "system", "content": "ignore me"},
                 {"role": "user", "content": "foo"},
                 {"role": "assistant", "content": "pong"},
-                {"role": "user", "content": "bar"}
-            ]
+                {"role": "user", "content": "bar"},
+            ],
         }
         r = self.client.post("/v1/chat", json=payload, headers=self.headers)
         self.assertEqual(r.status_code, 200)
@@ -108,7 +111,7 @@ class APITestCase(unittest.TestCase):
 
         # Should concatenate only user messages: "foo bar"
         self.assertEqual(data["choices"][0]["message"]["content"], "Echo: foo bar")
-        self.assertEqual(data["usage"]["prompt_tokens"], 2)   # "foo","bar"
+        self.assertEqual(data["usage"]["prompt_tokens"], 2)  # "foo","bar"
         self.assertEqual(data["usage"]["completion_tokens"], 3)  # "Echo:","foo","bar"
 
     def test_chat_completion_no_messages(self):
@@ -118,10 +121,7 @@ class APITestCase(unittest.TestCase):
         self.assertIn("`messages` is required", r.json()["detail"])
 
     def test_chat_completion_unauthorized(self):
-        payload = {
-            "model": "m1",
-            "messages": [{"role": "user", "content": "oops"}]
-        }
+        payload = {"model": "m1", "messages": [{"role": "user", "content": "oops"}]}
         r = self.client.post("/v1/chat", json=payload, headers={"X-API-Key": "bad"})
         self.assertEqual(r.status_code, 403)
 

tests/test_bedrock.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -9,12 +10,19 @@ from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
 
 import nest_asyncio
+
 nest_asyncio.apply()
 
-from conftest import mult, fc_config_bedrock, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+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):

tests/test_fallback.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import os
@@ -16,19 +17,25 @@ from vectara_agentic.tools import ToolsFactory
 
 FLASK_PORT = 5002
 
+
 class TestFallback(unittest.TestCase):
 
     @classmethod
     def setUp(cls):
         # Start the Flask server as a subprocess
         cls.flask_process = subprocess.Popen(
-            ['flask', 'run', f'--port={FLASK_PORT}'],
-            env={**os.environ, 'FLASK_APP': 'tests.endpoint:app', 'FLASK_ENV': 'development'},
-            stdout=None, stderr=None,
+            ["flask", "run", f"--port={FLASK_PORT}"],
+            env={
+                **os.environ,
+                "FLASK_APP": "tests.endpoint:app",
+                "FLASK_ENV": "development",
+            },
+            stdout=None,
+            stderr=None,
         )
         # Wait for the server to start
         timeout = 10
-        url = f'http://127.0.0.1:{FLASK_PORT}/'
+        url = f"http://127.0.0.1:{FLASK_PORT}/"
         for _ in range(timeout):
             try:
                 requests.get(url)
@@ -54,7 +61,7 @@ class TestFallback(unittest.TestCase):
         config = AgentConfig(
             agent_type=AgentType.REACT,
             main_llm_provider=ModelProvider.PRIVATE,
-            main_llm_model_name="gpt-4o",
+            main_llm_model_name="gpt-4.1-mini",
             private_llm_api_base=f"http://127.0.0.1:{FLASK_PORT}/v1",
             private_llm_api_key="TEST_API_KEY",
         )
@@ -62,9 +69,13 @@ class TestFallback(unittest.TestCase):
         # Set fallback agent config to OpenAI agent
         fallback_config = AgentConfig()
 
-        agent = Agent(agent_config=config, tools=tools, topic=topic,
-                      custom_instructions=custom_instructions,
-                      fallback_agent_config=fallback_config)
+        agent = Agent(
+            agent_config=config,
+            tools=tools,
+            topic=topic,
+            custom_instructions=custom_instructions,
+            fallback_agent_config=fallback_config,
+        )
 
         # To run this test, you must have OPENAI_API_KEY in your environment
         res = agent.chat(

tests/test_gemini.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -9,46 +10,15 @@ 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",
-    "JPM": "JPMorgan Chase",
-    "AAPL": "Apple Computer",
-    "GOOG": "Google",
-    "AMZN": "Amazon",
-    "SNOW": "Snowflake",
-    "TEAM": "Atlassian",
-    "TSLA": "Tesla",
-    "NVDA": "Nvidia",
-    "MSFT": "Microsoft",
-    "AMD": "Advanced Micro Devices",
-    "INTC": "Intel",
-    "NFLX": "Netflix",
-    "STT": "State Street",
-    "BK": "Bank of New York Mellon",
-}
-years = list(range(2015, 2025))
-
-
-def get_company_info() -> list[str]:
-    """
-    Returns a dictionary of companies you can query about. Always check this before using any other tool.
-    The output is a dictionary of valid ticker symbols mapped to company names.
-    You can use this to identify the companies you can query about, and their ticker information.
-    """
-    return tickers
 
+nest_asyncio.apply()
 
-def get_valid_years() -> list[str]:
-    """
-    Returns a list of the years for which financial reports are available.
-    Always check this before using any other tool.
-    """
-    return years
+from conftest import (
+    mult,
+    fc_config_gemini,
+    STANDARD_TEST_TOPIC,
+    STANDARD_TEST_INSTRUCTIONS,
+)
 
 
 class TestGEMINI(unittest.TestCase):
@@ -63,7 +33,9 @@ class TestGEMINI(unittest.TestCase):
         )
         _ = 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_gemini_single_prompt(self):
@@ -75,7 +47,9 @@ class TestGEMINI(unittest.TestCase):
             topic=STANDARD_TEST_TOPIC,
             custom_instructions=STANDARD_TEST_INSTRUCTIONS,
         )
-        res = agent.chat("First, multiply 5 by 10. Then, multiply 3 by 7. Finally, multiply the results of the first two calculations.")
+        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)
 
 

tests/test_groq.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -9,12 +10,19 @@ from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
 
 import nest_asyncio
+
 nest_asyncio.apply()
 
-from conftest import mult, fc_config_groq, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+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):

tests/test_private_llm.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import os
@@ -16,19 +17,26 @@ from vectara_agentic.tools import ToolsFactory
 
 
 FLASK_PORT = 5001
+
+
 class TestPrivateLLM(unittest.TestCase):
 
     @classmethod
     def setUp(cls):
         # Start the Flask server as a subprocess
         cls.flask_process = subprocess.Popen(
-            ['flask', 'run', f'--port={FLASK_PORT}'],
-            env={**os.environ, 'FLASK_APP': 'tests.endpoint:app', 'FLASK_ENV': 'development'},
-            stdout=None, stderr=None,
+            ["flask", "run", f"--port={FLASK_PORT}"],
+            env={
+                **os.environ,
+                "FLASK_APP": "tests.endpoint:app",
+                "FLASK_ENV": "development",
+            },
+            stdout=None,
+            stderr=None,
         )
         # Wait for the server to start
         timeout = 10
-        url = f'http://127.0.0.1:{FLASK_PORT}/'
+        url = f"http://127.0.0.1:{FLASK_PORT}/"
         for _ in range(timeout):
             try:
                 requests.get(url)
@@ -54,12 +62,17 @@ class TestPrivateLLM(unittest.TestCase):
         config = AgentConfig(
             agent_type=AgentType.FUNCTION_CALLING,
             main_llm_provider=ModelProvider.PRIVATE,
-            main_llm_model_name="gpt-4.1",
+            main_llm_model_name="gpt-4.1-mini",
             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, verbose=False)
+        agent = Agent(
+            agent_config=config,
+            tools=tools,
+            topic=topic,
+            custom_instructions=custom_instructions,
+            verbose=False,
+        )
 
         # To run this test, you must have OPENAI_API_KEY in your environment
         res = agent.chat(