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

tests/test_agent.py

@@ -1,4 +1,5 @@
 import unittest
+import threading
 from datetime import date
 
 from vectara_agentic.agent import _get_prompt, Agent, AgentType
@@ -6,9 +7,12 @@ from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider, ObserverType
 from vectara_agentic.tools import ToolsFactory
 
-def mult(x, y):
+def mult(x: float, y: float) -> float:
     return x * y
 
+
+ARIZE_LOCK = threading.Lock()
+
 class TestAgentPackage(unittest.TestCase):
     def test_get_prompt(self):
         prompt_template = "{chat_topic} on {today} with {custom_instructions}"
@@ -41,38 +45,39 @@ class TestAgentPackage(unittest.TestCase):
         )
 
     def test_agent_config(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        config = AgentConfig(
-            agent_type=AgentType.REACT,
-            main_llm_provider=ModelProvider.ANTHROPIC,
-            main_llm_model_name="claude-3-5-sonnet-20241022",
-            tool_llm_provider=ModelProvider.TOGETHER,
-            tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
-            observer=ObserverType.ARIZE_PHOENIX
-        )
-
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-            agent_config=config
-        )
-        self.assertEqual(agent._topic, topic)
-        self.assertEqual(agent._custom_instructions, instructions)
-        self.assertEqual(agent.agent_type, AgentType.REACT)
-        self.assertEqual(agent.agent_config.observer, ObserverType.ARIZE_PHOENIX)
-        self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
-        self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
-
-        # To run this test, you must have ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
-        self.assertEqual(
-            agent.chat(
-                "What is 5 times 10. Only give the answer, nothing else"
-            ).response.replace("$", "\\$"),
-            "50",
-        )
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            topic = "AI topic"
+            instructions = "Always do as your father tells you, if your mother agrees!"
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                main_llm_model_name="claude-3-5-sonnet-20241022",
+                tool_llm_provider=ModelProvider.TOGETHER,
+                tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+
+            agent = Agent(
+                tools=tools,
+                topic=topic,
+                custom_instructions=instructions,
+                agent_config=config
+            )
+            self.assertEqual(agent._topic, topic)
+            self.assertEqual(agent._custom_instructions, instructions)
+            self.assertEqual(agent.agent_type, AgentType.REACT)
+            self.assertEqual(agent.agent_config.observer, ObserverType.ARIZE_PHOENIX)
+            self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
+            self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
+
+            # To run this test, you must have ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
+            self.assertEqual(
+                agent.chat(
+                    "What is 5 times 10. Only give the answer, nothing else"
+                ).response.replace("$", "\\$"),
+                "50",
+            )
 
     def test_multiturn(self):
         tools = [ToolsFactory().create_tool(mult)]
@@ -101,44 +106,6 @@ class TestAgentPackage(unittest.TestCase):
         self.assertIsInstance(agent, Agent)
         self.assertEqual(agent._topic, "question answering")
 
