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

tests/test_serialization.py

@@ -1,3 +1,7 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 import threading
 import os
@@ -10,8 +14,7 @@ from vectara_agentic.tools import ToolsFactory
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
 from sqlalchemy import create_engine
 
-def mult(x: float, y: float) -> float:
-    return x * y
+from conftest import mult, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
 
 
 ARIZE_LOCK = threading.Lock()
@@ -40,12 +43,10 @@ class TestAgentSerialization(unittest.TestCase):
             )
 
             tools = [ToolsFactory().create_tool(mult)] + ToolsFactory().standard_tools() + db_tools
-            topic = "AI topic"
-            instructions = "Always do as your father tells you, if your mother agrees!"
             agent = Agent(
                 tools=tools,
-                topic=topic,
-                custom_instructions=instructions,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
                 agent_config=config
             )
 

tests/test_session_memory.py

@@ -0,0 +1,252 @@
+# 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 Agent
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider
+from vectara_agentic.tools import ToolsFactory
+from llama_index.core.llms import ChatMessage, MessageRole
+from conftest import mult, add
+
+
+ARIZE_LOCK = threading.Lock()
+
+
+class TestSessionMemoryManagement(unittest.TestCase):
+    """Test session_id parameter and memory management functionality"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.tools = [ToolsFactory().create_tool(mult), ToolsFactory().create_tool(add)]
+        self.topic = "Mathematics"
+        self.custom_instructions = "You are a helpful math assistant."
+        self.config = AgentConfig(main_llm_provider=ModelProvider.ANTHROPIC)
+
+    def test_agent_init_with_session_id(self):
+        """Test Agent initialization with custom session_id"""
+        custom_session_id = "test-session-123"
+
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=custom_session_id,
+        )
+
+        # Verify the agent uses the provided session_id
+        self.assertEqual(agent.session_id, custom_session_id)
+
+        # Verify memory uses the same session_id
+        self.assertEqual(agent.memory.session_id, custom_session_id)
+
+    def test_agent_init_without_session_id(self):
+        """Test Agent initialization without session_id (auto-generation)"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+        )
+
+        # Verify auto-generated session_id follows expected pattern
+        expected_pattern = f"{self.topic}:{date.today().isoformat()}"
+        self.assertEqual(agent.session_id, expected_pattern)
+
+        # Verify memory uses the same session_id
+        self.assertEqual(agent.memory.session_id, expected_pattern)
+
+    def test_from_tools_with_session_id(self):
+        """Test Agent.from_tools() with custom session_id"""
+        custom_session_id = "from-tools-session-456"
+
+        agent = Agent.from_tools(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=custom_session_id,
+        )
+
+        # Verify the agent uses the provided session_id
+        self.assertEqual(agent.session_id, custom_session_id)
+        self.assertEqual(agent.memory.session_id, custom_session_id)
+
+    def test_from_tools_without_session_id(self):
+        """Test Agent.from_tools() without session_id (auto-generation)"""
+        agent = Agent.from_tools(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+        )
+
+        # Verify auto-generated session_id
+        expected_pattern = f"{self.topic}:{date.today().isoformat()}"
+        self.assertEqual(agent.session_id, expected_pattern)
+        self.assertEqual(agent.memory.session_id, expected_pattern)
+
+    def test_session_id_consistency_across_agents(self):
+        """Test that agents with same session_id have consistent session_id attributes"""
+        shared_session_id = "shared-session-id-test"
+
+        # Create two agents with the same session_id
+        agent1 = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=shared_session_id,
+        )
+
+        agent2 = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=shared_session_id,
+        )
+
+        # Verify both agents have the same session_id
+        self.assertEqual(agent1.session_id, shared_session_id)
+        self.assertEqual(agent2.session_id, shared_session_id)
+        self.assertEqual(agent1.session_id, agent2.session_id)
+
+        # Verify their memory instances also have the correct session_id
+        self.assertEqual(agent1.memory.session_id, shared_session_id)
+        self.assertEqual(agent2.memory.session_id, shared_session_id)
+
+        # Note: Each agent gets its own Memory instance (this is expected behavior)
+        # In production, memory persistence happens through serialization/deserialization
+
+    def test_memory_isolation_different_sessions(self):
+        """Test that agents with different session_ids have isolated memory"""
+        session_id_1 = "isolated-session-1"
+        session_id_2 = "isolated-session-2"
+
+        # Create two agents with different session_ids
+        agent1 = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=session_id_1,
+        )
+
+        agent2 = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=session_id_2,
+        )
+
+        # Add messages to agent1's memory
+        agent1_messages = [
+            ChatMessage(role=MessageRole.USER, content="Agent 1 question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Agent 1 response"),
+        ]
+        agent1.memory.put_messages(agent1_messages)
+
+        # Add different messages to agent2's memory
+        agent2_messages = [
+            ChatMessage(role=MessageRole.USER, content="Agent 2 question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Agent 2 response"),
+        ]
+        agent2.memory.put_messages(agent2_messages)
+
+        # Verify memory isolation
+        retrieved_agent1_messages = agent1.memory.get()
+        retrieved_agent2_messages = agent2.memory.get()
+
+        self.assertEqual(len(retrieved_agent1_messages), 2)
+        self.assertEqual(len(retrieved_agent2_messages), 2)
+
+        # Verify agent1 only has its own messages
+        self.assertEqual(retrieved_agent1_messages[0].content, "Agent 1 question")
+        self.assertEqual(retrieved_agent1_messages[1].content, "Agent 1 response")
+
+        # Verify agent2 only has its own messages
+        self.assertEqual(retrieved_agent2_messages[0].content, "Agent 2 question")
+        self.assertEqual(retrieved_agent2_messages[1].content, "Agent 2 response")
+
+    def test_serialization_preserves_session_id(self):
+        """Test that agent serialization preserves custom session_id"""
+        custom_session_id = "serialization-test-session"
+
+        # Create agent with custom session_id
+        original_agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=custom_session_id,
+        )
+
+        # Add some memory
+        test_messages = [
+            ChatMessage(role=MessageRole.USER, content="Test question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Test answer"),
+        ]
+        original_agent.memory.put_messages(test_messages)
+
+        # Serialize the agent
+        serialized_data = original_agent.dumps()
+
+        # Deserialize the agent
+        restored_agent = Agent.loads(serialized_data)
+
+        # Verify session_id is preserved
+        self.assertEqual(restored_agent.session_id, custom_session_id)
+        self.assertEqual(restored_agent.memory.session_id, custom_session_id)
+
+        # Verify memory is preserved
+        restored_messages = restored_agent.memory.get()
+        self.assertEqual(len(restored_messages), 2)
+        self.assertEqual(restored_messages[0].content, "Test question")
+        self.assertEqual(restored_messages[1].content, "Test answer")
+
+    def test_chat_history_initialization_with_session_id(self):
+        """Test Agent initialization with chat_history and custom session_id"""
+        custom_session_id = "chat-history-session"
+        chat_history = [
+            ("Hello", "Hi there!"),
+            ("How are you?", "I'm doing well, thank you!"),
+        ]
+
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.config,
+            session_id=custom_session_id,
+            chat_history=chat_history,
+        )
+
+        # Verify session_id is correct
+        self.assertEqual(agent.session_id, custom_session_id)
+        self.assertEqual(agent.memory.session_id, custom_session_id)
+
+        # Verify chat history was loaded into memory
+        messages = agent.memory.get()
+        self.assertEqual(len(messages), 4)  # 2 user + 2 assistant messages
+
+        # Verify message content and roles
+        self.assertEqual(messages[0].role, MessageRole.USER)
+        self.assertEqual(messages[0].content, "Hello")
+        self.assertEqual(messages[1].role, MessageRole.ASSISTANT)
+        self.assertEqual(messages[1].content, "Hi there!")
+        self.assertEqual(messages[2].role, MessageRole.USER)
+        self.assertEqual(messages[2].content, "How are you?")
+        self.assertEqual(messages[3].role, MessageRole.ASSISTANT)
+        self.assertEqual(messages[3].content, "I'm doing well, thank you!")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_streaming.py

