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

tests/__init__.py

@@ -0,0 +1,7 @@
+"""
+Tests package for vectara_agentic.
+"""
+
+# Suppress external dependency warnings globally for all tests
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)

tests/conftest.py

@@ -0,0 +1,316 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+
+warnings.simplefilter("ignore", DeprecationWarning)
+
+"""
+Common test utilities, configurations, and fixtures for the vectara-agentic test suite.
+"""
+
+import unittest
+from contextlib import contextmanager
+from typing import Any
+
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import AgentType, ModelProvider
+
+
+# ========================================
+# Common Test Functions
+# ========================================
+
+
+def mult(x: float, y: float) -> float:
+    """Multiply two numbers - common test function used across multiple test files."""
+    return x * y
+
+
+def add(x: float, y: float) -> float:
+    """Add two numbers - common test function used in workflow tests."""
+    return x + y
+
+
+# ========================================
+# Common Test Data
+# ========================================
+
+# Standard test topic used across most tests
+STANDARD_TEST_TOPIC = "AI topic"
+
+# Standard test instructions used across most tests
+STANDARD_TEST_INSTRUCTIONS = (
+    "Always do as your father tells you, if your mother agrees!"
+)
+
+# Alternative instructions for specific tests
+WORKFLOW_TEST_INSTRUCTIONS = "You are a helpful AI assistant."
+MATH_AGENT_INSTRUCTIONS = "you are an agent specializing in math, assisting a user."
+
+
+# ========================================
+# Agent Configuration Objects
+# ========================================
+
+# Default configurations
+default_config = AgentConfig()
+
+# Function Calling configurations for all providers
+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,
+)
+
+fc_config_openai = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.OPENAI,
+    tool_llm_provider=ModelProvider.OPENAI,
+)
+
+fc_config_groq = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GROQ,
+    tool_llm_provider=ModelProvider.GROQ,
+)
+
+fc_config_bedrock = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.BEDROCK,
+    tool_llm_provider=ModelProvider.BEDROCK,
+)
+
+# ReAct configurations for all providers
+react_config_anthropic = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+react_config_gemini = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.GEMINI,
+    main_llm_model_name="models/gemini-2.5-flash",
+    tool_llm_provider=ModelProvider.GEMINI,
+    tool_llm_model_name="models/gemini-2.5-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,
+)
+
+# Private LLM configurations
+private_llm_react_config = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.PRIVATE,
+    main_llm_model_name="gpt-4o",
+    private_llm_api_base="http://localhost:8000/v1",
+    tool_llm_provider=ModelProvider.PRIVATE,
+    tool_llm_model_name="gpt-4o",
+)
+
+private_llm_fc_config = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.PRIVATE,
+    main_llm_model_name="gpt-4.1",
+    private_llm_api_base="http://localhost:8000/v1",
+    tool_llm_provider=ModelProvider.PRIVATE,
+    tool_llm_model_name="gpt-4.1",
+)
+
+
+# ========================================
+# Error Detection and Testing Utilities
+# ========================================
+
+
+def is_rate_limited(response_text: str) -> bool:
+    """
+    Check if a response indicates a rate limit error from any LLM provider.
+
+    Args:
+        response_text: The response text from the agent
+
+    Returns:
+        bool: True if the response indicates rate limiting
+    """
+    rate_limit_indicators = [
+        # Generic indicators
+        "Error code: 429",
+        "rate_limit_exceeded",
+        "Rate limit reached",
+        "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",
+        "tokens per minute",
+        "TPM",
+        # Anthropic-specific
+        "overloaded_error",
+        "Overloaded",
+        "APIStatusError",
+        "anthropic.APIStatusError",
+        "usage_limit_exceeded",
+        # General API limit indicators
+        "try again in",
+        "Please wait",
+        "Too many requests",
+        "throttled",
+        # Additional rate limit patterns
+        "Limit.*Used.*Requested",
+        "Need more tokens",
+    ]
+
+    response_lower = response_text.lower()
+    return any(
+        indicator.lower() in response_lower for indicator in rate_limit_indicators
+    )
+
+
+def is_api_key_error(response_text: str) -> bool:
+    """
+    Check if a response indicates an API key authentication error.
+
+    Args:
+        response_text: The response text from the agent
+
+    Returns:
+        bool: True if the response indicates API key issues
+    """
+    api_key_indicators = [
+        "Error code: 401",
+        "Invalid API Key",
+        "authentication",
+        "unauthorized",
+        "invalid_api_key",
+        "missing api key",
+        "api key not found",
+    ]
+
+    response_lower = response_text.lower()
+    return any(indicator.lower() in response_lower for indicator in api_key_indicators)
+
+
+def skip_if_rate_limited(
+    test_instance: unittest.TestCase, response_text: str, provider: str = "LLM"
+) -> None:
+    """
+    Skip a test if the response indicates rate limiting.
+
+    Args:
+        test_instance: The test case instance
+        response_text: The response text to check
+        provider: The name of the provider (for clearer skip messages)
+    """
+    if is_rate_limited(response_text):
+        test_instance.skipTest(f"{provider} rate limit reached - skipping test")
+
+
+def skip_if_api_key_error(
+    test_instance: unittest.TestCase, response_text: str, provider: str = "LLM"
+) -> None:
+    """
+    Skip a test if the response indicates API key issues.
+
+    Args:
+        test_instance: The test case instance
+        response_text: The response text to check
+        provider: The name of the provider (for clearer skip messages)
+    """
+    if is_api_key_error(response_text):
+        test_instance.skipTest(f"{provider} API key invalid/missing - skipping test")
+
+
+def skip_if_provider_error(
+    test_instance: unittest.TestCase, response_text: str, provider: str = "LLM"
+) -> None:
+    """
+    Skip a test if the response indicates common provider errors (rate limiting or API key issues).
+
+    Args:
+        test_instance: The test case instance
+        response_text: The response text to check
+        provider: The name of the provider (for clearer skip messages)
+    """
+    skip_if_rate_limited(test_instance, response_text, provider)
+    skip_if_api_key_error(test_instance, response_text, provider)
+
+
+class AgentTestMixin:
+    """
+    Mixin class providing utility methods for agent testing.
+    """
+
+    @contextmanager
+    def with_provider_fallback(self, provider: str = "LLM"):
+        """
+        Context manager that catches and handles provider errors from any agent method.
+
+        Args:
+            provider: Provider name for error messages
+
+        Usage:
+            with self.with_provider_fallback("GROQ"):
+                response = agent.chat("test")
+
+            with self.with_provider_fallback("GROQ"):
+                async for chunk in agent.astream_chat("test"):
+                    pass
+
+        Raises:
+            unittest.SkipTest: If rate limiting or API key errors occur
+        """
+        try:
+            yield
+        except Exception as e:
+            error_text = str(e)
+            if is_rate_limited(error_text) or is_api_key_error(error_text):
+                self.skipTest(f"{provider} error: {error_text}")
+            raise
+
+    def check_response_and_skip(self, response: Any, provider: str = "LLM") -> Any:
+        """
+        Check response content and skip test if provider errors are detected.
+
+        Args:
+            response: The response object from agent method
+            provider: Provider name for error messages
+
+        Returns:
+            The response object if no errors detected
+
+        Raises:
+            unittest.SkipTest: If rate limiting or API key errors detected in response
+        """
+        response_text = getattr(response, "response", str(response))
+        skip_if_provider_error(self, response_text, provider)
+        return response

