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

agent_dev_cli-0.0.1b251223.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: agent-dev-cli
+Version: 0.0.1b251223
+Summary: AI Toolkit - CLI and SDK for agent debugging and workflow visualization
+Keywords: ai,agent,toolkit,debugging,workflow,visualization
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: azure-identity>=1.25.1
+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: click>=8.1.0
+Requires-Dist: azure-ai-projects>=2.0.0b2
+Requires-Dist: pytest>=8.0.0 ; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0 ; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0 ; extra == "dev"
+Requires-Dist: httpx>=0.27.0 ; extra == "dev"
+Project-URL: Documentation, https://github.com/microsoft/vscode-ai-toolkit#readme
+Project-URL: Homepage, https://github.com/microsoft/vscode-ai-toolkit
+Project-URL: Issues, https://github.com/microsoft/vscode-ai-toolkit/issues
+Project-URL: Repository, https://github.com/microsoft/vscode-ai-toolkit
+Provides-Extra: dev
+
+# Agent Dev CLI
+
+Agent Dev CLI - A Python package for agent debugging and workflow visualization with VS Code integration.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+### Option 1: CLI Wrapper (Recommended)
+
+The easiest way to use Agent Dev CLI - **no code changes required**:
+
+```bash
+# Run your agent script with agentdev instrumentation
+agentdev run my_agent.py
+
+# Specify a custom port
+agentdev run workflow.py --port 9000
+
+# Enable verbose output
+agentdev run my_agent.py --verbose
+
+# Pass arguments to your script
+agentdev run my_agent.py -- --model gpt-4 --temperature 0.7
+```
+
+The CLI automatically:
+- Intercepts `from_agent_framework()` calls
+- Injects agentdev visualization endpoints
+- Opens the workflow visualization in VS Code
+
+### Option 2: Programmatic API
+
+If you prefer explicit control, you can integrate agentdev directly:
+
+```python
+from agentdev import setup_test_tool
+from azure.ai.agentserver.agentframework import from_agent_framework
+
+# Create your agent
+agent = build_agent(chat_client)
+
+# Create agent server
+agent_server = from_agent_framework(agent)
+
+# Setup workflow visualization
+setup_test_tool(agent_server)
+
+# Run the server
+await agent_server.run_async()
+```
+
+## CLI Commands
+
+### `agentdev run`
+
+Run a Python agent script with agentdev instrumentation.
+
+```
+agentdev run [OPTIONS] SCRIPT [ARGS]...
+
+Options:
+  -p, --port INTEGER    Agent server port (default: 8088)
+  -v, --verbose         Enable verbose output
+  --help                Show this message and exit
+```
+
+### `agentdev info`
+
+Show agentdev configuration and status information.
+
+```
+agentdev info
+```
+
+## Features
+
+- **Health Check Endpoint**: Adds a `/agentdev/health` endpoint to your agent server
+- **Workflow Visualization**: Starts a visualization server on port 8090 for WorkflowAgent instances
+- **Easy Integration**: Simple one-function setup
+
+## Requirements
+
+- Python 3.10+
+- agent-framework
+- starlette
+
+## License
+
+MIT License
+
+
+## Test
+
+```bash
+curl 'http://localhost:8088/agentdev/v1/responses' \
+  -H 'Content-Type: application/json' \
+  -d '{"model":"workflow_in-memory_content-review-workflow_5c703d16cb1e4756848ddcc685b16503","input":{"role":"user","text":"test"},"stream":true}'
+```
+

agent_dev_cli-0.0.1b251223.dist-info/RECORD