@@ -0,0 +1,109 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+
+warnings.simplefilter("ignore", DeprecationWarning)
+
+import unittest
+import asyncio
+
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import ToolsFactory
+
+import nest_asyncio
+
+nest_asyncio.apply()
+
+from conftest import (
+    fc_config_openai,
+    fc_config_anthropic,
+    mult,
+    STANDARD_TEST_TOPIC,
+    STANDARD_TEST_INSTRUCTIONS,
+)
+
+
+class TestAgentStreaming(unittest.IsolatedAsyncioTestCase):
+
+    async def test_anthropic(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        agent = Agent(
+            agent_config=fc_config_anthropic,
+            tools=tools,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+        )
+
+        # 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 multiplications. Only give the answer, nothing else."
+        )
+        # Consume the stream
+        async for chunk in stream3.async_response_gen():
+            pass
+        response3 = await stream3.aget_response()
+
+        self.assertIn("1050", response3.response)
+
+    async def test_openai(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        agent = Agent(
+            agent_config=fc_config_openai,
+            tools=tools,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+        )
+
+        # 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 multiplications. Only give the answer, nothing else."
+        )
+        # Consume the stream
+        async for chunk in stream3.async_response_gen():
+            pass
+        response3 = await stream3.aget_response()
+
+        self.assertIn("1050", response3.response)
+
+    def test_openai_sync(self):
+        """Synchronous wrapper for the async test"""
+        asyncio.run(self.test_openai())
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_together.py

