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

agent_framework_devui/_discovery.py

@@ -134,6 +134,52 @@ class EntityDiscovery:
         # Extract tools/executors using Agent Framework specific logic
         tools_list = await self._extract_tools_from_object(entity_object, entity_type)
 
+        # Extract agent-specific fields (for agents only)
+        instructions = None
+        model = None
+        chat_client_type = None
+        context_providers_list = None
+        middleware_list = None
+
+        if entity_type == "agent":
+            # Try to get instructions
+            if hasattr(entity_object, "chat_options") and hasattr(entity_object.chat_options, "instructions"):
+                instructions = entity_object.chat_options.instructions
+
+            # Try to get model - check both chat_options and chat_client
+            if (
+                hasattr(entity_object, "chat_options")
+                and hasattr(entity_object.chat_options, "model_id")
+                and entity_object.chat_options.model_id
+            ):
+                model = entity_object.chat_options.model_id
+            elif hasattr(entity_object, "chat_client") and hasattr(entity_object.chat_client, "model_id"):
+                model = entity_object.chat_client.model_id
+
+            # Try to get chat client type
+            if hasattr(entity_object, "chat_client"):
+                chat_client_type = entity_object.chat_client.__class__.__name__
+
+            # Try to get context providers
+            if (
+                hasattr(entity_object, "context_provider")
+                and entity_object.context_provider
+                and hasattr(entity_object.context_provider, "__class__")
+            ):
+                context_providers_list = [entity_object.context_provider.__class__.__name__]
+
+            # Try to get middleware
+            if hasattr(entity_object, "middleware") and entity_object.middleware:
+                middleware_list = []
+                for m in entity_object.middleware:
+                    # Try multiple ways to get a good name for middleware
+                    if hasattr(m, "__name__"):  # Function or callable
+                        middleware_list.append(m.__name__)
+                    elif hasattr(m, "__class__"):  # Class instance
+                        middleware_list.append(m.__class__.__name__)
+                    else:
+                        middleware_list.append(str(m))
+
         # Create EntityInfo with Agent Framework specifics
         return EntityInfo(
             id=entity_id,
@@ -142,6 +188,11 @@ class EntityDiscovery:
             type=entity_type,
             framework="agent_framework",
             tools=[str(tool) for tool in (tools_list or [])],
+            instructions=instructions,
+            model_id=model,
+            chat_client_type=chat_client_type,
+            context_providers=context_providers_list,
+            middleware=middleware_list,
             executors=tools_list if entity_type == "workflow" else [],
             input_schema={"type": "string"},  # Default schema
             start_executor_id=tools_list[0] if tools_list and entity_type == "workflow" else None,
@@ -446,6 +497,48 @@ class EntityDiscovery:
             if tools:
                 tools_union = [tool for tool in tools]
 
+            # Extract agent-specific fields (for agents only)
+            instructions = None
+            model = None
+            chat_client_type = None
+            context_providers_list = None
+            middleware_list = None
+
+            if obj_type == "agent":
+                # Try to get instructions
+                if hasattr(obj, "chat_options") and hasattr(obj.chat_options, "instructions"):
+                    instructions = obj.chat_options.instructions
+
+                # Try to get model - check both chat_options and chat_client
+                if hasattr(obj, "chat_options") and hasattr(obj.chat_options, "model_id") and obj.chat_options.model_id:
+                    model = obj.chat_options.model_id
+                elif hasattr(obj, "chat_client") and hasattr(obj.chat_client, "model_id"):
+                    model = obj.chat_client.model_id
+
+                # Try to get chat client type
+                if hasattr(obj, "chat_client"):
+                    chat_client_type = obj.chat_client.__class__.__name__
+
+                # Try to get context providers
+                if (
+                    hasattr(obj, "context_provider")
+                    and obj.context_provider
+                    and hasattr(obj.context_provider, "__class__")
+                ):
+                    context_providers_list = [obj.context_provider.__class__.__name__]
+
+                # Try to get middleware
+                if hasattr(obj, "middleware") and obj.middleware:
+                    middleware_list = []
+                    for m in obj.middleware:
+                        # Try multiple ways to get a good name for middleware
+                        if hasattr(m, "__name__"):  # Function or callable
+                            middleware_list.append(m.__name__)
+                        elif hasattr(m, "__class__"):  # Class instance
+                            middleware_list.append(m.__class__.__name__)
+                        else:
+                            middleware_list.append(str(m))
+
             entity_info = EntityInfo(
                 id=entity_id,
                 type=obj_type,
@@ -453,6 +546,11 @@ class EntityDiscovery:
                 framework="agent_framework",
                 description=description,
                 tools=tools_union,
+                instructions=instructions,
+                model_id=model,
+                chat_client_type=chat_client_type,
+                context_providers=context_providers_list,
+                middleware=middleware_list,
                 metadata={
                     "module_path": module_path,
                     "entity_type": obj_type,

agent_framework_devui/_executor.py

@@ -7,7 +7,7 @@ import logging
 import os
 import uuid
 from collections.abc import AsyncGenerator
-from typing import Any
+from typing import Any, get_origin
 
 from agent_framework import AgentThread
 
@@ -151,6 +151,20 @@ class AgentFrameworkExecutor:
                 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,
@@ -160,6 +174,10 @@ class AgentFrameworkExecutor:
                     "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}")
@@ -638,6 +656,54 @@ 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 _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.
 
@@ -649,59 +715,30 @@ 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]
-
-            # If input type is dict, return as-is
-            if input_type is dict:
+            input_type = self._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 +751,27 @@ 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]
-
-            # If input type is str, return as-is
-            if input_type is str:
+            input_type = self._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

