agent-framework-devui 1.0.0b251007__py3-none-any.whl → 1.0.0b251028__py3-none-any.whl

agent_framework_devui/_executor.py

@@ -5,12 +5,12 @@
 import json
 import logging
 import os
-import uuid
 from collections.abc import AsyncGenerator
-from typing import Any, get_origin
+from typing import Any
 
-from agent_framework import AgentThread
+from agent_framework import AgentProtocol
 
+from ._conversations import ConversationStore, InMemoryConversationStore
 from ._discovery import EntityDiscovery
 from ._mapper import MessageMapper
 from ._tracing import capture_traces
@@ -29,21 +29,26 @@ class EntityNotFoundError(Exception):
 class AgentFrameworkExecutor:
     """Executor for Agent Framework entities - agents and workflows."""
 
-    def __init__(self, entity_discovery: EntityDiscovery, message_mapper: MessageMapper):
+    def __init__(
+        self,
+        entity_discovery: EntityDiscovery,
+        message_mapper: MessageMapper,
+        conversation_store: ConversationStore | None = None,
+    ):
         """Initialize Agent Framework executor.
 
         Args:
             entity_discovery: Entity discovery instance
             message_mapper: Message mapper instance
+            conversation_store: Optional conversation store (defaults to in-memory)
         """
         self.entity_discovery = entity_discovery
         self.message_mapper = message_mapper
         self._setup_tracing_provider()
         self._setup_agent_framework_tracing()
 
-        # Minimal thread storage - no metadata needed
-        self.thread_storage: dict[str, AgentThread] = {}
-        self.agent_threads: dict[str, list[str]] = {}  # agent_id -> thread_ids
+        # Use provided conversation store or default to in-memory
+        self.conversation_store = conversation_store or InMemoryConversationStore()
 
     def _setup_tracing_provider(self) -> None:
         """Set up our own TracerProvider so we can add processors."""
@@ -83,199 +88,6 @@ class AgentFrameworkExecutor:
         else:
             logger.debug("ENABLE_OTEL not set, skipping observability setup")
 
