agent-dev-cli 0.0.1b251223__py3-none-any.whl

agentdev/backend/event_mapper.py

@@ -0,0 +1,302 @@
+import time
+from typing import Callable, Type, Any
+from functools import wraps
+import uuid
+from datetime import datetime
+import sys
+import logging
+
+from agent_framework import WorkflowEvent, WorkflowStartedEvent, WorkflowFailedEvent, WorkflowStatusEvent, WorkflowRunState, ExecutorEvent, AgentRunUpdateEvent, ExecutorInvokedEvent, ExecutorCompletedEvent, AgentRunResponseUpdate, FunctionCallContent, FunctionResultContent, TextContent
+
+from ._utils import serialize_data
+from .structs.request import AgentFrameworkRequest
+
+
+# Access or store common data across different events
+class MapperContext:
+    # Input
+    request: AgentFrameworkRequest
+
+    # Generated
+    # global
+    response_id: str | None
+    response_created_at: float | None
+
+    # The last seen item id
+    item_id: str | None = None
+    output_index: int = 0
+
+    # The last seen call_id for function calling
+    call_id: str | None = None
+
+
+def event_mapper(event_type: Type[Any]) -> Callable:
+    """Decorator to register an event mapper method for a specific event type.
+    
+    Args:
+        event_type: The event type class this mapper handles
+        
+    Returns:
+        Decorator function that registers the mapper
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(self: 'EventMapper', ctx: MapperContext, event: Any) -> list[dict]:
+            return func(self, ctx, event)
+        
+        # Store event type on the wrapper for registration
+        wrapper._event_type = event_type  # type: ignore
+        return wrapper
+    
+    return decorator
+
+class EventMapper():
+    
+    def __init__(self):
+        """Initialize the EventMapper and register all decorated mapper methods."""
+        self._event_mappers = {}
+        
+        # Scan all methods for event_mapper decorators and register them
+        for attr_name in dir(self):
+            attr = getattr(self, attr_name)
+            if callable(attr) and hasattr(attr, '_event_type'):
+                event_type = attr._event_type
+                self._event_mappers[event_type] = attr
+    
+    def _get_event_mapper(self, event_type: Type[Any]) -> Callable | None:
+        # Direct lookup for exact type match
+        if event_type in self._event_mappers:
+            return self._event_mappers[event_type]
+        
+        for registered_type, mapper in self._event_mappers.items():
+            try:
+                if isinstance(event_type, type) and issubclass(event_type, registered_type):
+                    return mapper
+            except TypeError:
+                # Not a class type, skip
+                pass
+        
+        return None
+    
+    @event_mapper(WorkflowEvent)
+    def _map_workflow_event(self, ctx: MapperContext, event: WorkflowEvent) -> list[dict]:
+        if isinstance(event, WorkflowStartedEvent):
+            ctx.response_id = str(uuid.uuid4())
+            ctx.response_created_at = time.time()
+        
+        event_type = None
+        if isinstance(event, WorkflowStartedEvent):
+            event_type = "response.created"
+        elif isinstance(event, WorkflowFailedEvent):
+            return [{
+                "type": "response.failed",
+                "response":{
+                    "id": ctx.response_id,
+                    "created_at": ctx.response_created_at,
+                    "model": ctx.request.model,
+                    "error": {
+                        "code": event.details.error_type,
+                        "message": event.details.message,
+                        "traceback": event.details.traceback,
+                    },
+                },
+            }]
+        elif isinstance(event, WorkflowStatusEvent):
+            if event.state == WorkflowRunState.IN_PROGRESS:
+                event_type = "response.in_progress"
+
+        if event_type:
+            return [{
+                "type": event_type,
+                "response":{
+                    "id": ctx.response_id,
+                    "created_at": ctx.response_created_at,
+                    "model": ctx.request.model,
+                },
+            }]
+        
+        return []
+    
+    @event_mapper(AgentRunUpdateEvent)
+    def _map_agent_run_update_event(self, ctx: MapperContext, event: AgentRunUpdateEvent) -> list[dict]:
+        return [
+            {
+                "type":"response.output_text.delta",
+                "content_index":0,
+                "delta": event.data.text,
+                "item_id": ctx.item_id + "_message",
+                "logprobs":[],
+                "output_index":ctx.output_index,
+            }
+        ]
+
+    @event_mapper(ExecutorEvent)
+    def _map_executor_event(self, ctx: MapperContext, event: ExecutorEvent) -> list[dict]:
+        event_type = None
+        status = None
+        if isinstance(event, ExecutorInvokedEvent):
+            ctx.item_id = f"exec_{event.executor_id}_{str(uuid.uuid4())[:8]}"
+            ctx.output_index += 1
+            event_type = "response.output_item.added"
+            status = "in_progress"
+        elif isinstance(event, ExecutorCompletedEvent):
+            event_type = "response.output_item.done"
+            status = "completed"
+        else:
+            return []
+
+        events = []
+        if event_type:
+            # Serialize event data for frontend display
+            serialized_data = None
+            if event.data is not None:
+                try:
+                    serialized_data = serialize_data(event.data)
+                    logging.debug(f"[Executor] {event.executor_id} serialized data: {serialized_data}")
+                except Exception as e:
+                    logging.warning(f"Failed to serialize event data: {e}")
+                    serialized_data = str(event.data)
+            
+            # Build executor item with input/output data based on event type
+            executor_item: dict[str, Any] = {
+                "type": "executor_action",
+                "id": ctx.item_id,
+                "executor_id": event.executor_id,
+                "status": status,
+            }
+            
+            # For ExecutorInvokedEvent, include input data
+            if isinstance(event, ExecutorInvokedEvent):
+                executor_item["input"] = serialized_data
+            # For ExecutorCompletedEvent, include output data  
+            elif isinstance(event, ExecutorCompletedEvent):
+                executor_item["output"] = serialized_data
+            
+            events.append(
+                # Agent framework extended executor item
+                {
+                    "type": event_type,
+                    "output_index": ctx.output_index,
+                    "item": executor_item,
+                }
+            )
+            events.append(
+                # Standard OpenAI message item
+                {
+                    "type": event_type,
+                    "output_index": ctx.output_index,
+                    "item": {
+                        "type": "message",
+                        "id": ctx.item_id + "_message",
+                        "status": status,
+                        "role": "assistant",
+                        "content": [],
+                    }
+                }
+            )
+        
+        # OpenAI standard content part added event
+        if isinstance(event, ExecutorInvokedEvent):
+            events.append({
+                "type": "response.content_part.added",
+                "output_index": ctx.output_index,
+                "item_id": ctx.item_id + "_message",
+                "content_index": 0,
+                "part":{
+                    "text":"",
+                    "type":"output_text"
+                }
+            })
+        return events
+
+    @event_mapper(AgentRunResponseUpdate)
+    def _map_agent_run_response_update(self, ctx: MapperContext, event: AgentRunResponseUpdate) -> list[dict]:
+        item_id = event.message_id
+        results = []
+        if item_id and item_id != ctx.item_id:
+            ctx.item_id = item_id
+            ctx.output_index += 1
+            results.append({
+                "type":"response.output_item.added",           
+                "output_index": ctx.output_index,
+                "item":{
+                    "type":"message",       
+                    "id":"msg_a6a8c564",
+                    "content":[],
+                    "role":"assistant",
+                    "status":"in_progress"
+                },
+            })
+            results.append({
+                "type":"response.content_part.added",
+                "output_index": ctx.output_index,
+                "content_index": 0,
+                "item_id": ctx.item_id,
+                "part": {
+                    "type":"output_text",
+                    "text":"",
+                }
+            })
+        
+        for content in event.contents:
+            if isinstance(content, FunctionCallContent):
+                # Arguments are always streamed in OpenAI. But not always in Agent Framework.
+                # Argument streaming use last call_id to track the function call instance.
+                if ctx.call_id and content.arguments:
+                    results.append({
+                        "type": "response.function_call_arguments.delta",
+                        "output_index": ctx.output_index,
+                        # DevUI set OpenAI's item_id to the value of Agent Framework's call_id, which might be a bug
+                        "item_id": ctx.call_id,
+                        "delta": content.arguments,
+                    })
+                else:
+                    if content.call_id != ctx.call_id:
+                        ctx.call_id = content.call_id
+                        ctx.output_index += 1
+                    results.append({
+                        "type":"response.output_item.added",           
+                        "output_index": ctx.output_index,
+                        "item":{
+                            "type":"function_call",     
+                            "arguments":"",
+                            "call_id": ctx.call_id,
+                            "name": content.name,
+                            "id": content.call_id,
+                            "status":"in_progress",
+                        },
+                    })
+            elif isinstance(content, FunctionResultContent):
+                results.append({
+                    "type":"response.function_result.complete",           
+                    "call_id": content.call_id,
+                    "output_index": ctx.output_index,
+                    "output":content.result,
+                    "status":"completed",
+                    "item_id": ctx.item_id,
+                    "timestamp":datetime.now().isoformat(),
+                })
+
+            elif isinstance(content, TextContent):
+                results.append(
+                    {
+                        "type":"response.output_text.delta",
+                        "content_index":0,
+                        "delta": content.text,
+                        "item_id": ctx.item_id,
+                        "output_index": ctx.output_index,
+                    }
+                )
+            else:
+                print("Unknown content: " + str(type(content)), file=sys.stderr)
+        return results
+
+    def map_event(self, ctx: MapperContext, event: Any) -> list[dict]:
+        """Map an Agent Framework event to OpenAI Responses API events"""
+        mapper = self._get_event_mapper(type(event))
+        if not mapper:
+            print("Unknown event: " + type(event))
+            return []
+        
+        return mapper(ctx, event)
+    

agentdev/backend/server.py

@@ -0,0 +1,262 @@
+"""
+TestTool server setup module.
+
+This module provides functionality to set up test tool endpoints
+for agent servers.
+"""
+from typing import Any, AsyncGenerator
+import json
+import uuid
+import asyncio
+import logging
+
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import JSONResponse, StreamingResponse
+from starlette.routing import Route, WebSocketRoute
+from starlette.websockets import WebSocket, WebSocketDisconnect
+
+from agent_framework import Workflow, ChatMessage, AgentProtocol, Executor
+
+from .event_mapper import EventMapper, MapperContext
+from .structs.request import AgentFrameworkRequest
+from .structs.entity_response import EntityResponse
+from ._conversations import ConversationStore, InMemoryConversationStore
+from .code_analyzer import get_executor_location
+from .errors import ExecutorInputNotSupported
+
+class TestToolServer:
+    """Server class for mounting test tool endpoints."""
+    _entities: list[Workflow | AgentProtocol]
+    _events_mapper: EventMapper
+    _conversation_store: ConversationStore
+    _connection_id: str
+    
+    def __init__(self, entities: list[Workflow | AgentProtocol]):
+        self._events_mapper = EventMapper()
+        self._entities = entities
+        self._conversation_store = InMemoryConversationStore()
+        self._connection_id = str(uuid.uuid4())
+    
+    def convert_input_data(self, input_data: dict | list[dict], expected_type: type) -> Any:
+        """
+        Convert input data (always ChatMessage-like dict) to the expected input type of the entity (defined by user app)
+        """
+        if expected_type == list[ChatMessage]:
+            if type(input_data) == list:
+                chat_messages = [self.openai_chat_message_to_agent_framework_chat_message(item) for item in input_data]
+                return chat_messages
+            else:
+                chat_message = self.openai_chat_message_to_agent_framework_chat_message(input_data)
+                return [chat_message]
+        elif expected_type == ChatMessage:
+            chat_message = self.openai_chat_message_to_agent_framework_chat_message(input_data if type(input_data) == dict else input_data[0])
+            return chat_message
+        else:
+            raise ExecutorInputNotSupported(f"Unsupported input type for conversion: {expected_type}")
+    
+    def openai_chat_message_to_agent_framework_chat_message(self, message: dict) -> ChatMessage:
+        """Convert OpenAI chat message dict to Agent Framework ChatMessage."""
+        role = message.get("role")
+        text = message.get("text", None)
+        content = message.get("content", "")
+        if text:
+            return ChatMessage(role=role, text=text)
+        elif content:
+            contents = []
+            for c in content:
+                if type(c) == dict:
+                    if c["type"] == "input_text":
+                        result_content = {
+                            "type": "text",
+                            "text": c["text"]
+                        }
+                        contents.append(result_content)
+                    # TODO: support other content types like images, files, tool calls, etc.
+            return ChatMessage(role=role, contents=contents)
+        return ChatMessage(role=role, contents=contents, text=text)
+            
+
+    def mount_backend(self, root_app: Starlette):
+        app = Starlette(routes=[
+            # Responses API for workflow and agent
+            Route("/v1/responses", endpoint=self.responses, methods=["POST"]),
+            Route("/entities", endpoint=self.list_entities, methods=["GET"]),
+            Route("/entities/{entity_id}/info", endpoint=self.get_entity_info, methods=["GET"]),
+            Route("/entities/{entity_id}/executor/{executor_id}/location", endpoint=self.get_executor_location, methods=["GET"]),
+            Route("/conversations", endpoint=self.list_conversations, methods=["GET"]),
+            Route("/conversations", endpoint=self.create_conversation, methods=["POST"]),
+            WebSocketRoute("/ws/health", endpoint=self.websocket_health),
+        ])
+        root_app.mount("/agentdev/", app)
+    
+    async def list_entities(self, raw_request: Request):
+        entities_info = []
+        for entity in self._entities:
+            entity_info = EntityResponse.from_agent_framework(entity)
+            entities_info.append(entity_info.model_dump())
+        return JSONResponse({"entities": entities_info})
+    
+    async def get_entity_info(self, raw_request: Request):
+        entity_id = raw_request.path_params["entity_id"]
+        entity = self._get_entity(entity_id)
+        if not entity:
+            return JSONResponse({"error": "Entity not found"}, status_code=404)
+        
+        return JSONResponse(EntityResponse.from_agent_framework(entity).model_dump())
+    
+    async def get_executor_location(self, raw_request: Request):
+        entity_id = raw_request.path_params["entity_id"]
+        executor_id = raw_request.path_params["executor_id"]
+        
+        entity = self._get_entity(entity_id)
+        if not entity:
+            return JSONResponse({"error": "Entity not found"}, status_code=404)
+        
+        # Only workflows have executors
+        if not isinstance(entity, Workflow):
+            return JSONResponse({"error": "Entity is not a workflow"}, status_code=400)
+        
+        # Find the executor in the workflow
+        executor = self._find_executor(entity, executor_id)
+        if not executor:
+            return JSONResponse({"error": "Executor not found"}, status_code=404)
+
+        location = get_executor_location(executor)
+        if location is None:
+            return JSONResponse({"error": f"Could not determine executor location for {executor_id}, type={type(executor)}"}, status_code=400)
+        return JSONResponse({
+            "file_path": location.file_path,
+            "line_number": location.line_number,
+        })
+    
+    async def list_conversations(self, raw_request: Request):
+        items = self._conversation_store.list_conversations_by_metadata(metadata_filter=raw_request.query_params)
+        return JSONResponse({
+            "object": "list",
+            "data": items,
+            # For simplicity, we do not support pagination in conversation listing for now
+            "has_more": False,
+        })
+
+    async def create_conversation(self, raw_request: Request):
+        request_data = await raw_request.json()
+        conversation = self._conversation_store.create_conversation(metadata=request_data.get("metadata", {}))
+        return JSONResponse(conversation.model_dump())
+
+    async def responses(self, raw_request: Request):
+        raw_data = await raw_request.json()
+        request = AgentFrameworkRequest(**raw_data)
+        
+        entity = self._get_entity(request.model)
+        if not entity:
+            return JSONResponse({"error": "Model not found"}, status_code=404)
+
+        return StreamingResponse(
+            self._stream_execution(entity, request),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Access-Control-Allow-Origin": "*",
+            },
+        )
+
+    async def _stream_execution(self, entity: Workflow | AgentProtocol, request: AgentFrameworkRequest) -> AsyncGenerator[str, None]: 
+        if isinstance(entity, Workflow):
+            pass
+        elif isinstance(entity, AgentProtocol):
+            conversation_id = request.conversation["id"] if isinstance(request.conversation, dict) else request.conversation
+            if not conversation_id:
+                raise RuntimeError("Conversation ID must be provided for agent execution")
+
+        # Extract input from the request
+        input_raw = request.input
+        if type(input_raw) != dict and type(input_raw) != list:
+            raise RuntimeError("Only dict or list input type is supported in test tool server for now")
+
+        if isinstance(entity, Workflow):
+            start_executor_type = None
+            for input_type in entity.get_start_executor().input_types:
+                try:
+                    input_data = self.convert_input_data(input_raw, input_type)
+                except ExecutorInputNotSupported:
+                    continue
+            if input_data is None:
+                raise ExecutorInputNotSupported("No supported input type found for workflow start executor, start executor input types: " + str(entity.get_start_executor().input_types))
+        else:
+            # TODO: fetch conversation history from conversation store by ID
+            # Agents always support multiple input types including list[ChatMessage]
+            input_data = self.convert_input_data(input_raw, list[ChatMessage])
+
+        ctx = MapperContext()
+        ctx.request = request
+        try:
+            async for agent_framework_event in entity.run_stream(input_data):
+                if agent_framework_event and hasattr(agent_framework_event, "to_json"):
+                    logging.debug("Emit agent framework event: ", agent_framework_event.to_json())
+                else:
+                    logging.debug("Emit agent framework event: ", agent_framework_event)
+                openai_events = self._events_mapper.map_event(ctx, agent_framework_event)
+                for openai_event in openai_events:
+                    if openai_event:
+                        payload = json.dumps(openai_event)
+                        yield f"data: {payload}\n\n"
+        finally:
+            yield f"data: [DONE]\n\n"
+    
+    def _get_entity(self, model_name: str) -> Workflow | AgentProtocol | None:
+        # Because contain agents only support a single agent / workflow for now, we can just return the first one.
+        results = list(filter(lambda item: item.id == model_name, self._entities))
+        if not results:
+            return None
+        entity = results[0]
+        return entity
+    
+    def _find_executor(self, workflow: Workflow, executor_id: str) -> Executor | None:
+        # Search for the executor with matching ID
+        for name in workflow.executors:
+            if name == executor_id:
+                return workflow.executors[name]
+        return None
+    
+    def _get_entity_start_executor_types(self, entity: Workflow) -> Any:
+        return entity.get_start_executor().input_types[0]
+    
+    async def websocket_health(self, websocket: WebSocket):
+        """WebSocket endpoint for health check and connection monitoring."""
+        await websocket.accept()
+        try:
+            # Send initial connection info with unique connection ID
+            await websocket.send_json({
+                "type": "connected",
+                "connection_id": self._connection_id,
+                "timestamp": asyncio.get_event_loop().time()
+            })
+            
+            # Keep connection alive with periodic pings
+            while True:
+                try:
+                    # Wait for ping from client or send periodic health check
+                    data = await asyncio.wait_for(websocket.receive_text(), timeout=30.0)
+                    if data == "ping":
+                        await websocket.send_json({
+                            "type": "pong",
+                            "connection_id": self._connection_id,
+                            "timestamp": asyncio.get_event_loop().time()
+                        })
+                except asyncio.TimeoutError:
+                    # Send periodic health check
+                    await websocket.send_json({
+                        "type": "health",
+                        "connection_id": self._connection_id,
+                        "timestamp": asyncio.get_event_loop().time()
+                    })
+        except WebSocketDisconnect:
+            pass
+        except Exception as e:
+            print(f"WebSocket error: {e}")
+            try:
+                await websocket.close()
+            except:
+                pass

agentdev/backend/structs/__init__.py

@@ -0,0 +1,10 @@
+"""
+agentdev Package
+
+A simple package for setting up workflow visualization with agent servers.
+"""
+
+from .request import AgentFrameworkRequest
+
+__version__ = "0.1.0"
+__all__ = ["AgentFrameworkRequest"]

agentdev/backend/structs/entity_response.py

@@ -0,0 +1,30 @@
+from agent_framework import AgentProtocol, Workflow
+from pydantic import BaseModel
+from typing import Any
+
+class EntityResponse(BaseModel):
+
+    @classmethod
+    def from_agent_framework(cls, entity: AgentProtocol | Workflow) -> "EntityResponse":
+        return EntityResponse(
+            id=entity.id,
+            type="workflow" if isinstance(entity, Workflow) else "agent",
+            name=entity.name or "",
+            description=entity.description or "",
+            framework="agent_framework",
+            executors=list(entity.executors.keys()) if isinstance(entity, Workflow) else [],
+            start_executor_id=entity.get_start_executor().id if isinstance(entity, Workflow) else None,
+            workflow_dump=entity.to_dict() if isinstance(entity, Workflow) else None,
+            input_schema={"type": "object"},
+        )
+
+    id: str
+    type: str
+    name: str
+    description: str
+    framework: str
+    metadata: dict = {}
+    executors: list[str]
+    start_executor_id: str | None
+    workflow_dump: dict | None = None
+    input_schema: dict | None

agentdev/backend/structs/request.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Any, Literal
+
+# Agent Framework Request Model - Extending real OpenAI types
+class AgentFrameworkRequest(BaseModel):
+    """OpenAI ResponseCreateParams with Agent Framework routing.
+
+    This properly extends the real OpenAI API request format.
+    - Uses 'model' field as entity_id (agent/workflow name)
+    - Uses 'conversation' field for conversation context (OpenAI standard)
+    """
+
+    # All OpenAI fields from ResponseCreateParams
+    model: str  # Used as entity_id
+    input: str | list[Any] | dict[str, Any]  # ResponseInputParam + dict for workflow structured input
+    stream: bool | None = False
+
+    # OpenAI conversation parameter (standard!)
+    conversation: str | dict[str, Any] | None = None  # Union[str, {"id": str}]
+
+    # Common OpenAI optional fields
+    instructions: str | None = None
+    metadata: dict[str, Any] | None = None
+    temperature: float | None = None
+    max_output_tokens: int | None = None
+    tools: list[dict[str, Any]] | None = None
+
+    # Optional extra_body for advanced use cases
+    extra_body: dict[str, Any] | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+    def get_entity_id(self) -> str:
+        """Get entity_id from model field.
+
+        model IS the entity_id (agent/workflow name).
+        Simple and clean!
+        """
+        return self.model
+
+    def get_conversation_id(self) -> str | None:
+        """Extract conversation_id from conversation parameter.
+
+        Supports both string and object forms:
+        - conversation: "conv_123"
+        - conversation: {"id": "conv_123"}
+        """
+        if isinstance(self.conversation, str):
+            return self.conversation
+        if isinstance(self.conversation, dict):
+            return self.conversation.get("id")
+        return None
+
+    def to_openai_params(self) -> dict[str, Any]:
+        """Convert to dict for OpenAI client compatibility."""
+        return self.model_dump(exclude_none=True)
+