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

tests/test_workflow.py

@@ -1,32 +1,23 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+warnings.simplefilter("ignore", DeprecationWarning)
+
 import unittest
 
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.tools import ToolsFactory
 from vectara_agentic.sub_query_workflow import SubQuestionQueryWorkflow, SequentialSubQuestionsWorkflow
-
-def mult(x: float, y: float):
-    """
-    Multiply two numbers.
-    """
-    return x * y
-
-def add(x: float, y: float):
-    """
-    Add two numbers.
-    """
-    return x + y
+from conftest import mult, add, STANDARD_TEST_TOPIC, WORKFLOW_TEST_INSTRUCTIONS
 
 class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
 
     async def test_sub_query_workflow(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
-        topic = "AI topic"
-        instructions = "You are a helpful AI assistant."
         agent = Agent(
             tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
             agent_config = AgentConfig(),
             workflow_cls = SubQuestionQueryWorkflow,
         )
@@ -46,12 +37,10 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
 
     async def test_seq_sub_query_workflow(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
-        topic = "AI topic"
-        instructions = "You are a helpful AI assistant."
         agent = Agent(
             tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
             agent_config = AgentConfig(),
             workflow_cls = SequentialSubQuestionsWorkflow,
         )
@@ -66,12 +55,10 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
 
     async def test_workflow_failure_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
-        topic = "AI topic"
-        instructions = "You are a helpful AI assistant."
         agent = Agent(
             tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
             agent_config = AgentConfig(),
             workflow_cls = SubQuestionQueryWorkflow,
             workflow_timeout = 1
@@ -85,12 +72,10 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
 
     async def test_workflow_failure_seq_sub_question(self):
         tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
-        topic = "AI topic"
-        instructions = "You are a helpful AI assistant."
         agent = Agent(
             tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
+            topic=STANDARD_TEST_TOPIC,
+            custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
             agent_config = AgentConfig(),
             workflow_cls = SequentialSubQuestionsWorkflow,
             workflow_timeout = 1

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.3"
+__version__ = "0.4.1"