-    def test_serialization(self):
-        config = AgentConfig(
-            agent_type=AgentType.REACT,
-            main_llm_provider=ModelProvider.ANTHROPIC,
-            main_llm_model_name="claude-3-5-sonnet-20241022",
-            tool_llm_provider=ModelProvider.TOGETHER,
-            tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
-            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_agent_planning.py

@@ -1,45 +1,72 @@
 import unittest
 
-from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
-from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.agent import Agent
+from vectara_agentic.tools import VectaraToolFactory
+
+from pydantic import Field, BaseModel
+
+
+# SETUP speical test account credentials for vectara
+# It's okay to expose these credentials in the test code
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = 'zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA'
 
-def mult(x, y):
-    return x * y
 
-def addition(x, y):
-    return x + y
+class QueryArgs(BaseModel):
+    query: str = Field(..., description="The user query, always in the form of a question.")
+
+
+vec_factory = VectaraToolFactory(vectara_api_key=vectara_api_key,
+                                 vectara_corpus_key=vectara_corpus_key)
+summarizer = 'vectara-summary-table-md-query-ext-jan-2025-gpt-4o'
+ask_vectara = vec_factory.create_rag_tool(
+    tool_name = "ask_vectara",
+    tool_description = "This tool can respond to questions about Vectara.",
+    tool_args_schema = QueryArgs,
+    reranker = "multilingual_reranker_v1", rerank_k = 100, rerank_cutoff = 0.1,
+    n_sentences_before = 2, n_sentences_after = 2, lambda_val = 0.005,
+    summary_num_results = 10,
+    vectara_summarizer = summarizer,
+    include_citations = True,
+    verbose=False,
+)
 
 class TestAgentPlanningPackage(unittest.TestCase):
 
     def test_no_planning(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
         agent = Agent(
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
-            agent_config = AgentConfig()
+            agent_config=AgentConfig(),
         )
-
-        res = agent.chat("If you multiply 5 times 7, then 3 times 2, and add the results - what do you get?")
-        self.assertIn("41", res.response)
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
 
     def test_structured_planning(self):
-        tools = [ToolsFactory().create_tool(mult), ToolsFactory().create_tool(addition)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
         agent = Agent(
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
-            agent_config = AgentConfig(),
-            use_structured_planning = True,
+            agent_config=AgentConfig(),
+            use_structured_planning=True,
         )
 
-        res = agent.chat("If you multiply 5 times 7, then 3 times 2, and add the results - what do you get?")
-        self.assertIn("41", res.response)
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
 
 
 if __name__ == "__main__":

tests/test_agent_type.py

@@ -7,24 +7,48 @@ from vectara_agentic.types import ModelProvider
 
 import nest_asyncio
 nest_asyncio.apply()
-def mult(x, y):
+
+def mult(x: float, y: float) -> float:
     return x * y
 
 
-react_config_1 = AgentConfig(
+react_config_anthropic = AgentConfig(
     agent_type=AgentType.REACT,
     main_llm_provider=ModelProvider.ANTHROPIC,
-    main_llm_model_name="claude-3-7-sonnet-20250219",
-    tool_llm_provider=ModelProvider.TOGETHER,
-    tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+react_config_gemini = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
 )
 
-react_config_2 = AgentConfig(
+react_config_together = AgentConfig(
     agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+fc_config_anthropic = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+fc_config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.GEMINI,
     tool_llm_provider=ModelProvider.GEMINI,
 )
 
+fc_config_together = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+
 openai_config = AgentConfig(
     agent_type=AgentType.OPENAI,
 )
@@ -47,28 +71,78 @@ class TestAgentType(unittest.TestCase):
         res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
-    def test_react_anthropic(self):
+    def test_gemini(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_gemini,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+        agent = Agent(
+            agent_config=fc_config_gemini,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+    def test_together(self):
         tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"
         instructions = "Always do as your father tells you, if your mother agrees!"
+
         agent = Agent(
-            agent_config=react_config_1,
+            agent_config=react_config_together,
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
         )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
 
+        agent = Agent(
+            agent_config=fc_config_together,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
         agent.chat("What is 5 times 10. Only give the answer, nothing else")
         agent.chat("what is 3 times 7. Only give the answer, nothing else")
         res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
-    def test_react_gemini(self):
+    def test_anthropic(self):
         tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"
         instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_anthropic,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
         agent = Agent(
-            agent_config=react_config_2,
+            agent_config=fc_config_anthropic,
             tools=tools,
             topic=topic,
             custom_instructions=instructions,

tests/test_fallback.py

@@ -40,8 +40,8 @@ class TestFallback(unittest.TestCase):
         cls.flask_process.send_signal(signal.SIGINT)
         cls.flask_process.wait()
 
-    def test_fallback(self):
-        def mult(x, y):
+    def test_fallback_from_private(self):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]

tests/test_private_llm.py

@@ -41,7 +41,7 @@ class TestPrivateLLM(unittest.TestCase):
         cls.flask_process.wait()
 
     def test_endpoint(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]

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()

tests/test_tools.py

@@ -47,7 +47,7 @@ class TestToolsPackage(unittest.TestCase):
         self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_tool_factory(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools_factory = ToolsFactory()

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.6"
+__version__ = "0.2.8"

vectara_agentic/agent.py

@@ -21,7 +21,7 @@ from pydantic import Field, create_model, ValidationError
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
-from llama_index.core.agent import ReActAgent, StructuredPlannerAgent
+from llama_index.core.agent import ReActAgent, StructuredPlannerAgent, FunctionCallingAgent
 from llama_index.core.agent.react.formatter import ReActChatFormatter
 from llama_index.agent.llm_compiler import LLMCompilerAgentWorker
 from llama_index.agent.lats import LATSAgentWorker
@@ -277,7 +277,19 @@ class Agent:
         llm = get_llm(LLMRole.MAIN, config=config)
         llm.callback_manager = llm_callback_manager
 
-        if agent_type == AgentType.REACT:
+        if agent_type == AgentType.FUNCTION_CALLING:
+            prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
+            agent = FunctionCallingAgent.from_tools(
+                tools=self.tools,
+                llm=llm,
+                memory=self.memory,
+                verbose=self.verbose,
+                max_function_calls=config.max_reasoning_steps,
+                callback_manager=llm_callback_manager,
+                system_prompt = prompt,
+                allow_parallel_tool_calls=True,
+            )
+        elif agent_type == AgentType.REACT:
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = ReActAgent.from_tools(
                 tools=self.tools,
@@ -295,7 +307,7 @@ class Agent:
                 llm=llm,
                 memory=self.memory,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
                 max_function_calls=config.max_reasoning_steps,
                 system_prompt=prompt,
             )
@@ -304,7 +316,7 @@ class Agent:
                 tools=self.tools,
                 llm=llm,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             agent_worker.system_prompt = _get_prompt(
                 _get_llm_compiler_prompt(agent_worker.system_prompt, self._topic, self._custom_instructions),
@@ -322,7 +334,7 @@ class Agent:
                 num_expansions=3,
                 max_rollouts=-1,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent_worker.chat_formatter = ReActChatFormatter(system_header=prompt)
@@ -707,6 +719,8 @@ class Agent:
         """
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
+        orig_llm = self.llm.metadata.model_name
+        last_error = None
         while attempt < max_attempts:
             try:
                 current_agent = self._get_current_agent()
@@ -718,16 +732,20 @@ class Agent:
                     self.query_logging_callback(prompt, agent_response.response)
                 return agent_response
 
-            except Exception:
+            except Exception as e:
+                last_error = e
                 if attempt >= 2:
                     if self.verbose:
-                        print(f"LLM call failed on attempt {attempt+1}. 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}."
+            )
         )
 
     def stream_chat(self, prompt: str) -> AgentStreamingResponse:    # type: ignore
@@ -750,6 +768,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()
@@ -770,16 +789,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})."
+            )
         )
 
     #
@@ -843,7 +866,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