vectara-agentic 0.4.0__tar.gz → 0.4.1__tar.gz

{vectara_agentic-0.4.0/vectara_agentic.egg-info → vectara_agentic-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.4.0
+Version: 0.4.1
 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,13 +16,11 @@ 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.49
-Requires-Dist: llama-index-core==0.12.49
+Requires-Dist: llama-index==0.12.52
+Requires-Dist: llama-index-core==0.12.52.post1
 Requires-Dist: llama-index-workflow==1.0.1
 Requires-Dist: llama-index-cli==0.4.4
 Requires-Dist: llama-index-indices-managed-vectara==0.4.5
-Requires-Dist: llama-index-agent-llm-compiler==0.3.2
-Requires-Dist: llama-index-agent-lats==0.3.2
 Requires-Dist: llama-index-agent-openai==0.4.12
 Requires-Dist: llama-index-llms-openai==0.4.7
 Requires-Dist: llama-index-llms-openai-like==0.4.0
@@ -53,7 +51,7 @@ Requires-Dist: openinference-instrumentation-llama-index==4.3.1
 Requires-Dist: opentelemetry-proto>=1.31.0
 Requires-Dist: arize-phoenix==10.9.1
 Requires-Dist: arize-phoenix-otel==0.10.3
-Requires-Dist: protobuf==5.29.3
+Requires-Dist: protobuf==5.29.5
 Requires-Dist: tokenizers>=0.20
 Requires-Dist: pydantic==2.11.5
 Requires-Dist: pandas==2.2.3
@@ -125,7 +123,7 @@ Dynamic: summary
 - **Rapid Tool Creation:**  
   Build Vectara RAG tools or search tools with a single line of code.
 - **Agent Flexibility:**  
-  Supports multiple agent types including `ReAct`, `Function Calling`, `LATS`, and `LLMCompiler`.
+  Supports multiple agent types including `ReAct` and `Function Calling`.
 - **Pre-Built Domain Tools:**  
   Tools tailored for finance, legal, and other verticals.
 - **Multi-LLM Integration:**  
@@ -532,6 +530,49 @@ Built-in formatters include `format_as_table`, `format_as_json`, and `format_as_
 
 The human-readable format, if available, is used when using Vectara Hallucination Correction.
 
+## 🔍 Vectara Hallucination Correction (VHC)
+
+`vectara-agentic` provides built-in support for Vectara Hallucination Correction (VHC), which analyzes agent responses and corrects any detected hallucinations based on the factual content retrieved by VHC-eligible tools.
+
+### Computing VHC
+
+After a chat interaction, you can compute VHC to analyze and correct the agent's response:
+
+```python
+# Chat with the agent
+response = agent.chat("What was Apple's revenue in 2022?")
+print(response.response)
+
+# Compute VHC analysis
+vhc_result = agent.compute_vhc()
+
+# Access corrected text and corrections
+if vhc_result["corrected_text"]:
+    print("Original:", response.response)
+    print("Corrected:", vhc_result["corrected_text"])
+    print("Corrections:", vhc_result["corrections"])
+else:
+    print("No corrections needed or VHC not available")
+```
+
+### Async VHC Computation
+
+For async applications, use `acompute_vhc()`:
+
+```python
+# Async chat
+response = await agent.achat("What was Apple's revenue in 2022?")
+
+# Async VHC computation
+vhc_result = await agent.acompute_vhc()
+```
+
+### VHC Requirements
+
+- VHC requires a valid `VECTARA_API_KEY` environment variable
+- Only VHC-eligible tools (those marked with `vhc_eligible=True`) contribute to the analysis
+- VHC results are cached for each query/response pair to avoid redundant computation
+
 ### Tool Validation
 
 When creating an agent, you can enable tool validation by setting `validate_tools=True`. This will check that any tools mentioned in your custom instructions actually exist in the agent's tool set:
@@ -745,7 +786,7 @@ agent = Agent(
 ```
 
 The `AgentConfig` object may include the following items:
-- `agent_type`: the agent type. Valid values are `REACT`, `LLMCOMPILER`, `LATS` or `FUNCTION_CALLING` (default: `FUNCTION_CALLING`).
+- `agent_type`: the agent type. Valid values are `REACT` or `FUNCTION_CALLING` (default: `FUNCTION_CALLING`).
 - `main_llm_provider` and `tool_llm_provider`: the LLM provider for main agent and for the tools. Valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `BEDROCK`, `GEMINI` (default: `OPENAI`).
 
 > **Note:** Fireworks AI support has been removed. If you were using Fireworks, please migrate to one of the supported providers listed above.

{vectara_agentic-0.4.0 → vectara_agentic-0.4.1}/README.md

@@ -48,7 +48,7 @@
 - **Rapid Tool Creation:**  
   Build Vectara RAG tools or search tools with a single line of code.
 - **Agent Flexibility:**  
-  Supports multiple agent types including `ReAct`, `Function Calling`, `LATS`, and `LLMCompiler`.
+  Supports multiple agent types including `ReAct` and `Function Calling`.
 - **Pre-Built Domain Tools:**  
   Tools tailored for finance, legal, and other verticals.
 - **Multi-LLM Integration:**  
@@ -455,6 +455,49 @@ Built-in formatters include `format_as_table`, `format_as_json`, and `format_as_
 
 The human-readable format, if available, is used when using Vectara Hallucination Correction.
 
+## 🔍 Vectara Hallucination Correction (VHC)
+
+`vectara-agentic` provides built-in support for Vectara Hallucination Correction (VHC), which analyzes agent responses and corrects any detected hallucinations based on the factual content retrieved by VHC-eligible tools.
+
+### Computing VHC
+
+After a chat interaction, you can compute VHC to analyze and correct the agent's response:
+
+```python
+# Chat with the agent
+response = agent.chat("What was Apple's revenue in 2022?")
+print(response.response)
+
+# Compute VHC analysis
+vhc_result = agent.compute_vhc()
+
+# Access corrected text and corrections
+if vhc_result["corrected_text"]:
+    print("Original:", response.response)
+    print("Corrected:", vhc_result["corrected_text"])
+    print("Corrections:", vhc_result["corrections"])
+else:
+    print("No corrections needed or VHC not available")
+```
+
+### Async VHC Computation
+
+For async applications, use `acompute_vhc()`:
+
+```python
+# Async chat
+response = await agent.achat("What was Apple's revenue in 2022?")
+
+# Async VHC computation
+vhc_result = await agent.acompute_vhc()
+```
+
+### VHC Requirements
+
+- VHC requires a valid `VECTARA_API_KEY` environment variable
+- Only VHC-eligible tools (those marked with `vhc_eligible=True`) contribute to the analysis
+- VHC results are cached for each query/response pair to avoid redundant computation
+
 ### Tool Validation
 
 When creating an agent, you can enable tool validation by setting `validate_tools=True`. This will check that any tools mentioned in your custom instructions actually exist in the agent's tool set:
@@ -668,7 +711,7 @@ agent = Agent(
 ```
 
 The `AgentConfig` object may include the following items:
-- `agent_type`: the agent type. Valid values are `REACT`, `LLMCOMPILER`, `LATS` or `FUNCTION_CALLING` (default: `FUNCTION_CALLING`).
+- `agent_type`: the agent type. Valid values are `REACT` or `FUNCTION_CALLING` (default: `FUNCTION_CALLING`).
 - `main_llm_provider` and `tool_llm_provider`: the LLM provider for main agent and for the tools. Valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `BEDROCK`, `GEMINI` (default: `OPENAI`).
 
 > **Note:** Fireworks AI support has been removed. If you were using Fireworks, please migrate to one of the supported providers listed above.

{vectara_agentic-0.4.0 → vectara_agentic-0.4.1}/requirements.txt

@@ -1,10 +1,8 @@
-llama-index==0.12.49
-llama-index-core==0.12.49
+llama-index==0.12.52
+llama-index-core==0.12.52.post1
 llama-index-workflow==1.0.1
 llama-index-cli==0.4.4
 llama-index-indices-managed-vectara==0.4.5
-llama-index-agent-llm-compiler==0.3.2
-llama-index-agent-lats==0.3.2
 llama-index-agent-openai==0.4.12
 llama-index-llms-openai==0.4.7
 llama-index-llms-openai-like==0.4.0
@@ -35,7 +33,7 @@ openinference-instrumentation-llama-index==4.3.1
 opentelemetry-proto>=1.31.0
 arize-phoenix==10.9.1
 arize-phoenix-otel==0.10.3
-protobuf==5.29.3
+protobuf==5.29.5
 tokenizers>=0.20
 pydantic==2.11.5
 pandas==2.2.3

{vectara_agentic-0.4.0 → vectara_agentic-0.4.1}/tests/conftest.py

@@ -19,6 +19,7 @@ from vectara_agentic.types import AgentType, ModelProvider
 # Common Test Functions
 # ========================================
 
+
 def mult(x: float, y: float) -> float:
     """Multiply two numbers - common test function used across multiple test files."""
     return x * y
@@ -37,7 +38,9 @@ def add(x: float, y: float) -> float:
 STANDARD_TEST_TOPIC = "AI topic"
 
 # Standard test instructions used across most tests
-STANDARD_TEST_INSTRUCTIONS = "Always do as your father tells you, if your mother agrees!"
+STANDARD_TEST_INSTRUCTIONS = (
+    "Always do as your father tells you, if your mother agrees!"
+)
 
 # Alternative instructions for specific tests
 WORKFLOW_TEST_INSTRUCTIONS = "You are a helpful AI assistant."
@@ -139,6 +142,7 @@ private_llm_fc_config = AgentConfig(
 # Error Detection and Testing Utilities
 # ========================================
 
+
 def is_rate_limited(response_text: str) -> bool:
     """
     Check if a response indicates a rate limit error from any LLM provider.

{vectara_agentic-0.4.0 → vectara_agentic-0.4.1}/tests/run_tests.py

@@ -34,6 +34,7 @@ def suppress_pydantic_warnings():
     resource_patterns = [
         ".*unclosed transport.*",
         ".*unclosed <socket\\.socket.*",
+        ".*unclosed event loop.*",
     ]
 
     for pattern in pydantic_patterns:

{vectara_agentic-0.4.0 → vectara_agentic-0.4.1}/tests/test_agent.py

@@ -7,17 +7,13 @@ import threading
 from datetime import date
 
 from vectara_agentic.agent import Agent, AgentType
-from vectara_agentic.agent_core.utils.prompt_formatting import format_prompt
+from vectara_agentic.agent_core.factory import format_prompt
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider, ObserverType
 from vectara_agentic.tools import ToolsFactory
 
 from vectara_agentic.agent_core.prompts import GENERAL_INSTRUCTIONS
-
-
-def mult(x: float, y: float) -> float:
-    "Multiply two numbers"
-    return x * y
+from conftest import mult, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS
 
 
 ARIZE_LOCK = threading.Lock()
@@ -38,12 +34,10 @@ class TestAgentPackage(unittest.TestCase):
 
     def test_agent_init(self):
         tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI"
-        custom_instructions = "Always do as your mother tells you!"
-        agent = Agent(tools, topic, custom_instructions)
+        agent = Agent(tools, STANDARD_TEST_TOPIC, STANDARD_TEST_INSTRUCTIONS)
         self.assertEqual(agent.agent_type, AgentType.FUNCTION_CALLING)
-        self.assertEqual(agent._topic, topic)
-        self.assertEqual(agent._custom_instructions, custom_instructions)
+        self.assertEqual(agent._topic, STANDARD_TEST_TOPIC)
+        self.assertEqual(agent._custom_instructions, STANDARD_TEST_INSTRUCTIONS)
 
         # To run this test, you must have appropriate API key in your environment
         self.assertEqual(
@@ -56,8 +50,6 @@ class TestAgentPackage(unittest.TestCase):
     def test_agent_config(self):
         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,
@@ -69,12 +61,12 @@ class TestAgentPackage(unittest.TestCase):
 
             agent = Agent(
                 tools=tools,
-                topic=topic,
-                custom_instructions=instructions,
+                topic=STANDARD_TEST_TOPIC,
+                custom_instructions=STANDARD_TEST_INSTRUCTIONS,
                 agent_config=config
             )
-            self.assertEqual(agent._topic, topic)
-            self.assertEqual(agent._custom_instructions, instructions)
+            self.assertEqual(agent._topic, STANDARD_TEST_TOPIC)
+            self.assertEqual(agent._custom_instructions, STANDARD_TEST_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)
@@ -89,19 +81,20 @@ class TestAgentPackage(unittest.TestCase):
             )
 
     def test_multiturn(self):
-        tools = [ToolsFactory().create_tool(mult)]
-        topic = "AI topic"
-        instructions = "Always do as your father tells you, if your mother agrees!"
-        agent = Agent(
-            tools=tools,
-            topic=topic,
-            custom_instructions=instructions,
-        )
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            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.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 questions. Output only the answer.")
-        self.assertEqual(res.response, "1050")
+            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 questions. Output only the answer.")
+            self.assertEqual(res.response, "1050")
 
     def test_from_corpus(self):
         agent = Agent.from_corpus(
@@ -126,6 +119,10 @@ class TestAgentPackage(unittest.TestCase):
             chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
         )
 
+        data = agent.dumps()
+        clone = Agent.loads(data)
+        assert clone.memory.get() == agent.memory.get()
+
         res = agent.chat("multiply the results of the last two questions. Output only the answer.")
         self.assertEqual(res.response, "1050")
 

vectara_agentic-0.4.1/tests/test_agent_fallback_memory.py

@@ -0,0 +1,270 @@
+# Suppress external dependency warnings before any other imports
+import warnings
+
+warnings.simplefilter("ignore", DeprecationWarning)
+
+import unittest
+import threading
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, AgentConfigType
+from vectara_agentic.tools import ToolsFactory
+
+from llama_index.core.llms import ChatMessage, MessageRole
+from conftest import mult, add
+
+
+ARIZE_LOCK = threading.Lock()
+
+
+class TestAgentFallbackMemoryConsistency(unittest.TestCase):
+    """Test memory consistency between main and fallback agents"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.tools = [ToolsFactory().create_tool(mult), ToolsFactory().create_tool(add)]
+        self.topic = "Mathematics"
+        self.custom_instructions = "You are a helpful math assistant."
+
+        # Main agent config
+        self.main_config = AgentConfig(
+            agent_type=AgentType.FUNCTION_CALLING,
+            main_llm_provider=ModelProvider.ANTHROPIC,
+        )
+
+        # Fallback agent config
+        self.fallback_config = AgentConfig(
+            agent_type=AgentType.REACT, main_llm_provider=ModelProvider.ANTHROPIC
+        )
+
+        self.session_id = "test-fallback-session-123"
+
+    def test_memory_consistency_on_agent_creation(self):
+        """Test that main and fallback agents are created with the same memory content"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Add some memory before creating the agents
+        test_messages = [
+            ChatMessage(role=MessageRole.USER, content="What is 2*3?"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="2*3 = 6"),
+        ]
+        agent.memory.put_messages(test_messages)
+
+        # Verify both agents have memory with the same content
+        # Memory is managed by the main Agent class, not individual agent instances
+        main_memory = agent.memory.get()
+        fallback_memory = agent.memory.get()  # Both access the same memory
+
+        self.assertEqual(len(main_memory), 2)
+        self.assertEqual(len(fallback_memory), 2)
+        self.assertEqual(main_memory[0].content, "What is 2*3?")
+        self.assertEqual(fallback_memory[0].content, "What is 2*3?")
+
+        # Verify session_id consistency
+        # Memory is managed by the main Agent class
+        self.assertEqual(agent.memory.session_id, self.session_id)
+
+    def test_memory_sync_during_agent_switching(self):
+        """Test that memory remains consistent when switching between main and fallback agents"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Start with main agent
+        self.assertEqual(agent.agent_config_type, AgentConfigType.DEFAULT)
+
+        # Add initial memory
+        initial_messages = [
+            ChatMessage(role=MessageRole.USER, content="Initial question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Initial response"),
+        ]
+        agent.memory.put_messages(initial_messages)
+
+        # Access main agent to ensure it's loaded
+        main_memory_before = agent.memory.get()  # Memory managed by main Agent class
+        self.assertEqual(len(main_memory_before), 2)
+
+        # Switch to fallback agent (this should clear the fallback agent instance)
+        agent._switch_agent_config()
+        self.assertEqual(agent.agent_config_type, AgentConfigType.FALLBACK)
+
+        # Access fallback agent (should be recreated with current memory)
+        fallback_memory = agent.memory.get()  # Memory managed by main Agent class
+
+        # Verify fallback agent has the same memory content
+        self.assertEqual(len(fallback_memory), 2)
+        self.assertEqual(fallback_memory[0].content, "Initial question")
+        self.assertEqual(fallback_memory[1].content, "Initial response")
+
+        # Add more memory while using fallback agent
+        additional_messages = [
+            ChatMessage(role=MessageRole.USER, content="Fallback question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Fallback response"),
+        ]
+        agent.memory.put_messages(additional_messages)
+
+        # Switch back to main agent (this should clear the main agent instance)
+        agent._switch_agent_config()
+        self.assertEqual(agent.agent_config_type, AgentConfigType.DEFAULT)
+
+        # Verify recreated main agent now has all the memory including what was added during fallback
+        main_memory_after = agent.memory.get()  # Memory managed by main Agent class
+        self.assertEqual(len(main_memory_after), 4)
+        self.assertEqual(main_memory_after[2].content, "Fallback question")
+        self.assertEqual(main_memory_after[3].content, "Fallback response")
+
+    def test_memory_sync_on_clear_memory(self):
+        """Test that memory clearing resets agent instances for consistency"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Add memory
+        test_messages = [
+            ChatMessage(role=MessageRole.USER, content="Test question"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Test response"),
+        ]
+        agent.memory.put_messages(test_messages)
+
+        # Verify memory exists
+        # Memory is managed by the main Agent class
+        self.assertEqual(len(agent.memory.get()), 2)
+        self.assertEqual(len(agent.memory.get()), 2)  # Both access same memory
+
+        # Clear memory (should reset agent instances)
+        agent.clear_memory()
+
+        # Verify core memory is cleared
+        self.assertEqual(len(agent.memory.get()), 0)
+
+        # Verify agent instances were reset (None)
+        self.assertIsNone(agent._agent)
+        self.assertIsNone(agent._fallback_agent)
+
+        # Verify new agents have cleared memory
+        # Memory is managed by the main Agent class
+        self.assertEqual(len(agent.memory.get()), 0)
+        self.assertEqual(len(agent.memory.get()), 0)  # Both access same memory
+
+    def test_memory_consistency_after_serialization(self):
+        """Test that memory consistency is maintained after serialization/deserialization"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Add memory and load both agents
+        test_messages = [
+            ChatMessage(role=MessageRole.USER, content="Serialization test"),
+            ChatMessage(role=MessageRole.ASSISTANT, content="Serialization response"),
+        ]
+        agent.memory.put_messages(test_messages)
+
+        # Access both agents
+        _ = agent.agent
+        _ = agent.fallback_agent
+
+        # Serialize and deserialize
+        serialized_data = agent.dumps()
+        restored_agent = Agent.loads(serialized_data)
+
+        # Verify memory is preserved and consistent
+        self.assertEqual(restored_agent.session_id, self.session_id)
+        self.assertEqual(len(restored_agent.memory.get()), 2)
+
+        # Verify memory consistency
+        # Individual agent instances don't have .memory attribute - memory is managed by main Agent class
+        # Both agent instances should use the same memory from the main Agent
+
+        main_memory = restored_agent.memory.get()
+        fallback_memory = restored_agent.memory.get()  # Both access same memory
+
+        self.assertEqual(len(main_memory), 2)
+        self.assertEqual(len(fallback_memory), 2)
+        self.assertEqual(main_memory[0].content, "Serialization test")
+        self.assertEqual(fallback_memory[0].content, "Serialization test")
+
+    def test_session_id_consistency_across_agents(self):
+        """Test that session_id is consistent between main and fallback agents"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Verify main agent session_id consistency
+        self.assertEqual(agent.session_id, self.session_id)
+        self.assertEqual(agent.memory.session_id, self.session_id)
+
+        # Verify session_id consistency across all agents
+        # Memory is managed by the main Agent class
+        self.assertEqual(agent.memory.session_id, self.session_id)
+        self.assertEqual(
+            agent.memory.session_id, self.session_id
+        )  # Both access same memory
+
+    def test_agent_recreation_on_switch(self):
+        """Test that agents are properly recreated when switching configurations"""
+        agent = Agent(
+            tools=self.tools,
+            topic=self.topic,
+            custom_instructions=self.custom_instructions,
+            agent_config=self.main_config,
+            fallback_agent_config=self.fallback_config,
+            session_id=self.session_id,
+        )
+
+        # Load main agent
+        original_main_agent = agent.agent
+        self.assertIsNotNone(original_main_agent)
+
+        # Load fallback agent
+        original_fallback_agent = agent.fallback_agent
+        self.assertIsNotNone(original_fallback_agent)
+
+        # Switch to fallback - should clear the fallback agent instance
+        agent._switch_agent_config()
+        self.assertEqual(agent.agent_config_type, AgentConfigType.FALLBACK)
+        self.assertIsNone(agent._fallback_agent)  # Should be cleared
+
+        # Access fallback agent again - should be a new instance
+        new_fallback_agent = agent.fallback_agent
+        self.assertIsNot(new_fallback_agent, original_fallback_agent)
+
+        # Switch back to main - should clear the main agent instance
+        agent._switch_agent_config()
+        self.assertEqual(agent.agent_config_type, AgentConfigType.DEFAULT)
+        self.assertIsNone(agent._agent)  # Should be cleared
+
+        # Access main agent again - should be a new instance
+        new_main_agent = agent.agent
+        self.assertIsNot(new_main_agent, original_main_agent)
+
+
+if __name__ == "__main__":
+    unittest.main()