vectara-agentic 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

tests/test_agent.py

@@ -106,43 +106,6 @@ class TestAgentPackage(unittest.TestCase):
         self.assertIsInstance(agent, Agent)
         self.assertEqual(agent._topic, "question answering")
 
-    def test_serialization(self):
-        with ARIZE_LOCK:
-            config = AgentConfig(
-                agent_type=AgentType.REACT,
-                main_llm_provider=ModelProvider.ANTHROPIC,
-                tool_llm_provider=ModelProvider.TOGETHER,
-                observer=ObserverType.ARIZE_PHOENIX
-            )
-
-            agent = Agent.from_corpus(
-                tool_name="RAG Tool",
-                agent_config=config,
-                vectara_corpus_key="corpus_key",
-                vectara_api_key="api_key",
-                data_description="information",
-                assistant_specialty="question answering",
-            )
-
-            agent_reloaded = agent.loads(agent.dumps())
-            agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
-
-            self.assertIsInstance(agent_reloaded, Agent)
-            self.assertEqual(agent, agent_reloaded)
-            self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
-
-            self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
-            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
-            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
-
-            self.assertIsInstance(agent_reloaded, Agent)
-            self.assertEqual(agent, agent_reloaded_again)
-            self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
-
-            self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
-            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
-            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
-
     def test_chat_history(self):
         tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"

tests/test_serialization.py

@@ -0,0 +1,110 @@
+import unittest
+import threading
+import os
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, ObserverType
+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
+
+
+ARIZE_LOCK = threading.Lock()
+
+class TestAgentSerialization(unittest.TestCase):
+
+    @classmethod
+    def tearDown(cls):
+        try:
+            os.remove('ev_database.db')
+        except FileNotFoundError:
+            pass
+
+    def test_serialization(self):
+        with ARIZE_LOCK:
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                tool_llm_provider=ModelProvider.TOGETHER,
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+            db_tools = ToolsFactory().database_tools(
+                tool_name_prefix = "ev",
+                content_description = 'Electric Vehicles in the state of Washington and other population information',
+                sql_database = SQLDatabase(create_engine('sqlite:///ev_database.db')),
+            )
+
+            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,
+                agent_config=config
+            )
+
+            agent_reloaded = agent.loads(agent.dumps())
+            agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded)
+            self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded_again)
+            self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
+
+    def test_serialization_from_corpus(self):
+        with ARIZE_LOCK:
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                tool_llm_provider=ModelProvider.TOGETHER,
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+
+            agent = Agent.from_corpus(
+                tool_name="RAG Tool",
+                agent_config=config,
+                vectara_corpus_key="corpus_key",
+                vectara_api_key="api_key",
+                data_description="information",
+                assistant_specialty="question answering",
+            )
+
+            agent_reloaded = agent.loads(agent.dumps())
+            agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded)
+            self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded_again)
+            self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic/_callback.py

@@ -4,12 +4,35 @@ Module to handle agent callbacks
 
 import inspect
 from typing import Any, Dict, Optional, List, Callable
+from functools import wraps
 
 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.
+    This is useful for ensuring that the callback function does not receive unexpected
+    parameters, especially when the callback is called from different contexts.
+    """
+    if callback is None:
+        return None
+    try:
+        sig = inspect.signature(callback)
+        allowed_params = set(sig.parameters.keys())
+    except Exception:
+        # If we cannot determine the signature, return the callback as is.
+        return callback
+
+    @wraps(callback)
+    def new_callback(*args, **kwargs):
+        # Filter kwargs to only those that the original callback accepts.
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k in allowed_params}
+        return callback(*args, **filtered_kwargs)
+
+    return new_callback
 
 class AgentCallbackHandler(BaseCallbackHandler):
     """
@@ -24,7 +47,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
 
     def __init__(self, fn: Optional[Callable] = None) -> None:
         super().__init__(event_starts_to_ignore=[], event_ends_to_ignore=[])
-        self.fn = fn
+        self.fn = wrap_callback_fn(fn)
 
     # Existing synchronous methods
     def on_event_start(
@@ -37,9 +60,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
     ) -> str:
         if self.fn is not None and payload is not None:
             if inspect.iscoroutinefunction(self.fn):
-                raise ValueError("Synchronous callback handler cannot use async callback function")
+                raise ValueError(
+                    "Synchronous callback handler cannot use async callback function"
+                )
             # Handle events as before
-            self._handle_event(event_type, payload)
+            self._handle_event(event_type, payload, event_id)
         return event_id
 
     def start_trace(self, trace_id: Optional[str] = None) -> None:
@@ -73,9 +98,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
         """
         if self.fn is not None and payload is not None:
             if inspect.iscoroutinefunction(self.fn):
-                raise ValueError("Synchronous callback handler cannot use async callback function")
+                raise ValueError(
+                    "Synchronous callback handler cannot use async callback function"
+                )
             # Handle events as before
-            self._handle_event(event_type, payload)
+            self._handle_event(event_type, payload, event_id)
 
     # New asynchronous methods
     async def aon_event_start(
@@ -100,7 +127,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
             event_id: the event ID
         """
         if self.fn is not None and payload is not None:
-            await self._ahandle_event(event_type, payload)
+            await self._ahandle_event(event_type, payload, event_id)
         return event_id
 
     async def aon_event_end(
@@ -114,48 +141,66 @@ class AgentCallbackHandler(BaseCallbackHandler):
         Handle the end of an event (async)
         """
         if self.fn is not None and payload is not None:
-            await self._ahandle_event(event_type, payload)
+            await self._ahandle_event(event_type, payload, event_id)
 
     # Helper methods for handling events
-    def _handle_event(self, event_type: CBEventType, payload: Dict[str, Any]) -> None:
+    def _handle_event(
+        self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
+    ) -> None:
         if event_type == CBEventType.LLM:
-            self._handle_llm(payload)
+            self._handle_llm(payload, event_id)
         elif event_type == CBEventType.FUNCTION_CALL:
-            self._handle_function_call(payload)
+            self._handle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
-            self._handle_agent_step(payload)
+            self._handle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
             print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
-    async def _ahandle_event(self, event_type: CBEventType, payload: Dict[str, Any]) -> None:
+    async def _ahandle_event(
+        self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
+    ) -> None:
         if event_type == CBEventType.LLM:
-            await self._ahandle_llm(payload)
+            await self._ahandle_llm(payload, event_id)
         elif event_type == CBEventType.FUNCTION_CALL:
-            await self._ahandle_function_call(payload)
+            await self._ahandle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
-            await self._ahandle_agent_step(payload)
+            await self._ahandle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
             print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
     # Synchronous handlers
-    def _handle_llm(self, payload: dict) -> None:
+    def _handle_llm(
+        self,
+        payload: dict,
+        event_id: str,
+    ) -> None:
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
                 if self.fn:
-                    self.fn(AgentStatusType.AGENT_UPDATE, response)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_UPDATE,
+                        msg=response,
+                        event_id=event_id,
+                    )
         elif EventPayload.PROMPT in payload:
             prompt = str(payload.get(EventPayload.PROMPT))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_UPDATE, prompt)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_UPDATE,
+                    msg=prompt,
+                    event_id=event_id,
+                )
         else:
-            print(f"vectara-agentic llm callback: no messages or prompt found in payload {payload}")
+            print(
+                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
+            )
 
-    def _handle_function_call(self, payload: dict) -> None:
+    def _handle_function_call(self, payload: dict, event_id: str) -> None:
         if EventPayload.FUNCTION_CALL in payload:
             fcall = str(payload.get(EventPayload.FUNCTION_CALL))
             tool = payload.get(EventPayload.TOOL)
@@ -163,46 +208,77 @@ class AgentCallbackHandler(BaseCallbackHandler):
                 tool_name = tool.name
                 if self.fn:
                     self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
+                        status_type=AgentStatusType.TOOL_CALL,
+                        msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                        event_id=event_id,
                     )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
             if self.fn:
-                self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                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}")
+            print(
+                f"Vectara-agentic callback handler: no function call or output found in payload {payload}"
+            )
 
-    def _handle_agent_step(self, payload: dict) -> None:
+    def _handle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             msg = str(payload.get(EventPayload.MESSAGES))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_STEP, msg)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_STEP,
+                    msg=msg,
+                    event_id=event_id,
+                )
         elif EventPayload.RESPONSE in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_STEP, response)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_STEP,
+                    msg=response,
+                    event_id=event_id,
+                )
         else:
-            print(f"Vectara-agentic agent_step: no messages or prompt found in payload {payload}")
+            print(
+                f"Vectara-agentic agent_step: no messages or prompt found in payload {payload}"
+            )
 
     # Asynchronous handlers
-    async def _ahandle_llm(self, payload: dict) -> None:
+    async def _ahandle_llm(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
                 if self.fn:
                     if inspect.iscoroutinefunction(self.fn):
-                        await self.fn(AgentStatusType.AGENT_UPDATE, response)
+                        await self.fn(
+                            status_type=AgentStatusType.AGENT_UPDATE,
+                            msg=response,
+                            event_id=event_id,
+                        )
                     else:
-                        self.fn(AgentStatusType.AGENT_UPDATE, response)
+                        self.fn(
+                            status_type=AgentStatusType.AGENT_UPDATE,
+                            msg=response,
+                            event_id=event_id,
+                        )
         elif EventPayload.PROMPT in payload:
             prompt = str(payload.get(EventPayload.PROMPT))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_UPDATE, prompt)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_UPDATE,
+                    msg=prompt,
+                    event_id=event_id,
+                )
         else:
-            print(f"vectara-agentic llm callback: no messages or prompt found in payload {payload}")
+            print(
+                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
+            )
 
-    async def _ahandle_function_call(self, payload: dict) -> None:
+    async def _ahandle_function_call(self, payload: dict, event_id: str) -> None:
         if EventPayload.FUNCTION_CALL in payload:
             fcall = str(payload.get(EventPayload.FUNCTION_CALL))
             tool = payload.get(EventPayload.TOOL)
@@ -211,38 +287,64 @@ class AgentCallbackHandler(BaseCallbackHandler):
                 if self.fn:
                     if inspect.iscoroutinefunction(self.fn):
                         await self.fn(
-                            AgentStatusType.TOOL_CALL,
-                            f"Executing '{tool_name}' with arguments: {fcall}",
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                            event_id=event_id,
                         )
                     else:
                         self.fn(
-                            AgentStatusType.TOOL_CALL,
-                            f"Executing '{tool_name}' with arguments: {fcall}",
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                            event_id=event_id,
                         )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             if self.fn:
                 response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    await self.fn(
+                        status_type=AgentStatusType.TOOL_OUTPUT,
+                        msg=response,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    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}")
 
-    async def _ahandle_agent_step(self, payload: dict) -> None:
+    async def _ahandle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             if self.fn:
                 msg = str(payload.get(EventPayload.MESSAGES))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_STEP, msg)
+                    await self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=msg,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.AGENT_STEP, msg)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=msg,
+                        event_id=event_id,
+                    )
         elif EventPayload.RESPONSE in payload:
             if self.fn:
                 response = str(payload.get(EventPayload.RESPONSE))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_STEP, response)
+                    await self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=response,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.AGENT_STEP, response)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=response,
+                        event_id=event_id,
+                    )
         else:
             print(f"No messages or prompt found in payload {payload}")

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.7"
+__version__ = "0.2.9"

vectara_agentic/agent.py

@@ -33,7 +33,7 @@ from llama_index.core.agent.types import BaseAgent
 from llama_index.core.workflow import Workflow
 
 from .types import (
-    AgentType, AgentStatusType, LLMRole, ToolType,
+    AgentType, AgentStatusType, LLMRole, ToolType, ModelProvider,
     AgentResponse, AgentStreamingResponse, AgentConfigType
 )
 from .utils import get_llm, get_tokenizer_for_model
@@ -278,6 +278,10 @@ class Agent:
         llm.callback_manager = llm_callback_manager
 
         if agent_type == AgentType.FUNCTION_CALLING:
+            if config.tool_llm_provider == ModelProvider.OPENAI:
+                raise ValueError(
+                    "Vectara-agentic: Function calling agent type is not supported with the OpenAI LLM."
+                )
             prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = FunctionCallingAgent.from_tools(
                 tools=self.tools,
@@ -286,7 +290,7 @@ class Agent:
                 verbose=self.verbose,
                 max_function_calls=config.max_reasoning_steps,
                 callback_manager=llm_callback_manager,
-                system_prompt = prompt,
+                system_prompt=prompt,
                 allow_parallel_tool_calls=True,
             )
         elif agent_type == AgentType.REACT:
@@ -301,6 +305,10 @@ class Agent:
                 callable_manager=llm_callback_manager,
             )
         elif agent_type == AgentType.OPENAI:
+            if config.tool_llm_provider != ModelProvider.OPENAI:
+                raise ValueError(
+                    "Vectara-agentic: OPENAI agent type requires the OpenAI LLM."
+                )
             prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = OpenAIAgent.from_tools(
                 tools=self.tools,
@@ -768,6 +776,7 @@ class Agent:
         """
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
+        orig_llm = self.llm.metadata.model_name
         while attempt < max_attempts:
             try:
                 current_agent = self._get_current_agent()
@@ -788,16 +797,20 @@ class Agent:
                 agent_response.async_response_gen = _stream_response_wrapper  # Override the generator
                 return agent_response
 
-            except Exception:
+            except Exception as e:
+                last_error = e
                 if attempt >= 2:
                     if self.verbose:
-                        print("LLM call failed. Switching agent configuration.")
+                        print(f"LLM call failed on attempt {attempt}. Switching agent configuration.")
                     self._switch_agent_config()
                 time.sleep(1)
                 attempt += 1
 
         return AgentResponse(
-            response=f"LLM failure can't be resolved after {max_attempts} attempts."
+            response=(
+                f"For {orig_llm} LLM - failure can't be resolved after "
+                f"{max_attempts} attempts ({last_error})."
+            )
         )
 
     #
@@ -861,7 +874,6 @@ class Agent:
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the Agent instance to a dictionary."""
         tool_info = []
-
         for tool in self.tools:
             if hasattr(tool.metadata, "fn_schema"):
                 fn_schema_cls = tool.metadata.fn_schema

vectara_agentic/agent_config.py

@@ -71,6 +71,17 @@ class AgentConfig:
         default_factory=lambda: int(os.getenv("VECTARA_AGENTIC_MAX_REASONING_STEPS", "50"))
     )
 
+    def __post_init__(self):
+        # Use object.__setattr__ since the dataclass is frozen
+        if isinstance(self.agent_type, str):
+            object.__setattr__(self, "agent_type", AgentType(self.agent_type))
+        if isinstance(self.main_llm_provider, str):
+            object.__setattr__(self, "main_llm_provider", ModelProvider(self.main_llm_provider))
+        if isinstance(self.tool_llm_provider, str):
+            object.__setattr__(self, "tool_llm_provider", ModelProvider(self.tool_llm_provider))
+        if isinstance(self.observer, str):
+            object.__setattr__(self, "observer", ObserverType(self.observer))
+
     def to_dict(self) -> dict:
         """
         Convert the AgentConfig to a dictionary.

vectara_agentic/db_tools.py

@@ -1,38 +1,122 @@
 """
-This module contains the code to extend and improve DatabaseToolSpec
-Specifically adding load_sample_data and load_unique_values methods, as well as
-making sure the load_data method returns a list of text values from the database, not Document[] objects.
+This module contains the code adapted from DatabaseToolSpec
+It makes the following adjustments:
+* Adds load_sample_data and load_unique_values methods.
+* Fixes serialization.
+* Makes sure the load_data method returns a list of text values from the database (and not Document[] objects).
+* Limits the returned rows to self.max_rows.
 """
-from abc import ABC
-from typing import Callable, Any
+from typing import Any, Optional, List, Awaitable, Callable
+import asyncio
+from inspect import signature
 
-#
-# Additional database tool
-#
-class DBTool(ABC):
-    """
-    A base class for vectara-agentic database tools extensions
+from sqlalchemy import MetaData, text
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import NoSuchTableError
+from sqlalchemy.schema import CreateTable
+
+from llama_index.core.readers.base import BaseReader
+from llama_index.core.utilities.sql_wrapper import SQLDatabase
+from llama_index.core.schema import Document
+from llama_index.core.tools.function_tool import FunctionTool
+from llama_index.core.tools.types import ToolMetadata
+from llama_index.core.tools.utils import create_schema_from_function
+
+
+AsyncCallable = Callable[..., Awaitable[Any]]
+
+class DatabaseTools(BaseReader):
+    """Database tools for vectara-agentic
+    This class provides a set of tools to interact with a database.
+    It allows you to load data, list tables, describe tables, and load unique values.
+    It also provides a method to load sample data from a specified table.
     """
-    def __init__(self, load_data_fn: Callable, max_rows: int = 1000):
-        self.load_data_fn = load_data_fn
+    spec_functions = [
+        "load_data", "load_sample_data", "list_tables",
+        "describe_tables", "load_unique_values",
+    ]
+
+    def __init__(
+        self,
+        *args: Any,
+        max_rows: int = 1000,
+        sql_database: Optional[SQLDatabase] = None,
+        engine: Optional[Engine] = None,
+        uri: Optional[str] = None,
+        scheme: Optional[str] = None,
+        host: Optional[str] = None,
+        port: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        dbname: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
         self.max_rows = max_rows
 
-class DBLoadData(DBTool):
-    """
-    A tool to Run SQL query on the database and return the result.
-    """
-    def __call__(self, query: str) -> Any:
-        """Query and load data from the Database, returning a list of Documents.
+        if sql_database:
+            self.sql_database = sql_database
+        elif engine:
+            self.sql_database = SQLDatabase(engine, *args, **kwargs)
+        elif uri:
+            self.uri = uri
+            self.sql_database = SQLDatabase.from_uri(uri, *args, **kwargs)
+        elif (scheme and host and port and user and password and dbname):
+            uri = f"{scheme}://{user}:{password}@{host}:{port}/{dbname}"
+            self.uri = uri
+            self.sql_database = SQLDatabase.from_uri(uri, *args, **kwargs)
+        else:
+            raise ValueError(
+                "You must provide either a SQLDatabase, "
+                "a SQL Alchemy Engine, a valid connection URI, or a valid "
+                "set of credentials."
+            )
+        self._uri = getattr(self, "uri", None) or str(self.sql_database.engine.url)
+        self._metadata = MetaData()
+        self._metadata.reflect(bind=self.sql_database.engine)
+
+    def _get_metadata_from_fn_name(
+        self, fn_name: Callable,
+    ) -> Optional[ToolMetadata]:
+        """Return map from function name.
+
+        Return type is Optional, meaning that the schema can be None.
+        In this case, it's up to the downstream tool implementation to infer the schema.
+        """
+        try:
+            func = getattr(self, fn_name)
+        except AttributeError:
+            return None
+        name = fn_name
+        docstring = func.__doc__ or ""
+        description = f"{name}{signature(func)}\n{docstring}"
+        fn_schema = create_schema_from_function(fn_name, getattr(self, fn_name))
+        return ToolMetadata(name=name, description=description, fn_schema=fn_schema)
+
+    def _load_data(self, query: str) -> List[Document]:
+        documents = []
+        with self.sql_database.engine.connect() as connection:
+            if query is None:
+                raise ValueError("A query parameter is necessary to filter the data")
+            result = connection.execute(text(query))
+            for item in result.fetchall():
+                doc_str = ", ".join([str(entry) for entry in item])
+                documents.append(Document(text=doc_str))
+        return documents
 
+    def load_data(self, *args: Any, **load_kwargs: Any) -> List[str]:
+        """Query and load data from the Database, returning a list of Documents.
         Args:
             query (str): an SQL query to filter tables and rows.
-
         Returns:
-            List[text]: a list of text values from the database.
+            List[Document]: a list of Document objects from the database.
         """
+        query = args[0] if args else load_kwargs.get("args",{}).get("query")
+        if query is None:
+            raise ValueError("A query parameter is necessary to filter the data")
+
         count_query = f"SELECT COUNT(*) FROM ({query})"
         try:
-            count_rows = self.load_data_fn(count_query)
+            count_rows = self._load_data(count_query)
         except Exception as e:
             return [f"Error ({str(e)}) occurred while counting number of rows"]
         num_rows = int(count_rows[0].text)
@@ -42,19 +126,12 @@ class DBLoadData(DBTool):
                 "Please refactor your query to make it return less rows. "
             ]
         try:
-            res = self.load_data_fn(query)
+            res = self._load_data(query)
         except Exception as e:
             return [f"Error ({str(e)}) occurred while executing the query {query}"]
         return [d.text for d in res]
 
-class DBLoadSampleData(DBTool):
-    """
-    A tool to load a sample of data from the specified database table.
-
-    This tool fetches the first num_rows (default 25) rows from the given table
-    using a provided database query function.
-    """
-    def __call__(self, table_name: str, num_rows: int = 25) -> Any:
+    def load_sample_data(self, table_name: str, num_rows: int = 25) -> Any:
         """
         Fetches the first num_rows rows from the specified database table.
 
@@ -65,16 +142,39 @@ class DBLoadSampleData(DBTool):
             Any: The result of the database query.
         """
         try:
-            res = self.load_data_fn(f"SELECT * FROM {table_name} LIMIT {num_rows}")
+            res = self._load_data(f"SELECT * FROM {table_name} LIMIT {num_rows}")
         except Exception as e:
             return [f"Error ({str(e)}) occurred while loading sample data for table {table_name}"]
-        return res
+        return [d.text for d in res]
 
-class DBLoadUniqueValues(DBTool):
-    """
-    A tool to list all unique values for each column in a set of columns of a database table.
-    """
-    def __call__(self, table_name: str, columns: list[str], num_vals: int = 200) -> Any:
+    def list_tables(self) -> List[str]:
+        """List all tables in the database.
+        Returns:
+            List[str]: A list of table names in the database.
+        """
+        return [x.name for x in self._metadata.sorted_tables]
+
+    def describe_tables(self, tables: Optional[List[str]] = None) -> str:
+        """Describe the tables in the database.
+        Args:
+            tables (Optional[List[str]]): A list of table names to describe. If None, all tables are described.
+        Returns:
+            str: A string representation of the table schemas.
+        """
+        table_names = tables or [table.name for table in self._metadata.sorted_tables]
+        table_schemas = []
+        for table_name in table_names:
+            table = next(
+                (table for table in self._metadata.sorted_tables if table.name == table_name),
+                None,
+            )
+            if table is None:
+                raise NoSuchTableError(f"Table '{table_name}' does not exist.")
+            schema = str(CreateTable(table).compile(self.sql_database.engine))
+            table_schemas.append(f"{schema}\n")
+        return "\n".join(table_schemas)
+
+    def load_unique_values(self, table_name: str, columns: list[str], num_vals: int = 200) -> Any:
         """
         Fetches the first num_vals unique values from the specified columns of the database table.
 
@@ -89,8 +189,74 @@ class DBLoadUniqueValues(DBTool):
         res = {}
         try:
             for column in columns:
-                unique_vals = self.load_data_fn(f'SELECT DISTINCT "{column}" FROM {table_name} LIMIT {num_vals}')
+                unique_vals = self._load_data(f'SELECT DISTINCT "{column}" FROM {table_name} LIMIT {num_vals}')
                 res[column] = [d.text for d in unique_vals]
         except Exception as e:
             return {f"Error ({str(e)}) occurred while loading unique values for table {table_name}"}
         return res
+
+    def to_tool_list(self) -> List[FunctionTool]:
+        """
+        Returns a list of tools available.
+        """
+
+        tool_list = []
+        for tool_name in self.spec_functions:
+            func_sync = None
+            func_async = None
+            func = getattr(self, tool_name)
+            if asyncio.iscoroutinefunction(func):
+                func_async = func
+            else:
+                func_sync = func
+            metadata = self._get_metadata_from_fn_name(tool_name)
+
+            if func_sync is None:
+                if func_async is not None:
+                    func_sync = patch_sync(func_async)
+                else:
+                    raise ValueError(
+                        f"Could not retrieve a function for spec: {tool_name}"
+                    )
+
+            tool = FunctionTool.from_defaults(
+                fn=func_sync,
+                async_fn=func_async,
+                tool_metadata=metadata,
+            )
+            tool_list.append(tool)
+        return tool_list
+
+    # Custom pickling: exclude unpickleable objects
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        if "sql_database" in state:
+            state["sql_database_state"] = {"uri": self._uri}
+            del state["sql_database"]
+        if "_metadata" in state:
+            del state["_metadata"]
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        # Reconstruct the sql_database if it was removed
+        if "sql_database_state" in state:
+            uri = state["sql_database_state"].get("uri")
+            if uri:
+                self.sql_database = SQLDatabase.from_uri(uri)
+                self._uri = uri
+            else:
+                raise ValueError("Cannot reconstruct SQLDatabase without URI")
+            # Rebuild metadata after restoring the engine
+            self._metadata = MetaData()
+            self._metadata.reflect(bind=self.sql_database.engine)
+
+
+def patch_sync(func_async: AsyncCallable) -> Callable:
+    """Patch sync function from async function."""
+
+    def patched_sync(*args: Any, **kwargs: Any) -> Any:
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(func_async(*args, **kwargs))
+
+    return patched_sync

vectara_agentic/sub_query_workflow.py

@@ -102,7 +102,7 @@ class SubQuestionQueryWorkflow(Workflow):
             - What is the name of the mayor of San Jose?
             Here is the user question: {await ctx.get('original_query')}.
             Here are previous chat messages: {chat_history}.
-            And here is the list of tools: {await ctx.get('tools')}
+            And here is the list of tools: {ev.tools}
             """,
         )
 
