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

agent_framework_devui/_server.py

@@ -85,19 +85,25 @@ class DevServer:
         return self.executor
 
     async def _cleanup_entities(self) -> None:
-        """Cleanup entity resources (close clients, credentials, etc.)."""
+        """Cleanup entity resources (close clients, MCP tools, credentials, etc.)."""
         if not self.executor:
             return
 
         logger.info("Cleaning up entity resources...")
         entities = self.executor.entity_discovery.list_entities()
         closed_count = 0
+        mcp_tools_closed = 0
+        credentials_closed = 0
 
         for entity_info in entities:
             try:
                 entity_obj = self.executor.entity_discovery.get_entity_object(entity_info.id)
+
+                # Close chat clients and their credentials
                 if entity_obj and hasattr(entity_obj, "chat_client"):
                     client = entity_obj.chat_client
+
+                    # Close the chat client itself
                     if hasattr(client, "close") and callable(client.close):
                         if inspect.iscoroutinefunction(client.close):
                             await client.close()
@@ -105,11 +111,47 @@ class DevServer:
                             client.close()
                         closed_count += 1
                         logger.debug(f"Closed client for entity: {entity_info.id}")
+
+                    # Close credentials attached to chat clients (e.g., AzureCliCredential)
+                    credential_attrs = ["credential", "async_credential", "_credential", "_async_credential"]
+                    for attr in credential_attrs:
+                        if hasattr(client, attr):
+                            cred = getattr(client, attr)
+                            if cred and hasattr(cred, "close") and callable(cred.close):
+                                try:
+                                    if inspect.iscoroutinefunction(cred.close):
+                                        await cred.close()
+                                    else:
+                                        cred.close()
+                                    credentials_closed += 1
+                                    logger.debug(f"Closed credential for entity: {entity_info.id}")
+                                except Exception as e:
+                                    logger.warning(f"Error closing credential for {entity_info.id}: {e}")
+
+                # Close MCP tools (framework tracks them in _local_mcp_tools)
+                if entity_obj and hasattr(entity_obj, "_local_mcp_tools"):
+                    for mcp_tool in entity_obj._local_mcp_tools:
+                        if hasattr(mcp_tool, "close") and callable(mcp_tool.close):
+                            try:
+                                if inspect.iscoroutinefunction(mcp_tool.close):
+                                    await mcp_tool.close()
+                                else:
+                                    mcp_tool.close()
+                                mcp_tools_closed += 1
+                                tool_name = getattr(mcp_tool, "name", "unknown")
+                                logger.debug(f"Closed MCP tool '{tool_name}' for entity: {entity_info.id}")
+                            except Exception as e:
+                                logger.warning(f"Error closing MCP tool for {entity_info.id}: {e}")
+
             except Exception as e:
                 logger.warning(f"Error closing entity {entity_info.id}: {e}")
 
         if closed_count > 0:
             logger.info(f"Closed {closed_count} entity client(s)")
+        if credentials_closed > 0:
+            logger.info(f"Closed {credentials_closed} credential(s)")
+        if mcp_tools_closed > 0:
+            logger.info(f"Closed {mcp_tools_closed} MCP tool(s)")
 
     def create_app(self) -> FastAPI:
         """Create the FastAPI application."""

agent_framework_devui/_utils.py

@@ -6,7 +6,10 @@ import inspect
 import json
 import logging
 from dataclasses import fields, is_dataclass
-from typing import Any, get_args, get_origin
+from types import UnionType
+from typing import Any, Union, get_args, get_origin
+
+from agent_framework import ChatMessage
 
 logger = logging.getLogger(__name__)
 
@@ -110,10 +113,25 @@ def extract_executor_message_types(executor: Any) -> list[Any]:
     return message_types
 
 