-    # Thread Management Methods
-    def create_thread(self, agent_id: str) -> str:
-        """Create new thread for agent."""
-        thread_id = f"thread_{uuid.uuid4().hex[:8]}"
-        thread = AgentThread()
-
-        self.thread_storage[thread_id] = thread
-
-        if agent_id not in self.agent_threads:
-            self.agent_threads[agent_id] = []
-        self.agent_threads[agent_id].append(thread_id)
-
-        return thread_id
-
-    def get_thread(self, thread_id: str) -> AgentThread | None:
-        """Get AgentThread by ID."""
-        return self.thread_storage.get(thread_id)
-
-    def list_threads_for_agent(self, agent_id: str) -> list[str]:
-        """List thread IDs for agent."""
-        return self.agent_threads.get(agent_id, [])
-
-    def get_agent_for_thread(self, thread_id: str) -> str | None:
-        """Find which agent owns this thread."""
-        for agent_id, thread_ids in self.agent_threads.items():
-            if thread_id in thread_ids:
-                return agent_id
-        return None
-
-    def delete_thread(self, thread_id: str) -> bool:
-        """Delete thread."""
-        if thread_id not in self.thread_storage:
-            return False
-
-        for _agent_id, thread_ids in self.agent_threads.items():
-            if thread_id in thread_ids:
-                thread_ids.remove(thread_id)
-                break
-
-        del self.thread_storage[thread_id]
-        return True
-
-    async def get_thread_messages(self, thread_id: str) -> list[dict[str, Any]]:
-        """Get messages from a thread's message store, preserving all content types for UI display."""
-        thread = self.get_thread(thread_id)
-        if not thread or not thread.message_store:
-            return []
-
-        try:
-            # Get AgentFramework ChatMessage objects from thread
-            af_messages = await thread.message_store.list_messages()
-
-            ui_messages = []
-            for i, af_msg in enumerate(af_messages):
-                # Extract role value (handle enum)
-                role = af_msg.role.value if hasattr(af_msg.role, "value") else str(af_msg.role)
-
-                # Skip tool/function messages - only show user and assistant messages
-                if role not in ["user", "assistant"]:
-                    continue
-
-                # Extract all user-facing content (text, images, files, etc.)
-                display_contents = self._extract_display_contents(af_msg.contents)
-
-                # Skip messages with no displayable content
-                if not display_contents:
-                    continue
-
-                # Extract usage information if present
-                usage_data = None
-                for content in af_msg.contents:
-                    content_type = getattr(content, "type", None)
-                    if content_type == "usage":
-                        details = getattr(content, "details", None)
-                        if details:
-                            usage_data = {
-                                "total_tokens": getattr(details, "total_token_count", 0) or 0,
-                                "prompt_tokens": getattr(details, "input_token_count", 0) or 0,
-                                "completion_tokens": getattr(details, "output_token_count", 0) or 0,
-                            }
-                        break
-
-                ui_message = {
-                    "id": af_msg.message_id or f"restored-{i}",
-                    "role": role,
-                    "contents": display_contents,
-                    "timestamp": __import__("datetime").datetime.now().isoformat(),
-                    "author_name": af_msg.author_name,
-                    "message_id": af_msg.message_id,
-                }
-
-                # Add usage data if available
-                if usage_data:
-                    ui_message["usage"] = usage_data
-
-                ui_messages.append(ui_message)
-
-            logger.info(f"Restored {len(ui_messages)} display messages for thread {thread_id}")
-            return ui_messages
-
-        except Exception as e:
-            logger.error(f"Error getting thread messages: {e}")
-            import traceback
-
-            logger.error(traceback.format_exc())
-            return []
-
-    def _extract_display_contents(self, contents: list[Any]) -> list[dict[str, Any]]:
-        """Extract all user-facing content (text, images, files, etc.) from message contents.
-
-        Filters out internal mechanics like function calls/results while preserving
-        all content types that should be displayed in the UI.
-        """
-        display_contents = []
-
-        for content in contents:
-            content_type = getattr(content, "type", None)
-
-            # Text content
-            if content_type == "text":
-                text = getattr(content, "text", "")
-
-                # Handle double-encoded JSON from user messages
-                if text.startswith('{"role":'):
-                    try:
-                        import json
-
-                        parsed = json.loads(text)
-                        if parsed.get("contents"):
-                            for sub_content in parsed["contents"]:
-                                if sub_content.get("type") == "text":
-                                    display_contents.append({"type": "text", "text": sub_content.get("text", "")})
-                    except Exception:
-                        display_contents.append({"type": "text", "text": text})
-                else:
-                    display_contents.append({"type": "text", "text": text})
-
-            # Data content (images, files, PDFs, etc.)
-            elif content_type == "data":
-                display_contents.append({
-                    "type": "data",
-                    "uri": getattr(content, "uri", ""),
-                    "media_type": getattr(content, "media_type", None),
-                })
-
-            # URI content (external links to images/files)
-            elif content_type == "uri":
-                display_contents.append({
-                    "type": "uri",
-                    "uri": getattr(content, "uri", ""),
-                    "media_type": getattr(content, "media_type", None),
-                })
-
-            # Skip function_call, function_result, and other internal content types
-
-        return display_contents
-
-    async def serialize_thread(self, thread_id: str) -> dict[str, Any] | None:
-        """Serialize thread state for persistence."""
-        thread = self.get_thread(thread_id)
-        if not thread:
-            return None
-
-        try:
-            # Use AgentThread's built-in serialization
-            serialized_state = await thread.serialize()
-
-            # Add our metadata
-            agent_id = self.get_agent_for_thread(thread_id)
-            serialized_state["metadata"] = {"agent_id": agent_id, "thread_id": thread_id}
-
-            return serialized_state
-
-        except Exception as e:
-            logger.error(f"Error serializing thread {thread_id}: {e}")
-            return None
-
-    async def deserialize_thread(self, thread_id: str, agent_id: str, serialized_state: dict[str, Any]) -> bool:
-        """Deserialize thread state from persistence."""
-        try:
-            thread = await AgentThread.deserialize(serialized_state)
-            # Store the restored thread
-            self.thread_storage[thread_id] = thread
-            if agent_id not in self.agent_threads:
-                self.agent_threads[agent_id] = []
-            self.agent_threads[agent_id].append(thread_id)
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error deserializing thread {thread_id}: {e}")
-            return False
-
     async def discover_entities(self) -> list[EntityInfo]:
         """Discover all available entities.
 
@@ -357,9 +169,11 @@ class AgentFrameworkExecutor:
             Raw Agent Framework events and trace events
         """
         try:
-            # Get entity info and object
+            # Get entity info
             entity_info = self.get_entity_info(entity_id)
-            entity_obj = self.entity_discovery.get_entity_object(entity_id)
+
+            # Trigger lazy loading (will return from cache if already loaded)
+            entity_obj = await self.entity_discovery.load_entity(entity_id)
 
             if not entity_obj:
                 raise EntityNotFoundError(f"Entity object for '{entity_id}' not found")
