vectara-agentic 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

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,66 @@
+# 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,
+        )
+
+        res = agent.chat("Are large cats better than small dogs?")
+        vhc_corrections = res.metadata.get("corrections", None)
+        self.assertTrue(
+            len(vhc_corrections) >= 0 and len(vhc_corrections) <= 2,
+            "Corrections should be between 0 and 2"
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_workflow.py

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

vectara_agentic/__init__.py

@@ -2,25 +2,48 @@
 vectara_agentic package.
 """
 
+# Simple global warning suppression for end users
+import warnings
+
+warnings.simplefilter("ignore", DeprecationWarning)
+
+# pylint: disable=wrong-import-position
 from .agent import Agent
 from .tools import VectaraToolFactory, VectaraTool, ToolsFactory
 from .tools_catalog import ToolsCatalog
 from .agent_config import AgentConfig
 from .agent_endpoint import create_app, start_app
 from .types import (
-    AgentType, ObserverType, ModelProvider, AgentStatusType, LLMRole, ToolType
+    AgentType,
+    ObserverType,
+    ModelProvider,
+    AgentStatusType,
+    LLMRole,
+    ToolType,
 )
 
 # Define the __all__ variable for wildcard imports
 __all__ = [
-    'Agent', 'VectaraToolFactory', 'VectaraTool', 'ToolsFactory', 'AgentConfig',
-    'create_app', 'start_app', 'ToolsCatalog',
-    'AgentType', 'ObserverType', 'ModelProvider', 'AgentStatusType', 'LLMRole', 'ToolType'
+    "Agent",
+    "VectaraToolFactory",
+    "VectaraTool",
+    "ToolsFactory",
+    "AgentConfig",
+    "create_app",
+    "start_app",
+    "ToolsCatalog",
+    "AgentType",
+    "ObserverType",
+    "ModelProvider",
+    "AgentStatusType",
+    "LLMRole",
+    "ToolType",
 ]
 
 # Ensure package version is available
 try:
     import importlib.metadata
+
     __version__ = importlib.metadata.version("vectara_agentic")
 except Exception:
     __version__ = "0.0.0"  # fallback if not installed

vectara_agentic/_callback.py

@@ -3,14 +3,17 @@ Module to handle agent callbacks
 """
 
 import inspect
+import logging
 from typing import Any, Dict, Optional, List, Callable
 from functools import wraps
+import traceback
 
 from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.core.callbacks.schema import CBEventType, EventPayload
 
 from .types import AgentStatusType
 
+
 def wrap_callback_fn(callback):
     """
     Wrap a callback function to ensure it only receives the parameters it can accept.
@@ -34,6 +37,7 @@ def wrap_callback_fn(callback):
 
     return new_callback
 
+
 class AgentCallbackHandler(BaseCallbackHandler):
     """
     Callback handler to track agent status
@@ -153,10 +157,8 @@ class AgentCallbackHandler(BaseCallbackHandler):
             self._handle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
             self._handle_agent_step(payload, event_id)
-        elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception event in handle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
-            print(f"Unknown event type: {event_type}, payload={payload}")
+            pass
 
     async def _ahandle_event(
         self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
@@ -167,10 +169,8 @@ class AgentCallbackHandler(BaseCallbackHandler):
             await self._ahandle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
             await self._ahandle_agent_step(payload, event_id)
-        elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception event in ahandle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
-            print(f"Unknown event type: {event_type}, payload={payload}")
+            pass
 
     # Synchronous handlers
     def _handle_llm(
@@ -196,37 +196,38 @@ class AgentCallbackHandler(BaseCallbackHandler):
                     event_id=event_id,
                 )
         else:
-            print(
-                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
-            )
+            pass
 
     def _handle_function_call(self, payload: dict, event_id: str) -> None:
-        if EventPayload.FUNCTION_CALL in payload:
-            fcall = payload.get(EventPayload.FUNCTION_CALL)
-            tool = payload.get(EventPayload.TOOL)
-            if tool:
-                tool_name = tool.name
-                if self.fn:
+        try:
+            if EventPayload.FUNCTION_CALL in payload:
+                fcall = payload.get(EventPayload.FUNCTION_CALL)
+                tool = payload.get(EventPayload.TOOL)
+
+                if tool:
+                    tool_name = tool.name
+                    if self.fn:
+                        self.fn(
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg={"tool_name": tool_name, "arguments": fcall},
+                            event_id=event_id,
+                        )
+
+            elif EventPayload.FUNCTION_OUTPUT in payload:
+                response = payload.get(EventPayload.FUNCTION_OUTPUT)
+                tool = payload.get(EventPayload.TOOL)
+
+                if tool and self.fn:
                     self.fn(
-                        status_type=AgentStatusType.TOOL_CALL,
-                        msg={
-                            "tool_name": tool_name,
-                            "arguments": fcall
-                        },
+                        status_type=AgentStatusType.TOOL_OUTPUT,
+                        msg={"tool_name": tool.name, "content": response},
                         event_id=event_id,
                     )
-        elif EventPayload.FUNCTION_OUTPUT in payload:
-            response = payload.get(EventPayload.FUNCTION_OUTPUT)
-            if self.fn:
-                self.fn(
-                    status_type=AgentStatusType.TOOL_OUTPUT,
-                    msg=response,
-                    event_id=event_id,
-                )
-        else:
-            print(
-                f"Vectara-agentic callback handler: no function call or output found in payload {payload}"
-            )
+
+        except Exception as e:
+            logging.error(f"Exception in _handle_function_call: {e}")
+            logging.error(f"Traceback: {traceback.format_exc()}")
+            # Continue execution to prevent callback failures from breaking the agent
 
     def _handle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
@@ -245,10 +246,6 @@ class AgentCallbackHandler(BaseCallbackHandler):
                     msg=response,
                     event_id=event_id,
                 )
-        else:
-            print(
-                f"Vectara-agentic agent_step: no messages or prompt found in payload {payload}"
-            )
 
     # Asynchronous handlers
     async def _ahandle_llm(self, payload: dict, event_id: str) -> None:
@@ -276,52 +273,55 @@ class AgentCallbackHandler(BaseCallbackHandler):
                     msg=prompt,
                     event_id=event_id,
                 )