tests/endpoint.py

@@ -1,47 +1,84 @@
-from openai import OpenAI
-from flask import Flask, request, jsonify
+#!/usr/bin/env python3
+import json
 import logging
 from functools import wraps
+from flask import Flask, request, Response, jsonify
+from openai import OpenAI
 
 app = Flask(__name__)
-app.config['TESTING'] = True
 
-log = logging.getLogger('werkzeug')
-log.setLevel(logging.ERROR)
-
-# Set your OpenAI API key (ensure you've set this in your environment)
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+app.logger.setLevel(logging.INFO)
+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)
     def decorated_function(*args, **kwargs):
-        api_key = request.headers.get("Authorization").split("Bearer ")[-1]
-        if not api_key or api_key != EXPECTED_API_KEY:
+        auth_header = request.headers.get("Authorization", "")
+        if not auth_header.startswith("Bearer "):
+            return jsonify({"error": "Unauthorized"}), 401
+        api_key = auth_header.split(" ", 1)[1]
+        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("Request received: %s %s", request.method, request.path)
+    app.logger.info("%s %s", request.method, request.path)
 
 @app.route("/v1/chat/completions", methods=["POST"])
 @require_api_key
 def chat_completions():
-    app.logger.info("Received request on /v1/chat/completions")
-    data = request.get_json()
-    if not data:
+    """
+    Proxy endpoint for OpenAI Chat Completions.
+    Supports both streaming and non-streaming modes.
+    """
+    try:
+        data = request.get_json(force=True)
+    except Exception:
         return jsonify({"error": "Invalid JSON payload"}), 400
 
     client = OpenAI()