+def _contains_chat_message(type_hint: Any) -> bool:
+    """Check whether the provided type hint directly or indirectly references ChatMessage."""
+    if type_hint is ChatMessage:
+        return True
+
+    origin = get_origin(type_hint)
+    if origin in (list, tuple):
+        return any(_contains_chat_message(arg) for arg in get_args(type_hint))
+
+    if origin in (Union, UnionType):
+        return any(_contains_chat_message(arg) for arg in get_args(type_hint))
+
+    return False
+
+
 def select_primary_input_type(message_types: list[Any]) -> Any | None:
     """Choose the most user-friendly input type for workflow inputs.
 
-    Prefers str and dict types for better user experience.
+    Prefers ChatMessage (or containers thereof) and then falls back to primitives.
 
     Args:
         message_types: List of possible message types
@@ -124,6 +142,10 @@ def select_primary_input_type(message_types: list[Any]) -> Any | None:
     if not message_types:
         return None
 
+    for message_type in message_types:
+        if _contains_chat_message(message_type):
+            return ChatMessage
+
     preferred = (str, dict)
 
     for candidate in preferred:

agent_framework_devui/models/__init__.py

@@ -30,6 +30,9 @@ from openai.types.shared import Metadata, ResponsesModel
 from ._discovery_models import DiscoveryResponse, EntityInfo
 from ._openai_custom import (
     AgentFrameworkRequest,
+    CustomResponseOutputItemAddedEvent,
+    CustomResponseOutputItemDoneEvent,
+    ExecutorActionItem,
     OpenAIError,
     ResponseFunctionResultComplete,
     ResponseTraceEvent,
@@ -46,8 +49,11 @@ __all__ = [
     "Conversation",
     "ConversationDeletedResource",
     "ConversationItem",
+    "CustomResponseOutputItemAddedEvent",
+    "CustomResponseOutputItemDoneEvent",
     "DiscoveryResponse",
     "EntityInfo",
+    "ExecutorActionItem",
     "InputTokensDetails",
     "Metadata",
     "OpenAIError",

agent_framework_devui/models/_openai_custom.py

@@ -8,6 +8,7 @@ to support Agent Framework specific features like workflows and traces.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict
@@ -15,6 +16,69 @@ from pydantic import BaseModel, ConfigDict
 # Custom Agent Framework OpenAI event types for structured data
 
 
+# Agent lifecycle events - simple and clear
+class AgentStartedEvent:
+    """Event emitted when an agent starts execution."""
+
+    pass
+
+
+class AgentCompletedEvent:
+    """Event emitted when an agent completes execution successfully."""
+
+    pass
+
+
+@dataclass
+class AgentFailedEvent:
+    """Event emitted when an agent fails during execution."""
+
+    error: Exception | None = None
+
+
+class ExecutorActionItem(BaseModel):
+    """Custom item type for workflow executor actions.
+
+    This is a DevUI-specific extension to represent workflow executors as output items.
+    Since OpenAI's ResponseOutputItemAddedEvent only accepts specific item types,
+    and executor actions are not part of the standard, we need this custom type.
+    """
+
+    type: Literal["executor_action"] = "executor_action"
+    id: str
+    executor_id: str
+    status: Literal["in_progress", "completed", "failed", "cancelled"] = "in_progress"
+    metadata: dict[str, Any] | None = None
+    result: Any | None = None
+    error: dict[str, Any] | None = None
+
+
+class CustomResponseOutputItemAddedEvent(BaseModel):
+    """Custom version of ResponseOutputItemAddedEvent that accepts any item type.
+
+    This allows us to emit executor action items while maintaining the same
+    event structure as OpenAI's standard.
+    """
+
+    type: Literal["response.output_item.added"] = "response.output_item.added"
+    output_index: int
+    sequence_number: int
+    item: dict[str, Any] | ExecutorActionItem | Any  # Flexible item type
+
+
+class CustomResponseOutputItemDoneEvent(BaseModel):
+    """Custom version of ResponseOutputItemDoneEvent that accepts any item type.
+
+    This allows us to emit executor action items while maintaining the same
+    event structure as OpenAI's standard.
+    """
+
+    type: Literal["response.output_item.done"] = "response.output_item.done"
+    output_index: int
+    sequence_number: int
+    item: dict[str, Any] | ExecutorActionItem | Any  # Flexible item type
+
+
 class ResponseWorkflowEventComplete(BaseModel):
     """Complete workflow event data."""
 
@@ -57,6 +121,7 @@ class ResponseFunctionResultComplete(BaseModel):
     item_id: str
     output_index: int = 0
     sequence_number: int
+    timestamp: str | None = None  # Optional timestamp for UI display
 
 
 # Agent Framework extension fields
@@ -64,7 +129,7 @@ class AgentFrameworkExtraBody(BaseModel):
     """Agent Framework specific routing fields for OpenAI requests."""
 
     entity_id: str
-    input_data: dict[str, Any] | None = None
+    # input_data removed - now using standard input field for all data
 
     model_config = ConfigDict(extra="allow")
 
@@ -80,7 +145,7 @@ class AgentFrameworkRequest(BaseModel):
 
     # All OpenAI fields from ResponseCreateParams
     model: str  # Used as entity_id in DevUI!
-    input: str | list[Any]  # ResponseInputParam
+    input: str | list[Any] | dict[str, Any]  # ResponseInputParam + dict for workflow structured input
     stream: bool | None = False
 
     # OpenAI conversation parameter (standard!)