@@ -0,0 +1,20 @@
+agentdev/__init__.py,sha256=x8tqJT9_MfcIjgmP1dB8gztU3cXEjkUkxk6Q8bEgXjk,537
+agentdev/__main__.py,sha256=lHwzD56r-Jd0A_VOGRmv2PcP2AZ56dWz61o3zCBGxzY,135
+agentdev/_bootstrap.py,sha256=XQ2sKmTxJzS7S6AvvfUbegP6FZxJ93UO5clHpB_SUhQ,2193
+agentdev/_hooks.py,sha256=TeZWMQQeiSWzOokceDrVrYkOl4DT8oR5isBlhJRAu5A,9859
+agentdev/cli.py,sha256=dbDfnppPXUA1G2lpGh4U-Y-g-t1eFp0K9J97DzknQvk,4724
+agentdev/localdebug.py,sha256=Pr_DMsYZrYS_ijnahCQ6QT6_KqEo7e1-7lQ2QHTucIE,1977
+agentdev/backend/__init__.py,sha256=BFiYU9_0aAfygA0oTs0o70etmH65_gX9cN53ZcMwFIY,197
+agentdev/backend/_conversations.py,sha256=ui62ml5pise0fF9ri7HITM_l4irMdmm2jJ7d_U1FL74,18518
+agentdev/backend/_utils.py,sha256=9fx1bAZZR13wUX4d6OeOnCRDWglExpBA2yM1oIhozV4,3138
+agentdev/backend/code_analyzer.py,sha256=NfKmoPSCVB39qFG_jzhY9Qf1iYiTNezpGVxJQyr4ZLE,1517
+agentdev/backend/errors.py,sha256=95geZNBeAfxAWyJDCaGFXSFsCifUZ2V0PHmsPOYsmt4,53
+agentdev/backend/event_mapper.py,sha256=0k0zAMoiBteQjK2TELQXhjYFD0dcZCcuDwM2cKuS7pA,11847
+agentdev/backend/server.py,sha256=XWWHpVC8eKtqvU5esKOkaUlqHKFjbe2iif2eqbzHdXE,12262
+agentdev/backend/structs/__init__.py,sha256=UKpDMo_sjEtvmHI8Rys6_s4dUYaE0lz3-jw0T_BWoQ8,212
+agentdev/backend/structs/entity_response.py,sha256=0z5lliYeQmX3jgz4TGJNSt82vVxccsCHYop5hDxU1fc,1103
+agentdev/backend/structs/request.py,sha256=KsAHkDGGLW53_sOBDxV21D3cv_TzVcGYYP-jfM_ebV8,2053
+agent_dev_cli-0.0.1b251223.dist-info/entry_points.txt,sha256=Zeb1F0rPDO1dIQorHn7Q-hpOg09ZDE7elz4fowvO6BQ,46
+agent_dev_cli-0.0.1b251223.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+agent_dev_cli-0.0.1b251223.dist-info/METADATA,sha256=ruzicRPC0YmVOb7i0bjM84wY5DHRXLROYZAe8zq1I0U,3991
+agent_dev_cli-0.0.1b251223.dist-info/RECORD,,

agent_dev_cli-0.0.1b251223.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_dev_cli-0.0.1b251223.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agentdev=agentdev.cli:main
+

agentdev/__init__.py

@@ -0,0 +1,22 @@
+"""
+agentdev Package
+
+Agent Dev CLI - A package for agent debugging and workflow visualization.
+
+This package provides two ways to use agentdev:
+
+1. CLI Wrapper (Recommended - No code changes required):
+   
+   $ agentdev run my_agent.py
+   $ agentdev run workflow.py --port 9000
+   
+2. Programmatic API (Requires code modification):
+   
+   from agentdev import setup_test_tool
+   setup_test_tool(agent_server)
+"""
+
+from .localdebug import setup_test_tool
+
+__version__ = "0.0.1b251223"
+__all__ = ["setup_test_tool"]

agentdev/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running agentdev as a module: python -m agentdev"""
+from agentdev.cli import main
+
+if __name__ == "__main__":
+    main()

agentdev/_bootstrap.py

@@ -0,0 +1,70 @@
+"""
+agentdev Bootstrap Module.
+
+This module is executed via `python -m agentdev._bootstrap` to set up
+import hooks before running the user's agent script.
+
+The bootstrap process:
+1. Install import hooks for auto-instrumentation
+2. Modify sys.argv to match what the user script expects
+3. Execute the user's script in __main__ context
+"""
+
+import os
+import sys
+import runpy
+from pathlib import Path
+
+
+def bootstrap():
+    """Bootstrap the user's script with agentdev instrumentation."""
+    
+    # Check if we have a script to run
+    if len(sys.argv) < 2:
+        print("agentdev Bootstrap: No script specified", file=sys.stderr)
+        sys.exit(1)
+    
+    script_path = sys.argv[1]
+    
+    # Validate script exists
+    if not os.path.isfile(script_path):
+        print(f"agentdev Bootstrap: Script not found: {script_path}", file=sys.stderr)
+        sys.exit(1)
+    
+    verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    if verbose:
+        print(f"agentdev Bootstrap: Installing import hooks...", file=sys.stderr)
+    
+    # Install import hooks BEFORE running user code
+    from agentdev._hooks import install_hooks
+    install_hooks()
+    
+    if verbose:
+        print(f"agentdev Bootstrap: Hooks installed, running {script_path}", file=sys.stderr)
+    
+    # Adjust sys.argv to remove bootstrap reference
+    # User script sees: [script_path, arg1, arg2, ...]
+    sys.argv = sys.argv[1:]
+    
+    # Add script's directory to sys.path for relative imports
+    script_dir = str(Path(script_path).parent.absolute())
+    if script_dir not in sys.path:
+        sys.path.insert(0, script_dir)
+    
+    # Run the user's script as __main__
+    try:
+        # Use runpy for proper __main__ execution
+        runpy.run_path(script_path, run_name='__main__')
+    except SystemExit:
+        # Re-raise SystemExit to preserve exit codes
+        raise
+    except KeyboardInterrupt:
+        if verbose:
+            print("\nagentdev Bootstrap: Interrupted by user", file=sys.stderr)
+        sys.exit(130)
+    # Let other exceptions propagate so debuggers can break on them
+
+
+if __name__ == '__main__':
+    bootstrap()