@@ -0,0 +1,62 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
+import unittest
+import threading
+
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import ToolsFactory
+
+import nest_asyncio
+nest_asyncio.apply()
+
+from conftest import fc_config_together, mult, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
+
+
+ARIZE_LOCK = threading.Lock()
+
+class TestTogether(unittest.IsolatedAsyncioTestCase):
+
+    async def test_multiturn(self):
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            agent = Agent(
+                agent_config=fc_config_together,
+                tools=tools,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
+            )
+
+            # 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__":
+    unittest.main()

tests/test_tools.py

@@ -1,3 +1,8 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 from pydantic import Field, BaseModel
 from unittest.mock import patch, MagicMock
@@ -13,7 +18,6 @@ from vectara_agentic.tools import (
 )
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.types import AgentType, ModelProvider
 
 from llama_index.core.tools import FunctionTool
 
@@ -96,7 +100,6 @@ class TestToolsPackage(unittest.TestCase):
                 examples=["AAPL", "GOOG"],
             )
             year: Optional[int | str] = Field(
-                default=None,
                 description="The year this query relates to. An integer between 2015 and 2024 or a string specifying a condition on the year",
                 examples=[
                     2020,
@@ -154,8 +157,7 @@ class TestToolsPackage(unittest.TestCase):
                 description="The ticker symbol for the company",
                 examples=["AAPL", "GOOG"],
             )
-            year: int | str = Field(
-                default=None,
+            year: Optional[int | str] = Field(
                 description="The year this query relates to. An integer between 2015 and 2024 or a string specifying a condition on the year",
                 examples=[
                     2020,
@@ -235,80 +237,6 @@ class TestToolsPackage(unittest.TestCase):
             self.assertIsInstance(tool, FunctionTool)
             self.assertEqual(tool.metadata.tool_type, ToolType.QUERY)
 
-    def test_tool_with_many_arguments(self):
-        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,
-        )
-
-        # Test with 15 arguments to make sure no issues occur
-        config = AgentConfig(agent_type=AgentType.OPENAI)
-        agent = Agent(
-            tools=[query_tool_1],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments for OPENAI",
-            agent_config=config,
-        )
-        res = agent.chat("What is the stock price for Yahoo on 12/31/22?")
-        self.assertNotIn("maximum length of 1024 characters", str(res))
-
-        # Same test but with GROQ, should not have this limit
-        config = AgentConfig(
-            agent_type=AgentType.FUNCTION_CALLING,
-            main_llm_provider=ModelProvider.GROQ,
-            tool_llm_provider=ModelProvider.GROQ,
-        )
-        agent = Agent(
-            tools=[query_tool_1],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments for GROQ",
-            agent_config=config,
-        )
-        res = agent.chat("What is the stock price?")
-        self.assertNotIn("maximum length of 1024 characters", str(res))
-
-        # Same test but with ANTHROPIC, should not have this limit
-        config = AgentConfig(
-            agent_type=AgentType.FUNCTION_CALLING,
-            main_llm_provider=ModelProvider.ANTHROPIC,
-            tool_llm_provider=ModelProvider.ANTHROPIC,
-        )
-        agent = Agent(
-            tools=[query_tool_1],
-            topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
-            agent_config=config,
-        )
-        res = agent.chat("What is the stock price?")
-        self.assertIn("stock price", str(res))
-
     @patch.object(VectaraIndex, "as_query_engine")
     def test_vectara_tool_args_type(
         self,
@@ -384,7 +312,7 @@ class TestToolsPackage(unittest.TestCase):
             def __init__(self):
                 pass
 
-            def mult(self, x, y):
+            def mult(self, x: float, y: float) -> float:
                 return x * y
 
         test_class = TestClass()
@@ -410,7 +338,7 @@ class TestToolsPackage(unittest.TestCase):
         class DummyArgs(BaseModel):
             foo: int = Field(..., description="how many foos", examples=[1, 2, 3])
             bar: str = Field(
-                "baz",
+                default="baz",
                 description="what bar to use",
                 examples=["x", "y"],
             )
@@ -425,7 +353,7 @@ class TestToolsPackage(unittest.TestCase):
         doc = dummy_tool.metadata.description
         self.assertTrue(
             doc.startswith(
-                "dummy_tool(query: str, foo: int, bar: str) -> dict[str, Any]"
+                "dummy_tool(query: str, foo: int, bar: str | None) -> dict[str, Any]"
             )
         )
         self.assertIn("Args:", doc)
@@ -433,7 +361,7 @@ class TestToolsPackage(unittest.TestCase):
             "query (str): The search query to perform, in the form of a question", doc
         )
         self.assertIn("foo (int): how many foos (e.g., 1, 2, 3)", doc)
-        self.assertIn("bar (str, default='baz'): what bar to use (e.g., 'x', 'y')", doc)
+        self.assertIn("bar (str | None, default='baz'): what bar to use (e.g., 'x', 'y')", doc)
         self.assertIn("Returns:", doc)
         self.assertIn("dict[str, Any]: A dictionary containing the result data.", doc)
 

tests/test_vectara_llms.py

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

tests/test_vhc.py

@@ -0,0 +1,67 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
+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()
+
+statements = [
+    "The sky is blue.",
+    "Cats are better than dogs.",
+    "Python is a great programming language.",
+    "The Earth revolves around the Sun.",
+    "Chocolate is the best ice cream flavor.",
+]
+st_inx = 0
+def get_statement() -> str:
+    "Generate next statement"
+    global st_inx
+    st = statements[st_inx]
+    st_inx += 1
+    return st
+
+
+fc_config = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.OPENAI,
+    tool_llm_provider=ModelProvider.OPENAI,
+)
+
+vectara_api_key = 'zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA'
+
+class TestVHC(unittest.TestCase):
+
+    def test_vhc(self):
+        tools = [ToolsFactory().create_tool(get_statement)]
+        topic = "statements"
+        instructions = (
+            f"Call the get_statement tool multiple times to get all {len(statements)} statements."
+            f"Respond to the user question based exclusively on the statements you receive - do not use any other knowledge or information."
+        )
+
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            agent_config=fc_config,
+            custom_instructions=instructions,
+            vectara_api_key=vectara_api_key,
+        )
+
+        _ = agent.chat("Are large cats better than small dogs?")
+        vhc_res = agent.compute_vhc()
+        vhc_corrections = vhc_res.get("corrections", [])
+        self.assertTrue(
+            len(vhc_corrections) >= 0 and len(vhc_corrections) <= 2,
+            "Corrections should be between 0 and 2"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()