agent_framework_devui/_mapper.py

@@ -6,7 +6,6 @@ import json
 import logging
 import uuid
 from collections.abc import Sequence
-from dataclasses import asdict, is_dataclass
 from datetime import datetime
 from typing import Any, Union
 
@@ -97,8 +96,18 @@ class MessageMapper:
         # Import Agent Framework types for proper isinstance checks
         try:
             from agent_framework import AgentRunResponseUpdate, WorkflowEvent
+            from agent_framework._workflows._events import AgentRunUpdateEvent
+
+            # Handle AgentRunUpdateEvent - workflow event wrapping AgentRunResponseUpdate
+            # This must be checked BEFORE generic WorkflowEvent check
+            if isinstance(raw_event, AgentRunUpdateEvent):
+                # Extract the AgentRunResponseUpdate from the event's data attribute
+                if raw_event.data and isinstance(raw_event.data, AgentRunResponseUpdate):
+                    return await self._convert_agent_update(raw_event.data, context)
+                # If no data, treat as generic workflow event
+                return await self._convert_workflow_event(raw_event, context)
 
-            # Handle agent updates (AgentRunResponseUpdate)
+            # Handle agent updates (AgentRunResponseUpdate) - for direct agent execution
             if isinstance(raw_event, AgentRunResponseUpdate):
                 return await self._convert_agent_update(raw_event, context)
 