agentdev/_hooks.py

@@ -0,0 +1,275 @@
+"""
+agentdev Import Hooks.
+
+This module provides import hooks that automatically instrument
+the agent framework to inject agentdev visualization and debugging
+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.
+"""
+
+import sys
+import os
+import builtins
+import functools
+from typing import Any, Callable, Optional
+
+
+# Global flag to track if hooks are installed
+_hooks_installed = False
+
+# Store original functions for potential restoration
+_original_from_agent_framework: Optional[Callable] = None
+
+
+def _create_patched_from_agent_framework(original_func: Callable) -> Callable:
+    """Create a patched version of from_agent_framework that auto-injects agentdev.
+    
+    Args:
+        original_func: The original from_agent_framework function
+        
+    Returns:
+        Patched function that calls setup_test_tool automatically
+    """
+    @functools.wraps(original_func)
+    def patched_from_agent_framework(agent: Any, **kwargs) -> Any:
+        verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+        
+        if verbose:
+            print(f"agentdev Hook: Intercepted from_agent_framework() call", file=sys.stderr)
+        
+        # Call original function to create the server
+        server = original_func(agent, **kwargs)
+        
+        if verbose:
+            print(f"agentdev Hook: Agent server created, injecting agentdev...", file=sys.stderr)
+        
+        # Auto-inject agentdev visualization
+        try:
+            from agentdev.localdebug import setup_test_tool
+            setup_test_tool(server)
+            
+            if verbose:
+                print(f"agentdev Hook: Successfully injected agentdev instrumentation", file=sys.stderr)
+        except Exception as e:
+            print(f"agentdev Hook: Warning - Failed to inject agentdev: {e}", file=sys.stderr)
+            # Don't fail the user's code, just warn
+        
+        return server
+    
+    return patched_from_agent_framework
+
+
+def _patch_agentserver_module(module: Any, silent_retry: bool = False) -> bool:
+    """Patch the agentserver.agentframework module with agentdev instrumentation.
+    
+    Args:
+        module: The azure.ai.agentserver.agentframework module
+        silent_retry: If True, don't log retry messages
+        
+    Returns:
+        True if patching was successful, False if should retry later
+    """
+    global _original_from_agent_framework
+    
+    verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    if hasattr(module, 'from_agent_framework'):
+        # Store original for potential restoration
+        _original_from_agent_framework = module.from_agent_framework
+        
+        # Replace with patched version
+        module.from_agent_framework = _create_patched_from_agent_framework(
+            _original_from_agent_framework
+        )
+        
+        if verbose:
+            print(f"agentdev Hook: Patched from_agent_framework()", file=sys.stderr)
+        return True
+    else:
+        # Only log once on first retry attempt
+        if verbose and not silent_retry:
+            print(f"agentdev Hook: Waiting for from_agent_framework to be available...", file=sys.stderr)
+        return False
+
+
+class AgentDevMetaPathFinder:
+    """Meta path finder that intercepts agent framework imports.
+    
+    This finder watches for imports of azure.ai.agentserver.agentframework
+    and patches the module after it's loaded.
+    """
+    
+    TARGET_MODULE = "azure.ai.agentserver.agentframework"
+    
+    def __init__(self):
+        self._patched = False
+        self._verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    def find_module(self, fullname: str, path: Any = None) -> Optional["AgentDevMetaPathFinder"]:
+        """Called for each import - we use this to detect our target module.
+        
+        Note: We return None to let normal import proceed, then patch afterward.
+        """
+        return None
+    
+    def find_spec(self, fullname: str, path: Any, target: Any = None) -> None:
+        """Called for each import in Python 3.4+.
+        
+        We don't provide a spec - we just use this as a notification hook.
+        """
+        return None
+
+
+class AgentDevImportHook:
+    """Import hook that patches modules after they're imported.
+    
+    This uses sys.meta_path to intercept imports and patch the
+    agentserver module when it's loaded.
+    """
+    
+    TARGET_MODULE = "azure.ai.agentserver.agentframework"
+    
+    def __init__(self):
+        self._patched = False
+        self._first_attempt = True
+        self._verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    def find_module(self, fullname: str, path: Any = None):
+        """Legacy finder method for Python 3.3 compatibility."""
+        # Check if target module was just imported
+        self._check_and_patch()
+        return None
+    
+    def find_spec(self, fullname: str, path: Any, target: Any = None):
+        """Finder method for Python 3.4+."""
+        # Check if target module was just imported
+        self._check_and_patch()
+        return None
+    
+    def _check_and_patch(self) -> None:
+        """Check if target module is loaded and patch if necessary."""
+        if self._patched:
+            return
+        
+        if self.TARGET_MODULE in sys.modules:
+            module = sys.modules[self.TARGET_MODULE]
+            # Only show "waiting" message on first attempt
+            silent = not self._first_attempt
+            self._first_attempt = False
+            if _patch_agentserver_module(module, silent_retry=silent):
+                self._patched = True
+
+def _install_post_import_hook() -> None:
+    """Install a hook that patches the module after import.
+    
+    Since we can't easily intercept the module during import,
+    we use a different approach: patch sys.modules monitoring.
+    """
+    verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    # First, check if the module is already imported
+    target = "azure.ai.agentserver.agentframework"
+    target_parts = target.split(".")
+    
+    if target in sys.modules:
+        if verbose:
+            print(f"agentdev Hook: Target module already loaded, patching now", file=sys.stderr)
+        _patch_agentserver_module(sys.modules[target])
+        return
+    
+    # Install meta path hook to catch future imports
+    hook = AgentDevImportHook()
+    sys.meta_path.insert(0, hook)
+    
+    if verbose:
+        print(f"agentdev Hook: Installed meta path finder", file=sys.stderr)
+    
+    # Monkey-patch __import__ for more reliable interception
+    # Use the builtins module (standard way) instead of __builtins__ (implementation detail)
+    original_import = builtins.__import__
+    
+    def patched_import(name, globals=None, locals=None, fromlist=(), level=0):
+        result = original_import(name, globals, locals, fromlist, level)
+        
+        # Only check when importing something related to our target
+        # This reduces noise from unrelated imports
+        if hook._patched:
+            return result
+            
+        # Check if this import is our target or a parent/child of it
+        if name == target or name.startswith("azure.ai.agentserver") or target.startswith(name + "."):
+            if target in sys.modules:
+                module = sys.modules[target]
+                # Use hook's first_attempt tracking for silent retry
+                silent = not hook._first_attempt
+                hook._first_attempt = False
+                if _patch_agentserver_module(module, silent_retry=silent):
+                    hook._patched = True
+        
+        return result
+    
+    builtins.__import__ = patched_import
+    
+    if verbose:
+        print(f"agentdev Hook: Installed __import__ hook", file=sys.stderr)
+
+
+def install_hooks() -> None:
+    """Install agentdev import hooks for auto-instrumentation.
+    
+    This function should be called before any user code runs.
+    It sets up hooks to automatically patch the agent framework
+    when it's imported.
+    """
+    global _hooks_installed
+    
+    if _hooks_installed:
+        return
+    
+    verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    if verbose:
+        print("agentdev Hook: Installing import hooks...", file=sys.stderr)
+    
+    _install_post_import_hook()
+    _hooks_installed = True
+    
+    if verbose:
+        print("agentdev Hook: Import hooks installed successfully", file=sys.stderr)
+
+
+def uninstall_hooks() -> None:
+    """Uninstall agentdev import hooks and restore original functions.
+    
+    This can be used for testing or if the user wants to disable
+    agentdev instrumentation at runtime.
+    """
+    global _hooks_installed, _original_from_agent_framework
+    
+    if not _hooks_installed:
+        return
+    
+    verbose = os.environ.get('AGENTDEV_VERBOSE') == '1'
+    
+    # Restore original from_agent_framework if we patched it
+    target = "azure.ai.agentserver.agentframework"
+    if target in sys.modules and _original_from_agent_framework:
+        sys.modules[target].from_agent_framework = _original_from_agent_framework
+        
+        if verbose:
+            print("agentdev Hook: Restored original from_agent_framework()", file=sys.stderr)
+    
+    # Remove our meta path finders
+    sys.meta_path = [
+        finder for finder in sys.meta_path 
+        if not isinstance(finder, AgentDevImportHook)
+    ]
+    
+    _hooks_installed = False
+    _original_from_agent_framework = None
+    
+    if verbose:
+        print("agentdev Hook: Hooks uninstalled", file=sys.stderr)

agentdev/backend/__init__.py

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