agent-framework-devui 1.0.0b251001__py3-none-any.whl → 1.0.0b251016__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
 
-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,181 +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
-
-                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,
-                }
-
-                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.
 
@@ -339,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")
@@ -372,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.
 
@@ -388,34 +220,51 @@ class AgentFrameworkExecutor:
             # 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
 
-            # 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)
 
-                    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 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:
+                raise ValueError("Agent must implement either run() or run_stream() method")
 
         except Exception as e:
             logger.error(f"Error in agent execution: {e}")
@@ -437,8 +286,8 @@ class AgentFrameworkExecutor:
         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
+            if request.extra_body and isinstance(request.extra_body, dict) and request.extra_body.get("input_data"):
+                input_data = request.extra_body.get("input_data")  # type: ignore
                 logger.debug(f"Using structured input_data from extra_body: {type(input_data)}")
             else:
                 input_data = request.input
@@ -465,6 +314,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])
 
@@ -494,6 +346,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
@@ -579,6 +434,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.)
 
@@ -638,6 +527,37 @@ class AgentFrameworkExecutor:
             logger.warning(f"Error parsing workflow input: {e}")
             return raw_input
 
+    def _get_start_executor_message_types(self, workflow: Any) -> tuple[Any | None, list[Any]]:
+        """Return start executor and its declared input types."""
+        try:
+            start_executor = workflow.get_start_executor()
+        except Exception as exc:  # pragma: no cover - defensive logging path
+            logger.debug(f"Unable to access workflow start executor: {exc}")
+            return None, []
+
+        if not start_executor:
+            return None, []
+
+        message_types: list[Any] = []
+
+        try:
+            input_types = getattr(start_executor, "input_types", None)
+        except Exception as exc:  # pragma: no cover - defensive logging path
+            logger.debug(f"Failed to read executor input_types: {exc}")
+        else:
+            if input_types:
+                message_types = list(input_types)
+
+        if not message_types and hasattr(start_executor, "_handlers"):
+            try:
+                handlers = start_executor._handlers
+                if isinstance(handlers, dict):
+                    message_types = list(handlers.keys())
+            except Exception as exc:  # pragma: no cover - defensive logging path
+                logger.debug(f"Failed to read executor handlers: {exc}")
+
+        return start_executor, message_types
+
     def _parse_structured_workflow_input(self, workflow: Any, input_data: dict[str, Any]) -> Any:
         """Parse structured input data for workflow execution.
 
@@ -649,59 +569,32 @@ class AgentFrameworkExecutor:
             Parsed input for workflow
         """
         try:
+            from ._utils import parse_input_for_type
+
             # Get the start executor and its input type
-            start_executor = workflow.get_start_executor()
-            if not start_executor or not hasattr(start_executor, "_handlers"):
+            start_executor, message_types = self._get_start_executor_message_types(workflow)
+            if not start_executor:
                 logger.debug("Cannot determine input type for workflow - using raw dict")
                 return input_data
 
-            message_types = list(start_executor._handlers.keys())
             if not message_types:
                 logger.debug("No message types found for start executor - using raw dict")
                 return input_data
 
             # Get the first (primary) input type
-            input_type = message_types[0]
+            from ._utils import select_primary_input_type
 
-            # If input type is dict, return as-is
-            if input_type is dict:
+            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
 
-            # Handle primitive types
-            if input_type in (str, int, float, bool):
-                try:
-                    if isinstance(input_data, input_type):
-                        return input_data
-                    if "input" in input_data:
-                        return input_type(input_data["input"])
-                    if len(input_data) == 1:
-                        value = next(iter(input_data.values()))
-                        return input_type(value)
-                    return input_data
-                except (ValueError, TypeError) as e:
-                    logger.warning(f"Failed to convert input to {input_type}: {e}")
-                    return input_data
-
-            # If it's a Pydantic model, validate and create instance
-            if hasattr(input_type, "model_validate"):
-                try:
-                    return input_type.model_validate(input_data)
-                except Exception as e:
-                    logger.warning(f"Failed to validate input as {input_type}: {e}")
-                    return input_data
-
-            # If it's a dataclass or other type with annotations
-            elif hasattr(input_type, "__annotations__"):
-                try:
-                    return input_type(**input_data)
-                except Exception as e:
-                    logger.warning(f"Failed to create {input_type} from input data: {e}")
-                    return input_data
+            # Use consolidated parsing logic from _utils
+            return parse_input_for_type(input_data, input_type)
 
         except Exception as e:
             logger.warning(f"Error parsing structured workflow input: {e}")
-
-        return input_data
+            return input_data
 
     def _parse_raw_workflow_input(self, workflow: Any, raw_input: str) -> Any:
         """Parse raw input string based on workflow's expected input type.
@@ -714,57 +607,29 @@ class AgentFrameworkExecutor:
             Parsed input for workflow
         """
         try:
+            from ._utils import parse_input_for_type
+
             # Get the start executor and its input type
-            start_executor = workflow.get_start_executor()
-            if not start_executor or not hasattr(start_executor, "_handlers"):
+            start_executor, message_types = self._get_start_executor_message_types(workflow)
+            if not start_executor:
                 logger.debug("Cannot determine input type for workflow - using raw string")
                 return raw_input
 
-            message_types = list(start_executor._handlers.keys())
             if not message_types:
                 logger.debug("No message types found for start executor - using raw string")
                 return raw_input
 
             # Get the first (primary) input type
-            input_type = message_types[0]
+            from ._utils import select_primary_input_type
 
-            # If input type is str, return as-is
-            if input_type is str:
+            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
 
-            # If it's a Pydantic model, try to parse JSON
-            if hasattr(input_type, "model_validate_json"):
-                try:
-                    # First try to parse as JSON
-                    if raw_input.strip().startswith("{"):
-                        return input_type.model_validate_json(raw_input)
-
-                    # Try common field names
-                    common_fields = ["message", "text", "input", "data", "content"]
-                    for field in common_fields:
-                        try:
-                            return input_type(**{field: raw_input})
-                        except Exception as e:
-                            logger.debug(f"Failed to parse input using field '{field}': {e}")
-                            continue
-
-                    # Last resort: try default constructor
-                    return input_type()
-
-                except Exception as e:
-                    logger.debug(f"Failed to parse input as {input_type}: {e}")
-
-            # If it's a dataclass, try JSON parsing
-            elif hasattr(input_type, "__annotations__"):
-                try:
-                    if raw_input.strip().startswith("{"):
-                        parsed = json.loads(raw_input)
-                        return input_type(**parsed)
-                except Exception as e:
-                    logger.debug(f"Failed to parse input as {input_type}: {e}")
+            # Use consolidated parsing logic from _utils
+            return parse_input_for_type(raw_input, input_type)
 
         except Exception as e:
-            logger.debug(f"Error determining workflow input type: {e}")
-
-        # Fallback: return raw string
-        return raw_input
+            logger.debug(f"Error parsing workflow input: {e}")
+            return raw_input