@@ -390,7 +204,7 @@ class AgentFrameworkExecutor:
             yield {"type": "error", "message": str(e), "entity_id": entity_id}
 
     async def _execute_agent(
-        self, agent: Any, request: AgentFrameworkRequest, trace_collector: Any
+        self, agent: AgentProtocol, request: AgentFrameworkRequest, trace_collector: Any
     ) -> AsyncGenerator[Any, None]:
         """Execute Agent Framework agent with trace collection and optional thread support.
 
@@ -403,40 +217,73 @@ class AgentFrameworkExecutor:
             Agent update events and trace events
         """
         try:
+            # Emit agent lifecycle start event
+            from .models._openai_custom import AgentStartedEvent
+
+            yield AgentStartedEvent()
+
             # Convert input to proper ChatMessage or string
             user_message = self._convert_input_to_chat_message(request.input)
 
-            # Get thread if provided in extra_body
+            # Get thread from conversation parameter (OpenAI standard!)
             thread = None
-            if request.extra_body and hasattr(request.extra_body, "thread_id") and request.extra_body.thread_id:
-                thread_id = request.extra_body.thread_id
-                thread = self.get_thread(thread_id)
+            conversation_id = request.get_conversation_id()
+            if conversation_id:
+                thread = self.conversation_store.get_thread(conversation_id)
                 if thread:
-                    logger.debug(f"Using existing thread: {thread_id}")
+                    logger.debug(f"Using existing conversation: {conversation_id}")
                 else:
-                    logger.warning(f"Thread {thread_id} not found, proceeding without thread")
+                    logger.warning(f"Conversation {conversation_id} not found, proceeding without thread")
 
             if isinstance(user_message, str):
                 logger.debug(f"Executing agent with text input: {user_message[:100]}...")
             else:
                 logger.debug(f"Executing agent with multimodal ChatMessage: {type(user_message)}")
+            # Check if agent supports streaming
+            if hasattr(agent, "run_stream") and callable(agent.run_stream):
+                # Use Agent Framework's native streaming with optional thread
+                if thread:
+                    async for update in agent.run_stream(user_message, thread=thread):
+                        for trace_event in trace_collector.get_pending_events():
+                            yield trace_event
+
+                        yield update
+                else:
+                    async for update in agent.run_stream(user_message):
+                        for trace_event in trace_collector.get_pending_events():
+                            yield trace_event
+
+                        yield update
+            elif hasattr(agent, "run") and callable(agent.run):
+                # Non-streaming agent - use run() and yield complete response
+                logger.info("Agent lacks run_stream(), using run() method (non-streaming)")
+                if thread:
+                    response = await agent.run(user_message, thread=thread)
+                else:
+                    response = await agent.run(user_message)
 
-            # Use Agent Framework's native streaming with optional thread
-            if thread:
-                async for update in agent.run_stream(user_message, thread=thread):
-                    for trace_event in trace_collector.get_pending_events():
-                        yield trace_event
+                # Yield trace events before response
+                for trace_event in trace_collector.get_pending_events():
+                    yield trace_event
 
-                    yield update
+                # Yield the complete response (mapper will convert to streaming events)
+                yield response
             else:
-                async for update in agent.run_stream(user_message):
-                    for trace_event in trace_collector.get_pending_events():
-                        yield trace_event
+                raise ValueError("Agent must implement either run() or run_stream() method")
 
-                    yield update
+            # Emit agent lifecycle completion event
+            from .models._openai_custom import AgentCompletedEvent
+
+            yield AgentCompletedEvent()
 
         except Exception as e:
             logger.error(f"Error in agent execution: {e}")