@@ -236,6 +236,7 @@ class SequentialSubQuestionsWorkflow(Workflow):
             print(f"Query is {await ctx.get('original_query')}")
 
         llm = await ctx.get("llm")
+        orig_query = await ctx.get("original_query")
         response = llm.complete(
             f"""
             Given a user question, and a list of tools, output a list of
@@ -256,9 +257,9 @@ class SequentialSubQuestionsWorkflow(Workflow):
             - Who is the mayor of this city?
             The answer to the first question is San Jose, which is given as context to the second question.
             The answer to the second question is Matt Mahan.
-            Here is the user question: {await ctx.get('original_query')}.
+            Here is the user question: {orig_query}.
             Here are previous chat messages: {chat_history}.
-            And here is the list of tools: {await ctx.get('tools')}
+            And here is the list of tools: {ev.tools}
             """,
         )
 

vectara_agentic/tools.py

@@ -6,6 +6,7 @@ import inspect
 import re
 import importlib
 import os
+import asyncio
 
 from typing import Callable, List, Dict, Any, Optional, Union, Type
 from pydantic import BaseModel, Field, create_model
@@ -20,8 +21,8 @@ from llama_index.core.workflow.context import Context
 
 from .types import ToolType
 from .tools_catalog import ToolsCatalog, get_bad_topics
