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

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.8"
+__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,

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/tools.py

@@ -539,8 +539,8 @@ class VectaraToolFactory:
                     summary = summaries_dict.get(doc_id, "")
                     tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
             else:
-                for doc in docs:
-                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
+                for doc_id, metadata in docs:
+                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
 
             out = ToolOutput(
                 tool_name=search_function.__name__,

vectara_agentic/utils.py

@@ -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)
@@ -110,6 +110,7 @@ def get_llm(
         llm = Gemini(
             model=model_name, temperature=0,
             is_function_calling_model=True,
+            allow_parallel_tool_calls=True,
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.8
+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

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

@@ -9,21 +9,21 @@ tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4
 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=HOBvs3gmojKxd7sNMHt6Q-0_rlFpgzlI1gXNZOS_Fqc,65
-vectara_agentic/agent.py,sha256=ioC6EN86_d7SS1jEZ6CUe6OtetuGmLdWftj5bklPfMs,43522
-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=Go03bzma9m-qDH0CPP8hWhf1nu_4S6s7ke0jGqz58Pk,10296
 vectara_agentic/sub_query_workflow.py,sha256=3WoVnryR2NXyYXbLDM1XVLd7DtbCG0jgrVqeDUN4YNQ,10943
-vectara_agentic/tools.py,sha256=Mm2qfJZWnbNa9G-ycYMP7NPLSo4uUJ9_y45YmXxtlSc,42571
+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=nBQqVb4_UNummqVz28DHm3VaKzy8OAq-xSjhU23uxWU,7646
-vectara_agentic-0.2.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.8.dist-info/METADATA,sha256=IV5fm77XOPOvqfcpCZUKRxq9QgnoF3mPu-om_sTKEK8,25046
-vectara_agentic-0.2.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectara_agentic-0.2.8.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.8.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,,