vectara-agentic 0.2.7__tar.gz → 0.2.9__tar.gz

{vectara_agentic-0.2.7/vectara_agentic.egg-info → vectara_agentic-0.2.9}/PKG-INFO

@@ -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 → vectara_agentic-0.2.9}/requirements.txt

@@ -1,4 +1,4 @@
-llama-index==0.12.25
+llama-index==0.12.26
 llama-index-indices-managed-vectara==0.4.2
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0

{vectara_agentic-0.2.7 → vectara_agentic-0.2.9}/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"

vectara_agentic-0.2.9/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-0.2.7 → vectara_agentic-0.2.9}/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-0.2.7 → vectara_agentic-0.2.9}/vectara_agentic/_version.py

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

{vectara_agentic-0.2.7 → vectara_agentic-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-0.2.7 → vectara_agentic-0.2.9}/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.