@@ -258,13 +267,22 @@ class MessageMapper:
             List of OpenAI response stream events
         """
         try:
-            serialized_payload = self._serialize_payload(getattr(event, "data", None))
+            # Get event data and serialize if it's a SerializationMixin
+            event_data = getattr(event, "data", None)
+            if event_data is not None and hasattr(event_data, "to_dict"):
+                # SerializationMixin objects - convert to dict for JSON serialization
+                try:
+                    event_data = event_data.to_dict()
+                except Exception as e:
+                    logger.debug(f"Failed to serialize event data with to_dict(): {e}")
+                    event_data = str(event_data)
+
             # Create structured workflow event
             workflow_event = ResponseWorkflowEventComplete(
                 type="response.workflow_event.complete",
                 data={
                     "event_type": event.__class__.__name__,
-                    "data": serialized_payload,
+                    "data": event_data,
                     "executor_id": getattr(event, "executor_id", None),
                     "timestamp": datetime.now().isoformat(),
                 },
@@ -280,59 +298,6 @@ class MessageMapper:
             logger.warning(f"Error converting workflow event: {e}")
             return [await self._create_error_event(str(e), context)]
 
-    def _serialize_payload(self, value: Any) -> Any:
-        """Best-effort JSON serialization for workflow payloads."""
-        if value is None:
-            return None
-        if isinstance(value, (str, int, float, bool)):
-            return value
-        if isinstance(value, (list, tuple, set)):
-            return [self._serialize_payload(item) for item in value]
-        if isinstance(value, dict):
-            return {str(k): self._serialize_payload(v) for k, v in value.items()}
-        if is_dataclass(value) and not isinstance(value, type):
-            try:
-                return self._serialize_payload(asdict(value))
-            except Exception as exc:
-                logger.debug("Failed to serialize dataclass payload: %s", exc)
-        model_dump_method = getattr(value, "model_dump", None)
-        if model_dump_method is not None and callable(model_dump_method):
-            try:
-                dumped = model_dump_method()
-                return self._serialize_payload(dumped)
-            except Exception as exc:
-                logger.debug("Failed to serialize payload via model_dump: %s", exc)
-        dict_method = getattr(value, "dict", None)
-        if dict_method is not None and callable(dict_method):
-            try:
-                dict_result = dict_method()
-                return self._serialize_payload(dict_result)
-            except Exception as exc:
-                logger.debug("Failed to serialize payload via dict(): %s", exc)
-        to_dict_method = getattr(value, "to_dict", None)
-        if to_dict_method is not None and callable(to_dict_method):
-            try:
-                to_dict_result = to_dict_method()
-                return self._serialize_payload(to_dict_result)
-            except Exception as exc:
-                logger.debug("Failed to serialize payload via to_dict(): %s", exc)
-        model_dump_json_method = getattr(value, "model_dump_json", None)
-        if model_dump_json_method is not None and callable(model_dump_json_method):
-            try:
-                json_str = model_dump_json_method()
-                if isinstance(json_str, (str, bytes, bytearray)):
-                    return json.loads(json_str)
-            except Exception as exc:
-                logger.debug("Failed to serialize payload via model_dump_json: %s", exc)
-        if hasattr(value, "__dict__"):
-            try:
-                return self._serialize_payload({
-                    key: self._serialize_payload(val) for key, val in value.__dict__.items() if not key.startswith("_")
-                })
-            except Exception as exc:
-                logger.debug("Failed to serialize payload via __dict__: %s", exc)
-        return str(value)
-
     # Content type mappers - implementing our comprehensive mapping plan
 
     async def _map_text_content(self, content: Any, context: dict[str, Any]) -> ResponseTextDeltaEvent:
@@ -409,13 +374,24 @@ class MessageMapper:
             context["usage_data"] = []
         context["usage_data"].append(content)
 
+        # Extract usage from UsageContent.details (UsageDetails object)
+        details = getattr(content, "details", None)
+        total_tokens = 0
+        prompt_tokens = 0
+        completion_tokens = 0
+
+        if details:
+            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
+
         return ResponseUsageEventComplete(
             type="response.usage.complete",
             data={
-                "usage_data": getattr(content, "usage_data", {}),
-                "total_tokens": getattr(content, "total_tokens", 0),
-                "completion_tokens": getattr(content, "completion_tokens", 0),
-                "prompt_tokens": getattr(content, "prompt_tokens", 0),
+                "usage_data": details.to_dict() if details and hasattr(details, "to_dict") else {},
+                "total_tokens": total_tokens,
+                "completion_tokens": completion_tokens,
+                "prompt_tokens": prompt_tokens,
                 "timestamp": datetime.now().isoformat(),
             },
             item_id=context["item_id"],

agent_framework_devui/_server.py

@@ -7,7 +7,7 @@ import json
 import logging
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import Any, get_origin
 
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -23,6 +23,47 @@ from .models._discovery_models import DiscoveryResponse, EntityInfo
 logger = logging.getLogger(__name__)
 
 
+def _extract_executor_message_types(executor: Any) -> list[Any]:
+    """Return declared input types for the given executor."""
+    message_types: list[Any] = []
+
+    try:
+        input_types = getattr(executor, "input_types", None)
+    except Exception as exc:  # pragma: no cover - defensive logging path
+        logger.debug(f"Failed to access executor input_types: {exc}")
+    else:
+        if input_types:
+            message_types = list(input_types)
+
+    if not message_types and hasattr(executor, "_handlers"):
+        try:
+            handlers = 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 message_types
+
+
+def _select_primary_input_type(message_types: list[Any]) -> Any | None:
+    """Choose the most user-friendly input type for rendering workflow inputs."""
+    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]
+
+
 class DevServer:
     """Development Server - OpenAI compatible API server for debugging agents."""
 
@@ -222,24 +263,30 @@ class DevServer:
                         start_executor_id = ""
 
                         try:
+                            from ._utils import generate_input_schema
+
                             start_executor = entity_obj.get_start_executor()
-                            if start_executor and hasattr(start_executor, "_handlers"):
-                                message_types = list(start_executor._handlers.keys())
-                                if message_types:
-                                    input_type = message_types[0]
+                        except Exception as e:
+                            logger.debug(f"Could not extract input info for workflow {entity_id}: {e}")
+                        else:
+                            if start_executor:
+                                start_executor_id = getattr(start_executor, "executor_id", "") or getattr(
+                                    start_executor, "id", ""
+                                )
+
+                                message_types = _extract_executor_message_types(start_executor)
+                                input_type = _select_primary_input_type(message_types)
+
+                                if input_type:
                                     input_type_name = getattr(input_type, "__name__", str(input_type))
 
-                                    # Basic schema generation for common types
-                                    if input_type is str:
-                                        input_schema = {"type": "string"}
-                                    elif input_type is dict:
-                                        input_schema = {"type": "object"}
-                                    elif hasattr(input_type, "model_json_schema"):
-                                        input_schema = input_type.model_json_schema()
+                                    # Generate schema using comprehensive schema generation
+                                    input_schema = generate_input_schema(input_type)
 
-                                    start_executor_id = getattr(start_executor, "executor_id", "")
-                        except Exception as e:
-                            logger.debug(f"Could not extract input info for workflow {entity_id}: {e}")
+                        if not input_schema:
+                            input_schema = {"type": "string"}
+                            if input_type_name == "Unknown":
+                                input_type_name = "string"
 
                         # Get executor list
                         executor_list = []

agent_framework_devui/_session.py

@@ -67,7 +67,7 @@ class SessionManager:
             logger.debug(f"Closed session: {session_id}")
 
     def add_request_record(
-        self, session_id: str, entity_id: str, executor_name: str, request_input: Any, model: str
+        self, session_id: str, entity_id: str, executor_name: str, request_input: Any, model_id: str
     ) -> str:
         """Add a request record to a session.
 
@@ -76,7 +76,7 @@ class SessionManager:
             entity_id: ID of the entity being executed
             executor_name: Name of the executor
             request_input: Input for the request
-            model: Model name
+            model_id: Model name
 
         Returns:
             Request ID
@@ -91,7 +91,7 @@ class SessionManager:
             "entity_id": entity_id,
             "executor": executor_name,
             "input": request_input,
-            "model": model,
+            "model_id": model_id,
             "stream": True,
         }
         session["requests"].append(request_record)