-from .db_tools import DBLoadSampleData, DBLoadUniqueValues, DBLoadData
-from .utils import is_float, summarize_vectara_document
+from .db_tools import DatabaseTools
+from .utils import is_float, summarize_documents
 from .agent_config import AgentConfig
 
 LI_packages = {
@@ -31,7 +32,6 @@ LI_packages = {
     "exa": ToolType.QUERY,
     "neo4j": ToolType.QUERY,
     "kuzu": ToolType.QUERY,
-    "database": ToolType.QUERY,
     "google": {
         "GmailToolSpec": {
             "load_data": ToolType.QUERY,
@@ -109,9 +109,20 @@ class VectaraTool(FunctionTool):
             fn, name, description, return_direct, fn_schema, async_fn, tool_metadata,
             callback, async_callback
         )
-        vectara_tool = cls(tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn)
+        vectara_tool = cls(
+            tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn,
+        )
         return vectara_tool
 
+    def __str__(self) -> str:
+        return (
+            f"Tool(name={self.metadata.name}, "
+            f"Tool metadata={self.metadata})"
+        )
+
+    def __repr__(self) -> str:
+        return str(self)
+
     def __eq__(self, other):
         if not isinstance(other, VectaraTool):
             return False
@@ -508,17 +519,29 @@ class VectaraToolFactory:
                     raw_input={"args": args, "kwargs": kwargs},
                     raw_output={"response": msg},
                 )
-            tool_output = "Matching documents:\n"
             unique_ids = set()
+            docs = []
             for doc in response:
                 if doc.id_ in unique_ids:
                     continue
                 unique_ids.add(doc.id_)
-                if summarize:
-                    summary = summarize_vectara_document(self.vectara_corpus_key, self.vectara_api_key, doc.id_)
-                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\nsummary: '{summary}'\n\n"
-                else:
-                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
+                docs.append((doc.id_, doc.metadata))
+            tool_output = "Matching documents:\n"
+            if summarize:
+                summaries_dict = asyncio.run(
+                    summarize_documents(
+                        self.vectara_corpus_key,
+                        self.vectara_api_key,
+                        list(unique_ids)
+                    )
+                )
+                for doc_id, metadata in docs:
+                    summary = summaries_dict.get(doc_id, "")
+                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
+            else:
+                for doc_id, metadata in docs:
+                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+
             out = ToolOutput(
                 tool_name=search_function.__name__,
                 content=tool_output,
@@ -529,12 +552,14 @@ class VectaraToolFactory:
 
         base_params = [
             inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
-            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=10, annotation=int),
+            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
             inspect.Parameter("summarize", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True, annotation=bool),
         ]
         search_tool_extra_desc = tool_description + "\n" + """
+        This tool is meant to perform a search for relevant documents, it is not meant for asking questions.
         The response includes metadata about each relevant document.
-        If summarize=True, it also includes a summary of each document.
+        If summarize=True, it also includes a summary of each document, but takes a lot longer to respond,
+        so avoid using it unless necessary.
         """
 
         tool = _create_tool_from_dynamic_function(
@@ -905,7 +930,7 @@ class ToolsFactory:
         user: str = "postgres",
         password: str = "Password",
         dbname: str = "postgres",
-        max_rows: int = 500,
+        max_rows: int = 1000,
     ) -> List[VectaraTool]:
         """
         Returns a list of database tools.
@@ -923,24 +948,16 @@ class ToolsFactory:
             dbname (str, optional): The database name. Defaults to "postgres".
                You must specify either the sql_database object or the scheme, host, port, user, password, and dbname.
             max_rows (int, optional): if specified, instructs the load_data tool to never return more than max_rows
-               rows. Defaults to 500.
+               rows. Defaults to 1000.
 
         Returns:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         if sql_database:
-            tools = self.get_llama_index_tools(
-                tool_package_name="database",
-                tool_spec_name="DatabaseToolSpec",
-                tool_name_prefix=tool_name_prefix,
-                sql_database=sql_database,
-            )
+            dbt = DatabaseTools(sql_database=sql_database)
         else:
             if scheme in ["postgresql", "mysql", "sqlite", "mssql", "oracle"]:
-                tools = self.get_llama_index_tools(
-                    tool_package_name="database",
-                    tool_spec_name="DatabaseToolSpec",
-                    tool_name_prefix=tool_name_prefix,
+                dbt = DatabaseTools(
                     scheme=scheme,
                     host=host,
                     port=port,
@@ -955,28 +972,19 @@ class ToolsFactory:
                 )
 
         # Update tools with description
+        tools = dbt.to_tool_list()
+        vtools = []
         for tool in tools:
             if content_description:
                 tool.metadata.description = (
                     tool.metadata.description + f"The database tables include data about {content_description}."
                 )
-
-        # Add two new tools: load_sample_data and load_unique_values
-        load_data_tool_index = next(i for i, t in enumerate(tools) if t.metadata.name.endswith("load_data"))
-        load_data_fn_original = tools[load_data_tool_index].fn
-
-        load_data_fn = DBLoadData(load_data_fn_original, max_rows=max_rows)
-        load_data_fn.__name__ = f"{tool_name_prefix}_load_data"
-        load_data_tool = self.create_tool(load_data_fn, ToolType.QUERY)
-
-        sample_data_fn = DBLoadSampleData(load_data_fn_original)
-        sample_data_fn.__name__ = f"{tool_name_prefix}_load_sample_data"
-        sample_data_tool = self.create_tool(sample_data_fn, ToolType.QUERY)
-
-        load_unique_values_fn = DBLoadUniqueValues(load_data_fn_original)
-        load_unique_values_fn.__name__ = f"{tool_name_prefix}_load_unique_values"
-        load_unique_values_tool = self.create_tool(load_unique_values_fn, ToolType.QUERY)
-
-        tools[load_data_tool_index] = load_data_tool
-        tools.extend([sample_data_tool, load_unique_values_tool])
-        return tools
+            if len(tool_name_prefix) > 0:
+                tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
+            vtool = VectaraTool(
+                tool_type=ToolType.QUERY,
+                fn=tool.fn, async_fn=tool.async_fn,
+                metadata=tool.metadata
+            )
+            vtools.append(vtool)
+        return vtools

vectara_agentic/utils.py

@@ -6,9 +6,9 @@ from typing import Tuple, Callable, Optional
 from functools import lru_cache
 from inspect import signature
 import json
-import requests
-
+import asyncio
 import tiktoken
+import aiohttp
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
@@ -43,7 +43,7 @@ def _get_llm_params_for_role(
     config = config or AgentConfig()  # fallback to default config
 
     if role == LLMRole.TOOL:
-        model_provider = config.tool_llm_provider
+        model_provider = ModelProvider(config.tool_llm_provider)
         # If the user hasn’t explicitly set a tool_llm_model_name,
         # fallback to provider default from provider_to_default_model_name
         model_name = (
@@ -51,7 +51,7 @@ def _get_llm_params_for_role(
             or provider_to_default_model_name.get(model_provider)
         )
     else:
-        model_provider = config.main_llm_provider
+        model_provider = ModelProvider(config.main_llm_provider)
         model_name = (
             config.main_llm_model_name
             or provider_to_default_model_name.get(model_provider)
@@ -101,13 +101,17 @@ def get_llm(
                      max_tokens=max_tokens
             )
     elif model_provider == ModelProvider.ANTHROPIC:
-        llm = Anthropic(model=model_name, temperature=0, max_tokens=max_tokens)
+        llm = Anthropic(
+            model=model_name, temperature=0,
+            max_tokens=max_tokens, cache_idx=2,
+        )
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
         llm = Gemini(
             model=model_name, temperature=0,
             is_function_calling_model=True,
-            max_tokens=max_tokens
+            allow_parallel_tool_calls=True,
+            max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:
         from llama_index.llms.together import TogetherLLM
@@ -159,7 +163,7 @@ def remove_self_from_signature(func):
     func.__signature__ = new_sig
     return func
 
-def summarize_vectara_document(corpus_key: str, vectara_api_key, doc_id: str) -> str:
+async def summarize_vectara_document(corpus_key: str, vectara_api_key: str, doc_id: str) -> str:
     """
     Summarize a document in a Vectara corpus using the Vectara API.
     """
@@ -175,8 +179,32 @@ def summarize_vectara_document(corpus_key: str, vectara_api_key, doc_id: str) ->
         'Accept': 'application/json',
         'x-api-key': vectara_api_key
     }
-
-    response = requests.request("POST", url, headers=headers, data=payload, timeout=60)
-    if response.status_code != 200:
-        return f"Vectara Summarization failed with error code {response.status_code}, error={response.text}"
+    timeout = aiohttp.ClientTimeout(total=60)
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.post(url, headers=headers, data=payload) as response:
+            if response.status != 200:
+                error_json = await response.json()
+                return (
+                    f"Vectara Summarization failed with error code {response.status}, "
+                    f"error={error_json['messages'][0]}"
+                )
+            data = await response.json()
+            return data["summary"]
     return json.loads(response.text)["summary"]
+
+async def summarize_documents(
+    vectara_corpus_key: str,
+    vectara_api_key: str,
+    doc_ids: list[str]
+) -> dict[str, str]:
+    """
+    Summarize multiple documents in a Vectara corpus using the Vectara API.
+    """
+    if not doc_ids:
+        return {}
+    tasks = [
+        summarize_vectara_document(vectara_corpus_key, vectara_api_key, doc_id)
+        for doc_id in doc_ids
+    ]
+    summaries = await asyncio.gather(*tasks, return_exceptions=True)
+    return dict(zip(doc_ids, summaries))

{vectara_agentic-0.2.7.dist-info → vectara_agentic-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.7
+Version: 0.2.9
 Summary: A Python package for creating AI Assistants and AI Agents with Vectara
 Home-page: https://github.com/vectara/py-vectara-agentic
 Author: Ofer Mendelevitch
@@ -16,7 +16,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.12.25
+Requires-Dist: llama-index==0.12.26
 Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0

{vectara_agentic-0.2.7.dist-info → vectara_agentic-0.2.9.dist-info}/RECORD

@@ -1,28 +1,29 @@
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/endpoint.py,sha256=frnpdZQpnuQNNKNYgAn2rFTarNG8MCJaNA77Bw_W22A,1420
-tests/test_agent.py,sha256=CU7Zdb1J5kFjrkkIeDr70W1wsikYuOvoYKGYpg4EPxM,6678
+tests/test_agent.py,sha256=t4omKBg9207hpT8b05v9TwuXJCM4knYSTdsXe740eho,4845
 tests/test_agent_planning.py,sha256=_mj73TNP9yUjkUJ-X31r-cQYreJ4qatXOtMrRvVpF4Y,2411
 tests/test_agent_type.py,sha256=JM0Q2GBGHSADoBacz_DW551zWSfbpf7qa8xXqtyWsc4,5671
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
 tests/test_private_llm.py,sha256=CY-_rCpxGUuxnZ3ypkodw5Jj-sJCNdh6rLbCvULwuJI,2247
+tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
 tests/test_tools.py,sha256=IVKn0HoS2erTCr1mOEGzTkktiY0PCfKNvqnD_pizjOg,3977
 tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
-vectara_agentic/_callback.py,sha256=5PfqjLmuaZIR6dnqmhniTD_zwCgfi7kOu-nexb6Kss4,9688
+vectara_agentic/_callback.py,sha256=lU35-Pxp-fsMpOi4woY6oLECAhO1nSmLIy3b8fbgT54,13029
 vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
 vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
-vectara_agentic/_version.py,sha256=FGUM5lA5uZpmWWB52dt2AMCqWcU0M9b-2BB-raX-EN4,65
-vectara_agentic/agent.py,sha256=nbBl66n56kjEZX4Zconb9IZjESzpjBZIEQdL4uLfurI,43333
-vectara_agentic/agent_config.py,sha256=y1hSvU5ns0cE2R7BqF65LFstixF1ytJcoVgicGXo7w0,3691
+vectara_agentic/_version.py,sha256=H4T1Nr91mODgWHnEWr2XhUyVnkEh_ZuEEayYoJS0Iis,65
+vectara_agentic/agent.py,sha256=ItNy6QRfgkk-zePK05k8yhsov_TVh5ScB-BbiQdUbTY,43956
+vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
 vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=VUdcjDFPwauFd2A92mXNYZnCjeMiTzcTka7S5At_3oQ,3595
-vectara_agentic/sub_query_workflow.py,sha256=eS1S7l5PdyLPLZqxUJSR0oM2kvHb4raPGHk8t8td9sc,10939
-vectara_agentic/tools.py,sha256=RpPGWiPHe-9ZiOxNz389W-gNWxegg7m4RlEx_pH9_W0,42881
+vectara_agentic/db_tools.py,sha256=Go03bzma9m-qDH0CPP8hWhf1nu_4S6s7ke0jGqz58Pk,10296
+vectara_agentic/sub_query_workflow.py,sha256=3WoVnryR2NXyYXbLDM1XVLd7DtbCG0jgrVqeDUN4YNQ,10943
+vectara_agentic/tools.py,sha256=vOIevyGhApeZ46UelSTXmKXWE26Z2KtjLgsb4cHP49M,42579
 vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
-vectara_agentic/utils.py,sha256=U4VWCyrvpXfPb9SJpd4Xj7rJCN-cZCNReNm9_uQjnlk,6759
-vectara_agentic-0.2.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.7.dist-info/METADATA,sha256=z-IFDKlGmNh9QSIUV4xOOCYKF-PrTUnDukp8M5BNMe4,25046
-vectara_agentic-0.2.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectara_agentic-0.2.7.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.7.dist-info/RECORD,,
+vectara_agentic/utils.py,sha256=4vA5MyNoG47_7eHuLFQByiG_FHWbrQ6ZJDsdqHUwiJA,7720
+vectara_agentic-0.2.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.9.dist-info/METADATA,sha256=FfjEtidIWQlsUXY_cdVIxPc6h07M3JwXjQKEj3aCMLY,25046
+vectara_agentic-0.2.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.9.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.9.dist-info/RECORD,,