agent-dev-cli 0.0.1b260119__py3-none-any.whl → 0.0.1b260205__py3-none-any.whl

{agent_dev_cli-0.0.1b260119.dist-info → agent_dev_cli-0.0.1b260205.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-dev-cli
-Version: 0.0.1b260119
+Version: 0.0.1b260205
 Summary: AI Toolkit - CLI and SDK for agent debugging and workflow visualization
 Keywords: ai,agent,toolkit,debugging,workflow,visualization
 Author-email: Microsoft <aitkfeedback@microsoft.com>
@@ -26,9 +26,10 @@ Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: azure-ai-agents>=1.2.0b5
 Requires-Dist: starlette>=0.49.3
 Requires-Dist: openai>=1.109.1
-Requires-Dist: agent-framework-azure-ai>=1.0.0b251211
-Requires-Dist: azure-ai-agentserver-agentframework>=1.0.0b7
-Requires-Dist: azure-ai-agentserver-core>=1.0.0b7
+Requires-Dist: agent-framework-azure-ai>=1.0.0b251211,<=1.0.0b260107
+Requires-Dist: agent-framework-core>=1.0.0b251211,<=1.0.0b260107
+Requires-Dist: azure-ai-agentserver-agentframework==1.0.0b10
+Requires-Dist: azure-ai-agentserver-core==1.0.0b10
 Requires-Dist: click>=8.1.0
 Requires-Dist: azure-ai-projects>=2.0.0b2
 Project-URL: Documentation, https://github.com/microsoft/vscode-ai-toolkit#readme
@@ -78,7 +79,7 @@ The CLI automatically:
 If you prefer explicit control, you can integrate agentdev directly:
 
 ```python
-from agentdev import setup_test_tool
+from agentdev import configure_agent_server
 from azure.ai.agentserver.agentframework import from_agent_framework
 
 # Create your agent
@@ -88,7 +89,7 @@ agent = build_agent(chat_client)
 agent_server = from_agent_framework(agent)
 
 # Setup workflow visualization
-setup_test_tool(agent_server)
+configure_agent_server(agent_server)
 
 # Run the server
 await agent_server.run_async()

{agent_dev_cli-0.0.1b260119.dist-info → agent_dev_cli-0.0.1b260205.dist-info}/RECORD

@@ -1,22 +1,22 @@
-agentdev/__init__.py,sha256=Gf0UUj3_2MdCadGtKtnyJeYY02iUH5ZMevelN8Um09M,557
+agentdev/__init__.py,sha256=bl3B1MKFUJIhoLxHnfEktKYNvWweqJ-ppd9Kf0YOLlw,585
 agentdev/__main__.py,sha256=lHwzD56r-Jd0A_VOGRmv2PcP2AZ56dWz61o3zCBGxzY,135
-agentdev/_hooks.py,sha256=0bdq-K170vTmhE9a5JHL-DCXJOCpuG2LIvannQqH3jU,9819
-agentdev/_version.py,sha256=i-XLHa-ZbhQ-sdJ0UHTD6zCr_0GBfhh2au_NzzDWGwU,79
+agentdev/_hooks.py,sha256=-K2vFMhhZh1D46dEUA1uGgGdU92k6qbXnU98TpgmjTw,9847
+agentdev/_version.py,sha256=QTmmRJaAMr6GP280-vG-90EtyBrbr7gex8cu8UwRCiA,79
 agentdev/bootstrap.py,sha256=sL9CobtPdK4n2piHhFr1-K12AlWgTfgfbdzyfTYWuxc,2192
 agentdev/cli.py,sha256=SWM_SHfZdmLr6ZH8yuGtiMLcd9lhta5YjQxW9xICXac,4948
-agentdev/localdebug.py,sha256=qn75D3hISn2k8yFLRs0qXFrr_asCNRqyOcNy-97AWaY,2028
+agentdev/localdebug.py,sha256=KL3CHFaPskgYU7knTcvY74BthVT7aCOxUZy6ccm12ug,3401
 agentdev/backend/__init__.py,sha256=BFiYU9_0aAfygA0oTs0o70etmH65_gX9cN53ZcMwFIY,197
 agentdev/backend/_conversations.py,sha256=ui62ml5pise0fF9ri7HITM_l4irMdmm2jJ7d_U1FL74,18518
-agentdev/backend/_utils.py,sha256=WkJT-5o1QvLQHOaQqm_RR7ivLMS8DO5w9chHGA2WSus,3348
+agentdev/backend/_utils.py,sha256=MmysFnqhNmfCyb1cTfLtpGR66yJ2nElpcDQq8j_4hT0,3412
 agentdev/backend/code_analyzer.py,sha256=-B_1Qrf3cbWhvcxjxgk7xbHyfjKuL11GvtzY9wA1hkM,1565
 agentdev/backend/errors.py,sha256=95geZNBeAfxAWyJDCaGFXSFsCifUZ2V0PHmsPOYsmt4,53
-agentdev/backend/event_mapper.py,sha256=1TLY9JIsFdmFWcjaPHvRq7v_l7wUG9MY1wproD4dlRo,12485
-agentdev/backend/server.py,sha256=BRtZqJI2GxWraRwYkrpJNcDnhxZJ22aL0ScIZNhfNSk,12388
+agentdev/backend/event_mapper.py,sha256=SG-FwGwRJAdwXrBzFtkucqa_P8Wj4QjNcgzdXk7XgQs,17442
+agentdev/backend/server.py,sha256=WEXu37PkXyTpBHlddh_LhAksTNMWS5LEwkT7nMLEGaA,12685
 agentdev/backend/structs/__init__.py,sha256=UKpDMo_sjEtvmHI8Rys6_s4dUYaE0lz3-jw0T_BWoQ8,212
 agentdev/backend/structs/entity_response.py,sha256=dGG-9J3gpGxqu4LV_6UqeoyzjdBqFn8tiesu2EPXzmc,1079
 agentdev/backend/structs/request.py,sha256=lG0Tcp3bvR505DobO9u8XPfeVg-0DGKvt7mhPbGFJRg,2044
-agent_dev_cli-0.0.1b260119.dist-info/entry_points.txt,sha256=Zeb1F0rPDO1dIQorHn7Q-hpOg09ZDE7elz4fowvO6BQ,46
-agent_dev_cli-0.0.1b260119.dist-info/licenses/LICENSE,sha256=spth2ab8cfDqNmKBLSbKHNqnlnDIj-bYaw8insufb2w,3000
-agent_dev_cli-0.0.1b260119.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-agent_dev_cli-0.0.1b260119.dist-info/METADATA,sha256=N-KawRcwWez4u9_YeOTgJ_T5OQloenRaXqaIm9ldIrM,4408
-agent_dev_cli-0.0.1b260119.dist-info/RECORD,,
+agent_dev_cli-0.0.1b260205.dist-info/entry_points.txt,sha256=Zeb1F0rPDO1dIQorHn7Q-hpOg09ZDE7elz4fowvO6BQ,46
+agent_dev_cli-0.0.1b260205.dist-info/licenses/LICENSE,sha256=spth2ab8cfDqNmKBLSbKHNqnlnDIj-bYaw8insufb2w,3000
+agent_dev_cli-0.0.1b260205.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+agent_dev_cli-0.0.1b260205.dist-info/METADATA,sha256=ykBKkXqRr5E1-vUGohdI2GHh15o0w4rEpDZfAXAEOnU,4504
+agent_dev_cli-0.0.1b260205.dist-info/RECORD,,

agentdev/__init__.py

@@ -12,11 +12,11 @@ This package provides two ways to use agentdev:
    
 2. Programmatic API (Requires code modification):
    
-   from agentdev import setup_test_tool
-   setup_test_tool(agent_server)
+   from agentdev import configure_agent_server
+   configure_agent_server(agent_server)
 """
 
-from .localdebug import setup_test_tool
+from .localdebug import configure_agent_server
 from ._version import __version__
 
-__all__ = ["setup_test_tool", "__version__"]
+__all__ = ["configure_agent_server", "__version__"]

agentdev/_hooks.py

@@ -7,7 +7,7 @@ capabilities without requiring user code modifications.
 
 The hook intercepts:
 - `azure.ai.agentserver.agentframework.from_agent_framework()` 
-  to automatically call `setup_test_tool()` on the created server.
+  to automatically call `configure_agent_server()` on the created server.
 """
 
 import sys
@@ -31,7 +31,7 @@ def _create_patched_from_agent_framework(original_func: Callable) -> Callable:
         original_func: The original from_agent_framework function
         
     Returns:
-        Patched function that calls setup_test_tool automatically
+        Patched function that calls configure_agent_server automatically
     """
     @functools.wraps(original_func)
     def patched_from_agent_framework(agent: Any, **kwargs) -> Any:
@@ -48,8 +48,8 @@ def _create_patched_from_agent_framework(original_func: Callable) -> Callable:
         
         # Auto-inject agentdev visualization
         try:
-            from agentdev.localdebug import setup_test_tool
-            setup_test_tool(server)
+            from agentdev.localdebug import configure_agent_server
+            configure_agent_server(server)
             
             if verbose:
                 print(f"agentdev Hook: Successfully injected agentdev instrumentation", file=sys.stderr)

agentdev/_version.py

@@ -1,2 +1,2 @@
 """Version information for agentdev package."""
-__version__ = "0.0.1b260119"
+__version__ = "0.0.1b260205"

agentdev/backend/_utils.py

@@ -36,11 +36,6 @@ def serialize_data(data: Any, max_depth: int = 10) -> Any:
     if isinstance(data, dict):
         return {k: serialize_data(v, max_depth - 1) for k, v in data.items()}
     
-    # Handle ChatMessage - show as {"role":"xxx", "text":"xxx"}
-    if isinstance(data, ChatMessage):
-        role_str = data.role.value if hasattr(data.role, 'value') else str(data.role)
-        return {"role": role_str, "text": data.text}
-    
     # Handle AgentExecutorResponse
     if isinstance(data, AgentExecutorResponse):
         result = {}
@@ -57,6 +52,11 @@ def serialize_data(data: Any, max_depth: int = 10) -> Any:
             return serialize_data(dict_data, max_depth - 1)
         except Exception:
             pass
+
+    # Handle ChatMessage - Fallback if to_dict failed or is not available
+    if isinstance(data, ChatMessage):
+        role_str = data.role.value if hasattr(data.role, 'value') else str(data.role)
+        return {"role": role_str, "text": data.text, "contents": serialize_data(data.contents, max_depth - 1)}
     
     # Handle Pydantic models with model_dump()
     if hasattr(data, "model_dump") and callable(data.model_dump):

agentdev/backend/event_mapper.py

@@ -1,3 +1,4 @@
+import json
 import time
 from typing import Callable, Type, Any
 from functools import wraps
@@ -132,16 +133,82 @@ class EventMapper():
     
     @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,
-            }
-        ]
+        events = []
+        update = event.data
+        logging.debug(f"[EventMapper] AgentRunUpdateEvent received, executor_id={event.executor_id}, contents={len(update.contents) if update.contents else 0}")
+        if not ctx.item_id:
+            # Fallback if item_id not set
+            ctx.item_id = f"exec_{event.executor_id}_{str(uuid.uuid4())[:8]}"
+
+        message_item_id = ctx.item_id + "_message"
+        
+        for content in update.contents:
+            logging.debug(f"[EventMapper] Processing content type: {type(content).__name__}")
+            if isinstance(content, TextContent):
+                events.append({
+                    "type":"response.output_text.delta",
+                    "content_index":0,
+                    "delta": content.text,
+                    "item_id": message_item_id,
+                    "logprobs":[],
+                    "output_index":ctx.output_index,
+                })
+            elif isinstance(content, FunctionCallContent):
+                if content.call_id != ctx.call_id:
+                    ctx.call_id = content.call_id
+                    ctx.output_index += 1
+                    events.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",
+                        },
+                    })
+                
+                # Handle arguments delta
+                delta_args = ""
+                if isinstance(content.arguments, str):
+                    delta_args = content.arguments
+                elif content.arguments:
+                    # Serialize dictionary arguments
+                    try:
+                        delta_args = json.dumps(serialize_data(content.arguments))
+                    except Exception as e:
+                        logging.warning(f"Failed to serialize arguments: {e}")
+                        delta_args = str(content.arguments)
+
+                if delta_args:
+                    events.append({
+                        "type": "response.function_call_arguments.delta",
+                        "output_index": ctx.output_index,
+                        "item_id": ctx.call_id,
+                        "delta": delta_args,
+                    })
+
+            elif isinstance(content, FunctionResultContent):
+                serialized_result = None
+                try:
+                    serialized_result = serialize_data(content.result)
+                except Exception as e:
+                    logging.warning(f"Failed to serialize function result: {e}")
+                    serialized_result = str(content.result)
+
+                events.append({
+                    "type":"response.function_result.complete",           
+                    "call_id": content.call_id,
+                    "output_index": ctx.output_index,
+                    "output": serialized_result,
+                    "status":"completed",
+                    "item_id": ctx.item_id,
+                    "timestamp":datetime.now().isoformat(),
+                })
+        
+        return events
 
     @event_mapper(ExecutorEvent)
     def _map_executor_event(self, ctx: MapperContext, event: ExecutorEvent) -> list[dict]:
@@ -225,6 +292,7 @@ class EventMapper():
     @event_mapper(AgentRunResponseUpdate)
     def _map_agent_run_response_update(self, ctx: MapperContext, event: AgentRunResponseUpdate) -> list[dict]:
         item_id = event.message_id
+        logging.debug(f"[EventMapper] AgentRunResponseUpdate received, message_id={item_id}, contents={len(event.contents) if event.contents else 0}")
         results = []
         if item_id and item_id != ctx.item_id:
             ctx.item_id = item_id
@@ -253,16 +321,26 @@ class EventMapper():
         
         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,
-                    })
+                is_same_call = ctx.call_id and content.call_id == ctx.call_id
+                
+                if is_same_call and content.arguments:
+                    delta_args = ""
+                    if isinstance(content.arguments, str):
+                        delta_args = content.arguments
+                    elif content.arguments:
+                        try:
+                            delta_args = json.dumps(serialize_data(content.arguments))
+                        except Exception as e:
+                            logging.warning(f"Failed to serialize arguments: {e}")
+                            delta_args = str(content.arguments)
+                    
+                    if delta_args:
+                        results.append({
+                            "type": "response.function_call_arguments.delta",
+                            "output_index": ctx.output_index,
+                            "item_id": ctx.call_id,
+                            "delta": delta_args,
+                        })
                 else:
                     if content.call_id != ctx.call_id:
                         ctx.call_id = content.call_id
@@ -279,6 +357,24 @@ class EventMapper():
                             "status":"in_progress",
                         },
                     })
+                    if content.arguments:
+                        initial_args = ""
+                        if isinstance(content.arguments, str):
+                            initial_args = content.arguments
+                        elif content.arguments:
+                            try:
+                                initial_args = json.dumps(serialize_data(content.arguments))
+                            except Exception as e:
+                                logging.warning(f"Failed to serialize initial arguments: {e}")
+                                initial_args = str(content.arguments)
+                        
+                        if initial_args:
+                            results.append({
+                                "type": "response.function_call_arguments.delta",
+                                "output_index": ctx.output_index,
+                                "item_id": ctx.call_id,
+                                "delta": initial_args,
+                            })
             elif isinstance(content, FunctionResultContent):
                 results.append({
                     "type":"response.function_result.complete",           
@@ -306,10 +402,13 @@ class EventMapper():
 
     def map_event(self, ctx: MapperContext, event: Any) -> list[dict]:
         """Map an Agent Framework event to OpenAI Responses API events"""
+        logging.debug(f"[EventMapper] map_event called with event type: {type(event).__name__}")
         mapper = self._get_event_mapper(type(event))
         if not mapper:
             logging.warning("Unknown event: %s", type(event))
             return []
         
-        return mapper(ctx, event)
+        result = mapper(ctx, event)
+        logging.debug(f"[EventMapper] Mapped to {len(result)} output events: {[e.get('type') for e in result]}")
+        return result
     

agentdev/backend/server.py

@@ -18,6 +18,8 @@ from starlette.websockets import WebSocket, WebSocketDisconnect
 
 from agent_framework import Workflow, ChatMessage, AgentProtocol, Executor
 
+from .._version import __version__
+
 from .event_mapper import EventMapper, MapperContext
 from .structs.request import AgentFrameworkRequest
 from .structs.entity_response import EntityResponse
@@ -81,6 +83,7 @@ class TestToolServer:
         app = Starlette(routes=[
             # Responses API for workflow and agent
             Route("/v1/responses", endpoint=self.responses, methods=["POST"]),
+            Route("/version", endpoint=self.get_version, methods=["GET"]),
             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"]),
@@ -90,6 +93,10 @@ class TestToolServer:
         ])
         root_app.mount("/agentdev/", app)
     
+    async def get_version(self, raw_request: Request):
+        """Return the CLI version for compatibility checking."""
+        return JSONResponse({"version": __version__})
+    
     async def list_entities(self, raw_request: Request):
         entities_info = []
         for entity in self._entities:

agentdev/localdebug.py

@@ -7,9 +7,41 @@ This module provides functionality to set up workflow or agent visualization
 from agent_framework import WorkflowAgent
 import logging
 import time
+from typing import Any, Optional
 
 
-def setup_test_tool(agent_server):
+def _get_agent_from_server(agent_server: Any) -> Optional[Any]:
+    """
+    Extract the agent from an agent server instance.
+    
+    Args:
+        agent_server: The agent server instance
+        
+    Returns:
+        The agent instance, or None if not found
+    """
+    if hasattr(agent_server, '_agent') and agent_server._agent is not None:
+        return agent_server._agent
+    
+    if hasattr(agent_server, 'agent') and agent_server.agent is not None:
+        return agent_server.agent
+    
+    if hasattr(agent_server, '_workflow_factory') and agent_server._workflow_factory is not None:
+        try:
+            return agent_server._workflow_factory().as_agent()
+        except Exception as e:
+            logging.debug("Failed to build workflow agent (%s): %s", type(e).__name__, e)
+    
+    if hasattr(agent_server, '_build_agent'):
+        try:
+            return agent_server._build_agent()
+        except Exception as e:
+            logging.debug("Failed to call _build_agent (%s): %s", type(e).__name__, e)
+    
+    return None
+
+
+def configure_agent_server(agent_server):
     """
     Set up workflow or agent visualization for an agent server.
     
@@ -18,12 +50,14 @@ def setup_test_tool(agent_server):
     
     Args:
         agent_server: The agent server instance to set up visualization for.
-                     Should have 'app' (Starlette) and 'agent' attributes.
+                     Should have 'app' (Starlette) attribute. The agent is 
+                     extracted using `_get_agent_from_server()` which supports
+                     both old and new SDK versions.
     
     Example:
         >>> from azure.ai.agentserver.agentframework import from_agent_framework
         >>> agent_server = from_agent_framework(agent)
-        >>> setup_test_tool(agent_server)
+        >>> configure_agent_server(agent_server)
         >>> await agent_server.run_async()
     """
     from starlette.applications import Starlette
@@ -37,20 +71,22 @@ def setup_test_tool(agent_server):
         return JSONResponse({"status": "ok"}, status_code=200)
     
     app = agent_server.app
-    agent = agent_server.agent
+    agent = _get_agent_from_server(agent_server)
+    
+    if agent is None:
+        logging.warning("agentdev: Could not extract agent from server, visualization may be limited")
 
-    # Mount health check endpoint
     app.mount(
         "/agentdev/health",
         Starlette(routes=[Route("/", health_check)])
     )
 
-    # Prepare entities for visualization
     entities = []
-    if isinstance(agent, WorkflowAgent):
-        entities.append(agent.workflow)
-    else:
-        entities.append(agent)
+    if agent is not None:
+        if isinstance(agent, WorkflowAgent):
+            entities.append(agent.workflow)
+        else:
+            entities.append(agent)
 
     test_tool_server = TestToolServer(entities)
     test_tool_server.mount_backend(app)