Updates for socket messages from proxy agent

Author: marktayl1

src/backend/v3/callbacks/response_handlers.py

@@ -16,21 +16,6 @@ def agent_response_callback(message: ChatMessageContent, user_id: str = None) ->
 
     # Get agent name to determine handling
     agent_name = message.name or "Unknown Agent"
-
-
-    # Debug information about the message
-    # message_type = type(message).__name__
-    # metadata = getattr(message, 'metadata', {})
-    # # when streaming code - list the coder info first once - 
-    # if 'code' in metadata and metadata['code'] is True:
-    #     if coderagent == False:
-    #         print(f"\n **{agent_name}** [{message_type}]")
-    #         print("-" * (len(agent_name) + len(message_type) + 10))
-    #         coderagent = True
-    #     print(message.content, end='', flush=False)
-    #     return
-    # elif coderagent == True:
-    #     coderagent = False
 
     role = getattr(message, 'role', 'unknown')
 

src/backend/v3/magentic_agents/proxy_agent.py

@@ -6,6 +6,7 @@
 from collections.abc import AsyncIterable
 from typing import AsyncIterator, Optional
 
+import v3.models.messages as agent_messages
 from pydantic import Field
 from semantic_kernel.agents import (  # pylint: disable=no-name-in-module
     AgentResponseItem, AgentThread)
@@ -104,8 +105,6 @@ def __init__(self, user_id: str = None, **kwargs):
         )
         self.instructions = ""
 
-        self.user_id = user_id or current_user_id.get()
-
     def _create_message_content(self, content: str, thread_id: str = None) -> ChatMessageContent:
         """Create a ChatMessageContent with proper metadata."""
         return ChatMessageContent(
@@ -117,18 +116,23 @@ def _create_message_content(self, content: str, thread_id: str = None) -> ChatMe
 
     async def _trigger_response_callbacks(self, message_content: ChatMessageContent):
         """Manually trigger the same response callbacks used by other agents."""
+                # Get current user_id dynamically instead of using stored value
+        current_user = current_user_id.get() or self.user_id or ""
+
         # Trigger the standard agent response callback
-        agent_response_callback(message_content, self.user_id)
+        agent_response_callback(message_content, current_user)
 
     async def _trigger_streaming_callbacks(self, content: str, is_final: bool = False):
         """Manually trigger streaming callbacks for real-time updates."""
+        # Get current user_id dynamically instead of using stored value
+        current_user = current_user_id.get() or self.user_id or ""
         streaming_message = StreamingChatMessageContent(
             role=AuthorRole.ASSISTANT,
             content=content,
             name=self.name,
             choice_index=0
         )
-        await streaming_agent_response_callback(streaming_message, is_final, self.user_id)
+        await streaming_agent_response_callback(streaming_message, is_final, current_user)
 
     async def invoke(self, message: str,*, thread: AgentThread | None = None,**kwargs) -> AsyncIterator[ChatMessageContent]:
         """Ask human user for clarification about the message."""
@@ -142,9 +146,9 @@ async def invoke(self, message: str,*, thread: AgentThread | None = None,**kwarg
         # Send clarification request via response handlers
         clarification_request = f"I need clarification about: {message}"
         clarification_message = self._create_message_content(clarification_request, thread.id)
-        # await self._trigger_response_callbacks(clarification_message)
+        await self._trigger_response_callbacks(clarification_message)
 
-        # Get human input
+        # Get human input - replace this with awaiting a websocket call or API handler when available
         human_response = input("Please provide clarification: ").strip()
 
         if not human_response:
@@ -154,7 +158,6 @@ async def invoke(self, message: str,*, thread: AgentThread | None = None,**kwarg
 
         # Send response via response handlers
         response_message = self._create_message_content(response, thread.id)
-        #await self._trigger_response_callbacks(response_message)
 
         chat_message = response_message
 
@@ -183,7 +186,8 @@ async def invoke_stream(self, messages, thread=None, **kwargs) -> AsyncIterator[
 
         # Send clarification request via streaming callbacks
         clarification_request = f"I need clarification about: {message}"
-        #await self._trigger_streaming_callbacks(clarification_request)
+        self._create_message_content(clarification_request, thread.id)
+        await self._trigger_streaming_callbacks(clarification_request)
 
         # Get human input - replace with websocket call when available
         human_response = input("Please provide clarification: ").strip()
@@ -192,9 +196,6 @@ async def invoke_stream(self, messages, thread=None, **kwargs) -> AsyncIterator[
             human_response = "No additional clarification provided."
 
         response = f"Human clarification: {human_response}"
-        
-        # Send response via streaming callbacks
-        #await self._trigger_streaming_callbacks(response, is_final=True)
 
         chat_message = self._create_message_content(response, thread.id)
 

src/backend/v3/orchestration/human_approval_manager.py

@@ -77,22 +77,34 @@ async def plan(self, magentic_context: MagenticContext) -> Any:
         approval_response = await self._wait_for_user_approval()
 
         if approval_response and approval_response.approved:
-            print("✅ Plan approved - proceeding with execution...")
+            print("Plan approved - proceeding with execution...")
             return plan
         else:
-            print("❌ Plan execution cancelled by user")
-            return ChatMessageContent(
-                role="assistant",
-                content="Plan execution was cancelled by the user."
-            )
+            print("Plan execution cancelled by user")
+            await connection_config.send_status_update_async({
+                "type": "plan_approval_response", 
+                "data": approval_response
+            })
+            raise Exception("Plan execution cancelled by user") 
+            # return ChatMessageContent(
+            #     role="assistant",
+            #     content="Plan execution was cancelled by the user."
+            # )
+            
 
     async def _wait_for_user_approval(self) -> Optional[messages.PlanApprovalResponse]:
         """Wait for user approval response."""
         user_id = current_user_id.get()
-        print(f"🔍 DEBUG: user_id from context = {user_id}")  # <-- PUT BREAKPOINT HERE
-        
-        # Return None to cancel plan (for now, just to test context)
-        return None
+        # Temporarily use console input for approval - will switch to WebSocket or API in future
+        response = input("\nApprove this execution plan? [y/n]: ").strip().lower()
+        if response in ['y', 'yes']:
+            return messages.PlanApprovalResponse(approved=True)
+        elif response in ['n', 'no']:
+            return messages.PlanApprovalResponse(approved=False)
+        else:
+            print("Invalid input. Please enter 'y' for yes or 'n' for no.")
+            return await self._wait_for_user_approval()
+
 
     async def prepare_final_answer(self, magentic_context: MagenticContext) -> ChatMessageContent:
         """