+    is_stream = data.get('stream', False)
+
+    if is_stream:
+        # Stream each chunk to the client as Server-Sent Events
+        def generate():
+            try:
+                for chunk in client.chat.completions.create(**data):
+                    # Convert chunk to dict and then JSON
+                    event = chunk.model_dump()
+                    yield f"data: {json.dumps(event)}\n\n"
+            except Exception as e:
+                # On error, send an SSE event with error info
+                error_msg = json.dumps({"error": str(e)})
+                yield f"data: {error_msg}\n\n"
+
+        headers = {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        }
+        return Response(generate(), headers=headers)
+
+    # Non-streaming path
     try:
         completion = client.chat.completions.create(**data)
-        return jsonify(completion.model_dump()), 200
+        result = completion.model_dump()
+        app.logger.info(f"Non-stream response: {result}")
+        return jsonify(result), 200
     except Exception as e:
-        return jsonify({"error": str(e)}), 400
+        app.logger.error(f"Error during completion: {e}")
+        return jsonify({"error": str(e)}), 500
 
 
 if __name__ == "__main__":
-    # Run on port 5000 by default; adjust as needed.
-    app.run(debug=True, port=5000, use_reloader=False)
+    # Bind to all interfaces on port 5000
+    app.run(host="0.0.0.0", port=5000, debug=False, use_reloader=False)

