Fix version-agnostic WorkflowHandler implementation

- Research-based solution using official LlamaIndex docs
- Auto-detect .chat() method (0.12.x) vs .run() method (0.14.x)
- Use proper `await handler` pattern for WorkflowHandler (0.14.x)
- Tested locally with 0.12.x - agent returns responses correctly
- Version bumped to 1.0.11

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app/core/agent.py

@@ -820,28 +820,63 @@ class ChatCalAgent:
             print(f"🔍 Debug: Agent type: {type(self.agent)}")
             # Skip tools debug - ReActAgent doesn't expose tools attribute
 
-            # Simplified approach - just call the agent synchronously
-            # LlamaIndex 0.14.2 ReActAgent.run() should work synchronously
+            # Handle both local (0.12.x with .chat) and HuggingFace (0.14.x with .run) versions
             import time
+            import asyncio
             start_time = time.time()
             print(f"🚀 Debug: Starting agent execution at {start_time}")
 
             try:
-                print(f"🔄 Debug: Running agent with max_iterations=15")
-                print("🔍 Debug: Calling agent.run() synchronously")
+                # Check which method is available
+                if hasattr(self.agent, 'chat'):
+                    print("🔍 Debug: Using .chat() method (LlamaIndex 0.12.x)")
+                    result = self.agent.chat(message)
+                    response_content = str(result)
+                    execution_time = time.time() - start_time
+                    print(f"✅ Debug: .chat() completed in {execution_time:.2f} seconds")
+                    return response_content
+
+                elif hasattr(self.agent, 'run'):
+                    print("🔍 Debug: Using .run() method (LlamaIndex 0.14.x) - returns WorkflowHandler")
+
+                    # Use async approach for WorkflowHandler
+                    async def get_workflow_result():
+                        workflow_handler = self.agent.run(user_msg=message, max_iterations=15)
+                        print(f"🔍 Debug: WorkflowHandler type: {type(workflow_handler)}")
+
+                        # Use await handler pattern from docs
+                        print("🔍 Debug: Awaiting final response from WorkflowHandler")
+                        final_response = await workflow_handler
+                        print(f"🔍 Debug: Final response type: {type(final_response)}")
+
+                        # Extract response based on response format
+                        if isinstance(final_response, dict) and "response" in final_response:
+                            return final_response["response"]
+                        elif hasattr(final_response, 'response'):
+                            return str(final_response.response)
+                        else:
+                            return str(final_response)
 
-                # Call agent.chat() directly - ReActAgent uses chat method
-                result = self.agent.chat(message)
+                    # Run async function
+                    try:
+                        # Check if we're already in an event loop
+                        loop = asyncio.get_running_loop()
+                        # If in a loop, use a thread to run new event loop
+                        import concurrent.futures
+                        with concurrent.futures.ThreadPoolExecutor() as executor:
+                            future = executor.submit(lambda: asyncio.run(get_workflow_result()))
+                            response_content = future.result(timeout=60)
+                    except RuntimeError:
+                        # No event loop, can use asyncio.run directly
+                        response_content = asyncio.run(get_workflow_result())
+
+                    execution_time = time.time() - start_time
+                    print(f"✅ Debug: WorkflowHandler completed in {execution_time:.2f} seconds")
+                    return response_content
 
-                execution_time = time.time() - start_time
-                print(f"⏱️ Debug: Agent execution completed in {execution_time:.2f} seconds")
-                print(f"🔍 Debug: Result type: {type(result)}")
-                print(f"🔍 Debug: Result: {str(result)[:200]}...")
-
-                # Convert result to string response
-                response_content = str(result)
-                print(f"✅ Debug: Returning agent result ({len(response_content)} chars)")
-                return response_content
+                else:
+                    print("❌ Debug: Agent has neither .chat() nor .run() method")
+                    return "I'm having trouble with the agent configuration. Please try again."
 
             except Exception as e:
                 execution_time = time.time() - start_time

debug_version.py

@@ -38,6 +38,88 @@ def check_react_agent_api():
     except Exception as e:
         print(f"Error checking ReActAgent API: {e}")
 
+def test_workflow_handler():
+    """Test what WorkflowHandler actually returns and what methods it has."""
+    try:
+        print("\n=== WORKFLOW HANDLER TEST ===")
+
+        # Import what we need
+        from llama_index.core.agent import ReActAgent
+        from llama_index.core.tools import BaseTool, FunctionTool
+        from llama_index.core.llms.mock import MockLLM
+        import inspect
+
+        # Create a simple mock tool
+        def mock_tool(query: str) -> str:
+            """A simple mock tool."""
+            return f"Mock response for: {query}"
+
+        tool = FunctionTool.from_defaults(fn=mock_tool, name="mock_tool")
+
+        # Create a mock LLM
+        llm = MockLLM(max_tokens=100)
+
+        # Create ReActAgent
+        agent = ReActAgent(tools=[tool], llm=llm, verbose=True)
+        print(f"✅ Created ReActAgent successfully")
+
+        # Test the run method
+        print("🔍 Testing agent.run()...")
+        workflow_handler = agent.run(user_msg="Hello test")
+
+        print(f"🔍 WorkflowHandler type: {type(workflow_handler)}")
+        print(f"🔍 WorkflowHandler module: {type(workflow_handler).__module__}")
+
+        # Check WorkflowHandler methods
+        wh_methods = [m for m in dir(workflow_handler) if not m.startswith('_')]
+        print(f"🔍 WorkflowHandler methods: {sorted(wh_methods)}")
+
+        # Check for specific methods we're interested in
+        for method_name in ['result', 'get_result', 'run', '__iter__', '__next__', 'wait', 'done']:
+            if hasattr(workflow_handler, method_name):
+                method = getattr(workflow_handler, method_name)
+                if callable(method):
+                    try:
+                        sig = inspect.signature(method)
+                        is_async = inspect.iscoroutinefunction(method)
+                        print(f"✅ {method_name}: exists, callable, async={is_async}, sig={sig}")
+                    except:
+                        print(f"✅ {method_name}: exists, callable (signature unavailable)")
+                else:
+                    print(f"✅ {method_name}: exists, not callable, value={method}")
+            else:
+                print(f"❌ {method_name}: NOT FOUND")
+
+        # Test iteration
+        print("\n🔍 Testing iteration...")
+        try:
+            step_count = 0
+            for step in workflow_handler:
+                step_count += 1
+                print(f"   Step {step_count}: {type(step)} = {str(step)[:100]}...")
+                if step_count >= 3:  # Limit to avoid infinite loops
+                    break
+            print(f"✅ Iteration completed with {step_count} steps")
+        except Exception as e:
+            print(f"❌ Iteration failed: {e}")
+
+        # Test result() method if it exists
+        print("\n🔍 Testing .result() method...")
+        try:
+            if hasattr(workflow_handler, 'result'):
+                result = workflow_handler.result()
+                print(f"✅ .result() returned: {type(result)} = {str(result)[:100]}...")
+            else:
+                print("❌ No .result() method")
+        except Exception as e:
+            print(f"❌ .result() failed: {e}")
+
+    except Exception as e:
+        print(f"❌ WorkflowHandler test failed: {e}")
+        import traceback
+        traceback.print_exc()
+
 if __name__ == "__main__":
     check_llama_index_version()
-    check_react_agent_api()
+    check_react_agent_api()
+    test_workflow_handler()

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voicecal-ai"
-version = "1.0.9"
+version = "1.0.11"
 description = "A friendly AI chatbot for booking Google Calendar appointments"
 authors = ["Peter <pgits.job@gmail.com>"]