vectara-agentic 0.4.2__py3-none-any.whl → 0.4.4__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,12 +112,19 @@ 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,
@@ -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

@@ -66,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,6 +19,7 @@ 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 = []
@@ -27,7 +29,7 @@ class TestAgentPackage(unittest.TestCase):
         import asyncio
 
         for agent in self.agents_to_cleanup:
-            if hasattr(agent, 'cleanup'):
+            if hasattr(agent, "cleanup"):
                 agent.cleanup()
 
         # Force garbage collection to clean up any remaining references
@@ -53,7 +55,10 @@ 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):
@@ -81,22 +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(
@@ -120,7 +129,9 @@ class TestAgentPackage(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("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):
@@ -144,7 +155,7 @@ 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)
 
@@ -152,7 +163,9 @@ class TestAgentPackage(unittest.TestCase):
         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):

tests/test_agent_fallback_memory.py

@@ -70,7 +70,7 @@ class TestAgentFallbackMemoryConsistency(unittest.TestCase):
 
         # Verify session_id consistency
         # Memory is managed by the main Agent class
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
     def test_memory_sync_during_agent_switching(self):
         """Test that memory remains consistent when switching between main and fallback agents"""
@@ -219,13 +219,13 @@ class TestAgentFallbackMemoryConsistency(unittest.TestCase):
 
         # Verify main agent session_id consistency
         self.assertEqual(agent.session_id, self.session_id)
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
         # Verify session_id consistency across all agents
         # Memory is managed by the main Agent class
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
         self.assertEqual(
-            agent.memory.chat_store_key, self.session_id
+            agent.memory.session_id, self.session_id
         )  # Both access same memory
 
     def test_agent_recreation_on_switch(self):

tests/test_agent_memory_consistency.py

@@ -172,21 +172,21 @@ class TestAgentMemoryConsistency(unittest.TestCase):
 
         # Verify initial session_id
         self.assertEqual(agent.session_id, self.session_id)
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
         # Switch configurations multiple times
         agent._switch_agent_config()
         self.assertEqual(agent.session_id, self.session_id)
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
         agent._switch_agent_config()
         self.assertEqual(agent.session_id, self.session_id)
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
         # Clear memory
         agent.clear_memory()
         self.assertEqual(agent.session_id, self.session_id)
-        self.assertEqual(agent.memory.chat_store_key, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
 
     def test_serialization_preserves_consistency(self):
         """Test that serialization/deserialization preserves memory consistency behavior"""

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)
@@ -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
@@ -7,14 +8,23 @@ import threading
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import AgentType, ModelProvider
 
 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):
@@ -56,6 +66,38 @@ class TestGROQ(unittest.IsolatedAsyncioTestCase):
 
             self.assertEqual(response3.response, "1050")
 
+    async def test_gpt_oss_120b(self):
+        """Test GPT-OSS-120B model with GROQ provider."""
+        with ARIZE_LOCK:
+            # Create config specifically for GPT-OSS-120B via GROQ
+            gpt_oss_config = AgentConfig(
+                agent_type=AgentType.FUNCTION_CALLING,
+                main_llm_provider=ModelProvider.GROQ,
+                main_llm_model_name="openai/gpt-oss-120b",
+                tool_llm_provider=ModelProvider.GROQ,
+                tool_llm_model_name="openai/gpt-oss-120b",
+            )
+
+            tools = [ToolsFactory().create_tool(mult)]
+            agent = Agent(
+                agent_config=gpt_oss_config,
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+            )
+
+            # Test simple multiplication: 8 * 6 = 48
+            stream = await agent.astream_chat(
+                "What is 8 times 6? Only give the answer, nothing else"
+            )
+            # Consume the stream
+            async for chunk in stream.async_response_gen():
+                pass
+            response = await stream.aget_response()
+
+            # Verify the response contains the correct answer
+            self.assertIn("48", response.response)
+
 
 if __name__ == "__main__":
     unittest.main()