tests/run_tests.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Custom test runner that suppresses Pydantic deprecation warnings.
+Usage: python run_tests.py [test_pattern]
+"""
+
+import sys
+import warnings
+import unittest
+import argparse
+import asyncio
+import gc
+
+
+def suppress_pydantic_warnings():
+    """Comprehensive warning suppression before unittest starts."""
+    # Multiple layers of suppression
+    warnings.resetwarnings()
+    warnings.simplefilter("ignore", DeprecationWarning)
+
+    # Specific Pydantic patterns
+    pydantic_patterns = [
+        ".*PydanticDeprecatedSince.*",
+        ".*__fields__.*deprecated.*",
+        ".*__fields_set__.*deprecated.*",
+        ".*model_fields.*deprecated.*",
+        ".*model_computed_fields.*deprecated.*",
+        ".*use.*model_fields.*instead.*",
+        ".*use.*model_fields_set.*instead.*",
+        ".*Accessing.*model_.*attribute.*deprecated.*",
+    ]
+
+    # Resource warning patterns (reduce noise, not critical)
+    resource_patterns = [
+        ".*unclosed transport.*",
+        ".*unclosed <socket\\.socket.*",
+        ".*unclosed event loop.*",
+    ]
+
+    for pattern in pydantic_patterns:
+        warnings.filterwarnings("ignore", category=DeprecationWarning, message=pattern)
+
+    for pattern in resource_patterns:
+        warnings.filterwarnings("ignore", category=ResourceWarning, message=pattern)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run tests with warning suppression")
+    parser.add_argument(
+        "pattern",
+        nargs="?",
+        default="test_*.py",
+        help="Test file pattern (default: test_*.py)",
+    )
+    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
+
+    args = parser.parse_args()
+
+    # Apply comprehensive warning suppression BEFORE unittest starts
+    suppress_pydantic_warnings()
+
+    print(f"🧪 Running tests with pattern: {args.pattern}")
+    print("🔇 Pydantic deprecation warnings suppressed")
+
+    # Add tests directory to Python path for relative imports
+    import os
+    sys.path.insert(0, os.path.abspath("tests"))
+
+    # Discover and run tests
+    loader = unittest.TestLoader()
+    start_dir = "tests"
+    suite = loader.discover(start_dir, pattern=args.pattern)
+
+    # Run tests
+    verbosity = 2 if args.verbose else 1
+    runner = unittest.TextTestRunner(verbosity=verbosity)
+    result = runner.run(suite)
+
+    # Cleanup to reduce resource warnings
+    try:
+        # Close any remaining event loops
+        loop = None
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+
+        if loop and not loop.is_closed():
+            # Cancel all pending tasks
+            pending = asyncio.all_tasks(loop)
+            for task in pending:
+                task.cancel()
+
+            # Give tasks a chance to complete cancellation
+            if pending:
+                loop.run_until_complete(
+                    asyncio.gather(*pending, return_exceptions=True)
+                )
+
+        # Force garbage collection
+        gc.collect()
+
+    except Exception:
+        # Don't let cleanup errors affect test results
+        pass
+
+    # Exit with proper code
+    sys.exit(0 if result.wasSuccessful() else 1)
+
+
+if __name__ == "__main__":
+    main()

tests/test_agent.py

@@ -1,18 +1,19 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 import threading
 from datetime import date
 
-from vectara_agentic.agent import _get_prompt, Agent, AgentType
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_core.factory import format_prompt
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider, ObserverType
 from vectara_agentic.tools import ToolsFactory
 
-from vectara_agentic._prompts import GENERAL_INSTRUCTIONS
-
-
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
+from vectara_agentic.agent_core.prompts import GENERAL_INSTRUCTIONS
+from conftest import mult, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
 
 
 ARIZE_LOCK = threading.Lock()
@@ -28,19 +29,17 @@ class TestAgentPackage(unittest.TestCase):
             + " with Always do as your mother tells you!"
         )
         self.assertEqual(
-            _get_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)]
-        topic = "AI"
-        custom_instructions = "Always do as your mother tells you!"
-        agent = Agent(tools, topic, custom_instructions)
-        self.assertEqual(agent.agent_type, AgentType.OPENAI)
-        self.assertEqual(agent._topic, topic)
-        self.assertEqual(agent._custom_instructions, custom_instructions)
+        agent = Agent(tools, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS)
+        self.assertEqual(agent.agent_type, AgentType.FUNCTION_CALLING)
+        self.assertEqual(agent._topic, STANDARD_TEST_TOPIC)
+        self.assertEqual(agent._custom_instructions, STANDARD_TEST_INSTRUCTIONS)
 
-        # To run this test, you must have OPENAI_API_KEY in your environment
+        # To run this test, you must have appropriate API key in your environment
         self.assertEqual(
             agent.chat(
                 "What is 5 times 10. Only give the answer, nothing else"
@@ -51,8 +50,6 @@ class TestAgentPackage(unittest.TestCase):
     def test_agent_config(self):
         with ARIZE_LOCK:
             tools = [ToolsFactory().create_tool(mult)]
-            topic = "AI topic"
-            instructions = "Always do as your father tells you, if your mother agrees!"
             config = AgentConfig(
                 agent_type=AgentType.REACT,
                 main_llm_provider=ModelProvider.ANTHROPIC,
@@ -64,12 +61,12 @@ class TestAgentPackage(unittest.TestCase):
 
             agent = Agent(
                 tools=tools,
-                topic=topic,
-                custom_instructions=instructions,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
                 agent_config=config
             )
-            self.assertEqual(agent._topic, topic)
-            self.assertEqual(agent._custom_instructions, instructions)
+            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)
@@ -84,19 +81,20 @@ class TestAgentPackage(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,
-        )
+        with ARIZE_LOCK:
+            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")
+            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")
 
     def test_from_corpus(self):
         agent = Agent.from_corpus(
@@ -121,6 +119,10 @@ class TestAgentPackage(unittest.TestCase):
             chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
         )
 
+        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.")
         self.assertEqual(res.response, "1050")