+            # Emit agent lifecycle failure event
+            from .models._openai_custom import AgentFailedEvent
+
+            yield AgentFailedEvent(error=e)
+
+            # Still yield the error for backward compatibility
             yield {"type": "error", "message": f"Agent execution error: {e!s}"}
 
     async def _execute_workflow(
@@ -453,14 +300,9 @@ class AgentFrameworkExecutor:
             Workflow events and trace events
         """
         try:
-            # Get input data - prefer structured data from extra_body
-            input_data: str | list[Any] | dict[str, Any]
-            if request.extra_body and hasattr(request.extra_body, "input_data") and request.extra_body.input_data:
-                input_data = request.extra_body.input_data
-                logger.debug(f"Using structured input_data from extra_body: {type(input_data)}")
-            else:
-                input_data = request.input
-                logger.debug(f"Using input field as fallback: {type(input_data)}")
+            # Get input data directly from request.input field
+            input_data = request.input
+            logger.debug(f"Using input field: {type(input_data)}")
 
             # Parse input based on workflow's expected input type
             parsed_input = await self._parse_workflow_input(workflow, input_data)
@@ -483,6 +325,9 @@ class AgentFrameworkExecutor:
     def _convert_input_to_chat_message(self, input_data: Any) -> Any:
         """Convert OpenAI Responses API input to Agent Framework ChatMessage or string.
 
+        Handles various input formats including text, images, files, and multimodal content.
+        Falls back to string extraction for simple cases.
+
         Args:
             input_data: OpenAI ResponseInputParam (List[ResponseInputItemParam])
 
@@ -512,6 +357,9 @@ class AgentFrameworkExecutor:
     ) -> Any:
         """Convert OpenAI ResponseInputParam to Agent Framework ChatMessage.
 
+        Processes text, images, files, and other content types from OpenAI format
+        to Agent Framework ChatMessage with appropriate content objects.
+
         Args:
             input_items: List of OpenAI ResponseInputItemParam objects (dicts or objects)
             ChatMessage: ChatMessage class for creating chat messages
@@ -597,6 +445,40 @@ class AgentFrameworkExecutor:
                                     elif file_url:
                                         contents.append(DataContent(uri=file_url, media_type=media_type))
 
+                                elif content_type == "function_approval_response":
+                                    # Handle function approval response (DevUI extension)
+                                    try:
+                                        from agent_framework import FunctionApprovalResponseContent, FunctionCallContent
+
+                                        request_id = content_item.get("request_id", "")
+                                        approved = content_item.get("approved", False)
+                                        function_call_data = content_item.get("function_call", {})
+
+                                        # Create FunctionCallContent from the function_call data
+                                        function_call = FunctionCallContent(
+                                            call_id=function_call_data.get("id", ""),
+                                            name=function_call_data.get("name", ""),
+                                            arguments=function_call_data.get("arguments", {}),
+                                        )
+
+                                        # Create FunctionApprovalResponseContent with correct signature
+                                        approval_response = FunctionApprovalResponseContent(
+                                            approved,  # positional argument
+                                            id=request_id,  # keyword argument 'id', NOT 'request_id'
+                                            function_call=function_call,  # FunctionCallContent object
+                                        )
+                                        contents.append(approval_response)
+                                        logger.info(
+                                            f"Added FunctionApprovalResponseContent: id={request_id}, "
+                                            f"approved={approved}, call_id={function_call.call_id}"
+                                        )
+                                    except ImportError:
+                                        logger.warning(
+                                            "FunctionApprovalResponseContent not available in agent_framework"
+                                        )
+                                    except Exception as e:
+                                        logger.error(f"Failed to create FunctionApprovalResponseContent: {e}")
+
             # Handle other OpenAI input item types as needed
             # (tool calls, function results, etc.)
 
@@ -687,23 +569,6 @@ class AgentFrameworkExecutor:
 
         return start_executor, message_types
 
-    def _select_primary_input_type(self, message_types: list[Any]) -> Any | None:
-        """Choose the most user-friendly input type for workflow kick-off."""
-        if not message_types:
-            return None
-
-        preferred = (str, dict)
-
-        for candidate in preferred:
-            for message_type in message_types:
-                if message_type is candidate:
-                    return candidate
-                origin = get_origin(message_type)
-                if origin is candidate:
-                    return candidate
-
-        return message_types[0]
-
     def _parse_structured_workflow_input(self, workflow: Any, input_data: dict[str, Any]) -> Any:
         """Parse structured input data for workflow execution.
 
@@ -728,7 +593,9 @@ class AgentFrameworkExecutor:
                 return input_data
 
             # Get the first (primary) input type
-            input_type = self._select_primary_input_type(message_types)
+            from ._utils import select_primary_input_type
+
+            input_type = select_primary_input_type(message_types)
             if input_type is None:
                 logger.debug("Could not select primary input type for workflow - using raw dict")
                 return input_data
@@ -764,7 +631,9 @@ class AgentFrameworkExecutor:
                 return raw_input
 
             # Get the first (primary) input type
-            input_type = self._select_primary_input_type(message_types)
+            from ._utils import select_primary_input_type
+
+            input_type = select_primary_input_type(message_types)
             if input_type is None:
                 logger.debug("Could not select primary input type for workflow - using raw string")
                 return raw_input