-        else:
-            print(
-                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
-            )
 
     async def _ahandle_function_call(self, payload: dict, event_id: str) -> None:
-        if EventPayload.FUNCTION_CALL in payload:
-            fcall = payload.get(EventPayload.FUNCTION_CALL)
-            tool = payload.get(EventPayload.TOOL)
-            if tool:
-                if self.fn:
+        try:
+            if EventPayload.FUNCTION_CALL in payload:
+                fcall = payload.get(EventPayload.FUNCTION_CALL)
+                tool = payload.get(EventPayload.TOOL)
+
+                if tool and self.fn:
                     if inspect.iscoroutinefunction(self.fn):
                         await self.fn(
                             status_type=AgentStatusType.TOOL_CALL,
+                            msg={"tool_name": tool.name, "arguments": fcall},
+                            event_id=event_id,
+                        )
+                    else:
+                        self.fn(
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg={"tool_name": tool.name, "arguments": fcall},
+                            event_id=event_id,
+                        )
+
+            elif EventPayload.FUNCTION_OUTPUT in payload:
+                response = payload.get(EventPayload.FUNCTION_OUTPUT)
+                tool = payload.get(EventPayload.TOOL)
+
+                if tool and self.fn:
+                    if inspect.iscoroutinefunction(self.fn):
+                        await self.fn(
+                            status_type=AgentStatusType.TOOL_OUTPUT,
                             msg={
                                 "tool_name": tool.name,
-                                "arguments": fcall
+                                "content": response,
                             },
                             event_id=event_id,
                         )
                     else:
                         self.fn(
-                            status_type=AgentStatusType.TOOL_CALL,
+                            status_type=AgentStatusType.TOOL_OUTPUT,
                             msg={
                                 "tool_name": tool.name,
-                                "arguments": fcall
+                                "content": response,
                             },
                             event_id=event_id,
                         )
-        elif EventPayload.FUNCTION_OUTPUT in payload:
-            if self.fn:
-                response = payload.get(EventPayload.FUNCTION_OUTPUT)
-                if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(
-                        status_type=AgentStatusType.TOOL_OUTPUT,
-                        msg=response,
-                        event_id=event_id,
-                    )
-                else:
-                    self.fn(
-                        status_type=AgentStatusType.TOOL_OUTPUT,
-                        msg=response,
-                        event_id=event_id,
-                    )
-        else:
-            print(f"No function call or output found in payload {payload}")
+
+        except Exception as e:
+            logging.error(f"Exception in _ahandle_function_call: {e}")
+            logging.error(f"Traceback: {traceback.format_exc()}")
+            # Continue execution to prevent callback failures from breaking the agent
 
     async def _ahandle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
@@ -354,5 +354,3 @@ class AgentCallbackHandler(BaseCallbackHandler):
                         msg=response,
                         event_id=event_id,
                     )
-        else:
-            print(f"No messages or prompt found in payload {payload}")

vectara_agentic/_observability.py

@@ -1,6 +1,7 @@
 """
 Observability for Vectara Agentic.
 """
+
 import os
 import json
 from typing import Optional, Union
@@ -13,9 +14,9 @@ SPAN_NAME: str = "VectaraQueryEngine._query"
 
 
 def setup_observer(config: AgentConfig, verbose: bool) -> bool:
-    '''
+    """
     Setup the observer.
-    '''
+    """
     if config.observer != ObserverType.ARIZE_PHOENIX:
         if verbose:
             print("No Phoenix observer set.")
@@ -38,9 +39,11 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     if not phoenix_endpoint:
         print("Phoenix endpoint not set. Attempting to launch local Phoenix UI...")
         px.launch_app()
-        print("Local Phoenix UI launched. You can view traces at the UI address (usually http://localhost:6006).")
+        print(
+            "Local Phoenix UI launched. You can view traces at the UI address (usually http://localhost:6006)."
+        )
 
-    if phoenix_endpoint and 'app.phoenix.arize.com' in phoenix_endpoint:
+    if phoenix_endpoint and "app.phoenix.arize.com" in phoenix_endpoint:
         phoenix_api_key = os.getenv("PHOENIX_API_KEY")
         if not phoenix_api_key:
             raise ValueError(
@@ -50,7 +53,7 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
         os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"
 
     reg_kwargs = {
-        "endpoint": phoenix_endpoint or 'http://localhost:6006/v1/traces',
+        "endpoint": phoenix_endpoint or "http://localhost:6006/v1/traces",
         "project_name": PROJECT_NAME,
         "batch": False,
         "set_global_tracer_provider": False,
@@ -58,35 +61,35 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     tracer_provider = register(**reg_kwargs)
     LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
     if verbose:
-        print(f"Phoenix observer configured for project 'vectara-agentic' at endpoint: {reg_kwargs['endpoint']}")
+        print(
+            f"Phoenix observer configured for project 'vectara-agentic' at endpoint: {reg_kwargs['endpoint']}"
+        )
     return True
 
 
 def _extract_fcs_value(output: Union[str, dict]) -> Optional[float]:
-    '''
+    """
     Extract the FCS value from the output.
-    '''
+    """
     try:
         output_json = json.loads(output)
-        if 'metadata' in output_json and 'fcs' in output_json['metadata']:
-            return output_json['metadata']['fcs']
-    except json.JSONDecodeError:
-        print(f"Failed to parse JSON: {output}")
-    except KeyError:
-        print(f"'fcs' not found in: {output_json}")
+        if "metadata" in output_json and "fcs" in output_json["metadata"]:
+            return output_json["metadata"]["fcs"]
+    except Exception as e:
+        print(f"Error extracting FCS value: {e}")
     return None
 
 
 def _find_top_level_parent_id(row: pd.Series, all_spans: pd.DataFrame) -> Optional[str]:
-    '''
+    """
     Find the top level parent id for the given span.
-    '''
-    current_id = row['parent_id']
+    """
+    current_id = row["parent_id"]
     while current_id is not None:
         parent_row = all_spans[all_spans.index == current_id]
         if parent_row.empty:
             break
-        new_parent_id = parent_row['parent_id'].iloc[0]
+        new_parent_id = parent_row["parent_id"].iloc[0]
         if new_parent_id == current_id:
             break
         if new_parent_id is None:
@@ -96,17 +99,14 @@ def _find_top_level_parent_id(row: pd.Series, all_spans: pd.DataFrame) -> Option
 
 
 def eval_fcs() -> None:
-    '''
+    """
     Evaluate the FCS score for the VectaraQueryEngine._query span.
-    '''
+    """
     import phoenix as px
     from phoenix.trace.dsl import SpanQuery
     from phoenix.trace import SpanEvaluations
-    query = SpanQuery().select(
-        "output.value",
-        "parent_id",
-        "name"
-    )
+
+    query = SpanQuery().select("output.value", "parent_id", "name")
     try:
         client = px.Client()
         all_spans = client.query_spans(query, project_name=PROJECT_NAME)
@@ -114,17 +114,17 @@ def eval_fcs() -> None:
         print(f"Failed to query spans: {e}")
         return
 
-    vectara_spans = all_spans[all_spans['name'] == SPAN_NAME].copy()
-    vectara_spans['top_level_parent_id'] = vectara_spans.apply(
+    vectara_spans = all_spans[all_spans["name"] == SPAN_NAME].copy()
+    vectara_spans["top_level_parent_id"] = vectara_spans.apply(
         lambda row: _find_top_level_parent_id(row, all_spans), axis=1
     )
-    vectara_spans['score'] = vectara_spans['output.value'].apply(_extract_fcs_value)
+    vectara_spans["score"] = vectara_spans["output.value"].apply(_extract_fcs_value)
 
     vectara_spans.reset_index(inplace=True)
     top_level_spans = vectara_spans.copy()
-    top_level_spans['context.span_id'] = top_level_spans['top_level_parent_id']
+    top_level_spans["context.span_id"] = top_level_spans["top_level_parent_id"]
     vectara_spans = pd.concat([vectara_spans, top_level_spans], ignore_index=True)
-    vectara_spans.set_index('context.span_id', inplace=True)
+    vectara_spans.set_index("context.span_id", inplace=True)
 
     px.Client().log_evaluations(
         SpanEvaluations(

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.3.2"
+__version__ = "0.4.0"