vectara-agentic 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

tests/test_vhc.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -10,6 +11,7 @@ from vectara_agentic.tools import ToolsFactory
 from vectara_agentic.types import ModelProvider
 
 import nest_asyncio
+
 nest_asyncio.apply()
 
 statements = [
@@ -20,6 +22,8 @@ statements = [
     "Chocolate is the best ice cream flavor.",
 ]
 st_inx = 0
+
+
 def get_statement() -> str:
     "Generate next statement"
     global st_inx
@@ -34,7 +38,8 @@ fc_config = AgentConfig(
     tool_llm_provider=ModelProvider.OPENAI,
 )
 
-vectara_api_key = 'zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA'
+vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+
 
 class TestVHC(unittest.TestCase):
 
@@ -59,7 +64,7 @@ class TestVHC(unittest.TestCase):
         vhc_corrections = vhc_res.get("corrections", [])
         self.assertTrue(
             len(vhc_corrections) >= 0 and len(vhc_corrections) <= 2,
-            "Corrections should be between 0 and 2"
+            "Corrections should be between 0 and 2",
         )
 
 

tests/test_workflow.py

@@ -1,5 +1,6 @@
 # Suppress external dependency warnings before any other imports
 import warnings
+
 warnings.simplefilter("ignore", DeprecationWarning)
 
 import unittest
@@ -7,9 +8,13 @@ import unittest
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.tools import ToolsFactory
-from vectara_agentic.sub_query_workflow import SubQuestionQueryWorkflow, SequentialSubQuestionsWorkflow
+from vectara_agentic.sub_query_workflow import (
+    SubQuestionQueryWorkflow,
+    SequentialSubQuestionsWorkflow,
+)
 from conftest import mult, add, STANDARD_TEST_TOPIC, WORKFLOW_TEST_INSTRUCTIONS
 
+
 class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
 
     async def test_sub_query_workflow(self):
@@ -18,8 +23,8 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
             tools=tools,
             topic=STANDARD_TEST_TOPIC,
             custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
-            agent_config = AgentConfig(),
-            workflow_cls = SubQuestionQueryWorkflow,
+            agent_config=AgentConfig(),
+            workflow_cls=SubQuestionQueryWorkflow,
         )
 
         inputs = SubQuestionQueryWorkflow.InputsModel(
@@ -41,8 +46,8 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
             tools=tools,
             topic=STANDARD_TEST_TOPIC,
             custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
-            agent_config = AgentConfig(),
-            workflow_cls = SequentialSubQuestionsWorkflow,
+            agent_config=AgentConfig(),
+            workflow_cls=SequentialSubQuestionsWorkflow,
         )
 
         inputs = SequentialSubQuestionsWorkflow.InputsModel(
@@ -51,6 +56,7 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
         res = await agent.run(inputs=inputs, verbose=True)
         self.assertIn("22", res.response)
 
+
 class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
 
     async def test_workflow_failure_sub_question(self):
@@ -59,9 +65,9 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
             tools=tools,
             topic=STANDARD_TEST_TOPIC,
             custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
-            agent_config = AgentConfig(),
-            workflow_cls = SubQuestionQueryWorkflow,
-            workflow_timeout = 1
+            agent_config=AgentConfig(),
+            workflow_cls=SubQuestionQueryWorkflow,
+            workflow_timeout=1,
         )
 
         inputs = SubQuestionQueryWorkflow.InputsModel(
@@ -76,9 +82,9 @@ class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
             tools=tools,
             topic=STANDARD_TEST_TOPIC,
             custom_instructions=WORKFLOW_TEST_INSTRUCTIONS,
-            agent_config = AgentConfig(),
-            workflow_cls = SequentialSubQuestionsWorkflow,
-            workflow_timeout = 1
+            agent_config=AgentConfig(),
+            workflow_cls=SequentialSubQuestionsWorkflow,
+            workflow_timeout=1,
         )
 
         inputs = SequentialSubQuestionsWorkflow.InputsModel(

vectara_agentic/_callback.py

@@ -38,6 +38,46 @@ def wrap_callback_fn(callback):
     return new_callback
 
 
+def _extract_content_from_response(response) -> str:
+    """
+    Extract text content from various LLM response formats.
+
+    Handles different provider response objects and extracts the text content consistently.
+
+    Args:
+        response: Response object from LLM provider
+
+    Returns:
+        str: Extracted text content
+    """
+    # Handle case where response is a string
+    if isinstance(response, str):
+        return response
+
+    # Handle ChatMessage objects with blocks (Anthropic, etc.)
+    if hasattr(response, "blocks") and response.blocks:
+        text_parts = []
+        for block in response.blocks:
+            if hasattr(block, "text"):
+                text_parts.append(block.text)
+        return "".join(text_parts)
+
+    # Handle responses with content attribute
+    if hasattr(response, "content"):
+        return str(response.content)
+
+    # Handle responses with message attribute that has content
+    if hasattr(response, "message") and hasattr(response.message, "content"):
+        return str(response.message.content)
+
+    # Handle delta attribute for streaming responses
+    if hasattr(response, "delta"):
+        return str(response.delta)
+
+    # Fallback to string conversion
+    return str(response)
+
+
 class AgentCallbackHandler(BaseCallbackHandler):
     """
     Callback handler to track agent status
@@ -151,26 +191,36 @@ class AgentCallbackHandler(BaseCallbackHandler):
     def _handle_event(
         self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
     ) -> None:
-        if event_type == CBEventType.LLM:
-            self._handle_llm(payload, event_id)
-        elif event_type == CBEventType.FUNCTION_CALL:
-            self._handle_function_call(payload, event_id)
-        elif event_type == CBEventType.AGENT_STEP:
-            self._handle_agent_step(payload, event_id)
-        else:
-            pass
+        try:
+            if event_type == CBEventType.LLM:
+                self._handle_llm(payload, event_id)
+            elif event_type == CBEventType.FUNCTION_CALL:
+                self._handle_function_call(payload, event_id)
+            elif event_type == CBEventType.AGENT_STEP:
+                self._handle_agent_step(payload, event_id)
+            else:
+                pass
+        except Exception as e:
+            logging.error(f"Exception in callback handler: {e}")
+            logging.error(f"Traceback: {traceback.format_exc()}")
+            # Continue execution to prevent callback failures from breaking the agent
 
     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, event_id)
-        elif event_type == CBEventType.FUNCTION_CALL:
-            await self._ahandle_function_call(payload, event_id)
-        elif event_type == CBEventType.AGENT_STEP:
-            await self._ahandle_agent_step(payload, event_id)
-        else:
-            pass
+        try:
+            if event_type == CBEventType.LLM:
+                await self._ahandle_llm(payload, event_id)
+            elif event_type == CBEventType.FUNCTION_CALL:
+                await self._ahandle_function_call(payload, event_id)
+            elif event_type == CBEventType.AGENT_STEP:
+                await self._ahandle_agent_step(payload, event_id)
+            else:
+                pass
+        except Exception as e:
+            logging.error(f"Exception in async callback handler: {e}")
+            logging.error(f"Traceback: {traceback.format_exc()}")
+            # Continue execution to prevent callback failures from breaking the agent
 
     # Synchronous handlers
     def _handle_llm(
@@ -182,17 +232,21 @@ class AgentCallbackHandler(BaseCallbackHandler):
             response = payload.get(EventPayload.RESPONSE)
             if response and str(response) not in ["None", "assistant: None"]:
                 if self.fn:
+                    # Convert response to consistent dict format
+                    content = _extract_content_from_response(response)
                     self.fn(
                         status_type=AgentStatusType.AGENT_UPDATE,
-                        msg=response,
+                        msg={"content": content},
                         event_id=event_id,
                     )
         elif EventPayload.PROMPT in payload:
             prompt = payload.get(EventPayload.PROMPT)
             if self.fn:
+                # Convert prompt to consistent dict format
+                content = str(prompt) if prompt else ""
                 self.fn(
                     status_type=AgentStatusType.AGENT_UPDATE,
-                    msg=prompt,
+                    msg={"content": content},
                     event_id=event_id,
                 )
         else:
@@ -253,24 +307,28 @@ class AgentCallbackHandler(BaseCallbackHandler):
             response = payload.get(EventPayload.RESPONSE)
             if response and str(response) not in ["None", "assistant: None"]:
                 if self.fn:
+                    # Convert response to consistent dict format
+                    content = _extract_content_from_response(response)
                     if inspect.iscoroutinefunction(self.fn):
                         await self.fn(
                             status_type=AgentStatusType.AGENT_UPDATE,
-                            msg=response,
+                            msg={"content": content},
                             event_id=event_id,
                         )
                     else:
                         self.fn(
                             status_type=AgentStatusType.AGENT_UPDATE,
-                            msg=response,
+                            msg={"content": content},
                             event_id=event_id,
                         )
         elif EventPayload.PROMPT in payload:
             prompt = payload.get(EventPayload.PROMPT)
             if self.fn:
+                # Convert prompt to consistent dict format
+                content = str(prompt) if prompt else ""
                 self.fn(
                     status_type=AgentStatusType.AGENT_UPDATE,
-                    msg=prompt,
+                    msg={"content": content},
                     event_id=event_id,
                 )
 

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.4.2"
+__version__ = "0.4.3"

vectara_agentic/agent.py

@@ -22,8 +22,8 @@ from dotenv import load_dotenv
 # Runtime imports for components used at module level
 from llama_index.core.llms import MessageRole, ChatMessage
 from llama_index.core.callbacks import CallbackManager
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.storage.chat_store import SimpleChatStore
+from llama_index.core.memory import Memory
+
 
 # Heavy llama_index imports moved to TYPE_CHECKING for lazy loading
 if TYPE_CHECKING:
@@ -53,6 +53,7 @@ from .agent_config import AgentConfig
 # Import utilities from agent core modules
 from .agent_core.streaming import (
     FunctionCallingStreamHandler,
+    ReActStreamHandler,
     execute_post_stream_processing,
 )
 from .agent_core.factory import create_agent_from_config, create_agent_from_corpus
@@ -168,11 +169,8 @@ class Agent:
             or f"{topic}:{date.today().isoformat()}"
         )
 
-        chat_store = SimpleChatStore()
-        self.memory = ChatMemoryBuffer.from_defaults(
-            chat_store=chat_store,
-            chat_store_key=self.session_id,
-            token_limit=65536
+        self.memory = Memory.from_defaults(
+            session_id=self.session_id, token_limit=65536
         )
         if chat_history:
             msgs = []
@@ -491,6 +489,14 @@ class Agent:
             # Clear the main agent so it gets recreated with current memory
             self._agent = None
 
+    def _reset_agent_state(self) -> None:
+        """
+        Reset agent state to recover from workflow runtime errors.
+        Clears both agent instances to force recreation with fresh state.
+        """
+        self._agent = None
+        self._fallback_agent = None
+
     def report(self, detailed: bool = False) -> None:
         """
         Get a report from the agent.
@@ -546,11 +552,14 @@ class Agent:
             AgentResponse: The response from the agent.
         """
         try:
-            _ = asyncio.get_running_loop()
-        except RuntimeError:
+            loop = asyncio.get_running_loop()
+            if hasattr(loop, "_nest_level"):
+                return asyncio.run(self.achat(prompt))
+        except (RuntimeError, ImportError):
+            # No running loop or nest_asyncio not available
             return asyncio.run(self.achat(prompt))
 
-        # We are inside a running loop (Jupyter, uvicorn, etc.)
+        # We are inside a running loop without nest_asyncio
         raise RuntimeError(
             "Use `await agent.achat(...)` inside an event loop (e.g. Jupyter)."
         )
@@ -565,8 +574,8 @@ class Agent:
         Returns:
             AgentResponse: The response from the agent.
         """
-        if not prompt:
-            return AgentResponse(response="")
+        if not prompt or not prompt.strip():
+            return AgentResponse(response="Please provide a valid prompt.")
 
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
@@ -593,14 +602,12 @@ class Agent:
 
                     # Listen to workflow events if progress callback is set
                     if self.agent_progress_callback:
-                        # Create event tracker for consistent event ID generation
-                        from .agent_core.streaming import ToolEventTracker
-
-                        event_tracker = ToolEventTracker()
+                        # Import the event ID utility function
+                        from .agent_core.streaming import get_event_id
 
                         async for event in handler.stream_events():
                             # Use consistent event ID tracking to ensure tool calls and outputs are paired
-                            event_id = event_tracker.get_event_id(event)
+                            event_id = get_event_id(event)
 
                             # Handle different types of workflow events using same logic as FunctionCallingStreamHandler
                             from llama_index.core.agent.workflow import (
@@ -831,6 +838,27 @@ class Agent:
                         base=streaming_adapter, metadata=user_meta
                     )
 
+                # Deal with ReAct agent type
+                elif self._get_current_agent_type() == AgentType.REACT:
+                    from llama_index.core.workflow import Context
+
+                    # Create context and pass memory to the workflow agent
+                    ctx = Context(current_agent)
+
+                    handler = current_agent.run(
+                        user_msg=prompt, memory=self.memory, ctx=ctx
+                    )
+
+                    # Create a streaming adapter for ReAct with event handling
+                    react_stream_handler = ReActStreamHandler(self, handler, prompt)
+                    streaming_adapter = react_stream_handler.create_streaming_response(
+                        user_meta
+                    )
+
+                    return AgentStreamingResponse(
+                        base=streaming_adapter, metadata=user_meta
+                    )
+
                 #
                 # For other agent types, use the standard async chat method
                 #
@@ -870,16 +898,20 @@ class Agent:
     def _add_tool_output(self, tool_name: str, content: str):
         """Add a tool output to the current collection for VHC."""
         tool_output = {
-            'status_type': 'TOOL_OUTPUT',
-            'content': content,
-            'tool_name': tool_name
+            "status_type": "TOOL_OUTPUT",
+            "content": content,
+            "tool_name": tool_name,
         }
         self._current_tool_outputs.append(tool_output)
-        logging.info(f"🔧 [TOOL_STORAGE] Added tool output from '{tool_name}': {len(content)} chars")
+        logging.info(
+            f"🔧 [TOOL_STORAGE] Added tool output from '{tool_name}': {len(content)} chars"
+        )
 
     def _get_stored_tool_outputs(self) -> List[dict]:
         """Get the stored tool outputs from the current query."""
-        logging.info(f"🔧 [TOOL_STORAGE] Retrieved {len(self._current_tool_outputs)} stored tool outputs")
+        logging.info(
+            f"🔧 [TOOL_STORAGE] Retrieved {len(self._current_tool_outputs)} stored tool outputs"
+        )
         return self._current_tool_outputs.copy()
 
     async def acompute_vhc(self) -> Dict[str, Any]:
@@ -926,7 +958,9 @@ class Agent:
         )
 
         if not last_response:
-            logging.info("🔍 [VHC_AGENT] Returning early - no last assistant response found")
+            logging.info(
+                "🔍 [VHC_AGENT] Returning early - no last assistant response found"
+            )
             return {"corrected_text": None, "corrections": []}
 
         # Update stored response for caching
@@ -944,7 +978,9 @@ class Agent:
             f"🔍 [VHC_AGENT] acompute_vhc called with vectara_api_key={'set' if self.vectara_api_key else 'None'}"
         )
         if not self.vectara_api_key:
-            logging.info("🔍 [VHC_AGENT] No vectara_api_key - returning early with None")
+            logging.info(
+                "🔍 [VHC_AGENT] No vectara_api_key - returning early with None"
+            )
             return {"corrected_text": None, "corrections": []}
 
         # Compute VHC using existing library function
@@ -953,7 +989,9 @@ class Agent:
         try:
             # Use stored tool outputs from current query
             stored_tool_outputs = self._get_stored_tool_outputs()
-            logging.info(f"🔧 [VHC_AGENT] Using {len(stored_tool_outputs)} stored tool outputs for VHC")
+            logging.info(
+                f"🔧 [VHC_AGENT] Using {len(stored_tool_outputs)} stored tool outputs for VHC"
+            )
 
             corrected_text, corrections = analyze_hallucinations(
                 query=self._last_query,
@@ -1111,9 +1149,9 @@ class Agent:
         """Clean up resources used by the agent."""
         from ._observability import shutdown_observer
 
-        if hasattr(self, 'agent') and hasattr(self.agent, '_llm'):
+        if hasattr(self, "agent") and hasattr(self.agent, "_llm"):
             llm = self.agent._llm
-            if hasattr(llm, 'client') and hasattr(llm.client, 'close'):
+            if hasattr(llm, "client") and hasattr(llm.client, "close"):
                 try:
                     if asyncio.iscoroutinefunction(llm.client.close):
                         asyncio.run(llm.client.close())

vectara_agentic/agent_core/serialization.py

@@ -13,8 +13,7 @@ from typing import Dict, Any, List, Optional, Callable
 
 import cloudpickle as pickle
 from pydantic import Field, create_model, BaseModel
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.storage.chat_store import SimpleChatStore
+from llama_index.core.memory import Memory
 from llama_index.core.llms import ChatMessage
 from llama_index.core.tools import FunctionTool
 
@@ -23,8 +22,7 @@ from ..tools import VectaraTool
 from ..types import ToolType
 from .utils.schemas import get_field_type
 
-
-def restore_memory_from_dict(data: Dict[str, Any], session_id: str, token_limit: int = 65536) -> ChatMemoryBuffer:
+def restore_memory_from_dict(data: Dict[str, Any], session_id: str, token_limit: int = 65536) -> Memory:
     """
     Restore agent memory from serialized dictionary data.
 
@@ -36,12 +34,10 @@ def restore_memory_from_dict(data: Dict[str, Any], session_id: str, token_limit:
         token_limit: Token limit for the memory instance
 
     Returns:
-        ChatMemoryBuffer: Restored memory instance
+        Memory: Restored memory instance
     """
-    chat_store = SimpleChatStore()
-    mem = ChatMemoryBuffer.from_defaults(
-        chat_store=chat_store,
-        chat_store_key=session_id,
+    mem = Memory.from_defaults(
+        session_id=session_id,
         token_limit=token_limit
     )