agentex-sdk 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

agentex/lib/cli/debug/debug_handlers.py

@@ -0,0 +1,174 @@
+"""
+Debug process handlers for AgentEx CLI.
+
+Provides debug-enabled versions of ACP server and temporal worker startup.
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Dict, TYPE_CHECKING
+
+from rich.console import Console
+
+if TYPE_CHECKING:
+    import asyncio.subprocess
+
+from .debug_config import DebugConfig, resolve_debug_port
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+
+async def start_temporal_worker_debug(
+    worker_path: Path, 
+    env: Dict[str, str], 
+    debug_config: DebugConfig
+):
+    """Start temporal worker with debug support"""
+    
+    if not debug_config.should_debug_worker():
+        raise ValueError("Debug config is not configured for worker debugging")
+    
+    # Resolve the actual debug port
+    debug_port = resolve_debug_port(debug_config, debug_config.get_worker_port())
+    
+    # Add debug environment variables
+    debug_env = env.copy()
+    debug_env.update({
+        "AGENTEX_DEBUG_ENABLED": "true",
+        "AGENTEX_DEBUG_PORT": str(debug_port),
+        "AGENTEX_DEBUG_WAIT_FOR_ATTACH": str(debug_config.wait_for_attach).lower(),
+        "AGENTEX_DEBUG_TYPE": "worker"
+    })
+    
+    # Start the worker process
+    # For debugging, use absolute path to run_worker.py to run from workspace root
+    worker_script = worker_path.parent / "run_worker.py"
+    cmd = [sys.executable, str(worker_script)]
+    
+    console.print(f"[blue]🐛 Starting Temporal worker in debug mode[/blue]")
+    console.print(f"[yellow]📡 Debug server will listen on port {debug_port}[/yellow]")
+    console.print(f"[green]✓ VS Code should connect to: localhost:{debug_port}[/green]")
+    
+    if debug_config.wait_for_attach:
+        console.print(f"[yellow]⏳ Worker will wait for debugger to attach[/yellow]")
+    
+    console.print(f"[dim]💡 In your IDE: Attach to localhost:{debug_port}[/dim]")
+    console.print(f"[dim]🔧 If connection fails, check that VS Code launch.json uses port {debug_port}[/dim]")
+    
+    return await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=Path.cwd(),  # Run from current working directory (workspace root)
+        env=debug_env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+
+async def start_acp_server_debug(
+    acp_path: Path, 
+    port: int, 
+    env: Dict[str, str],
+    debug_config: DebugConfig
+):
+    """Start ACP server with debug support"""
+    
+    if not debug_config.should_debug_acp():
+        raise ValueError("Debug config is not configured for ACP debugging")
+    
+    # Resolve the actual debug port
+    debug_port = resolve_debug_port(debug_config, debug_config.get_acp_port())
+    
+    # Add debug environment variables
+    debug_env = env.copy()
+    debug_env.update({
+        "AGENTEX_DEBUG_ENABLED": "true",
+        "AGENTEX_DEBUG_PORT": str(debug_port),
+        "AGENTEX_DEBUG_WAIT_FOR_ATTACH": str(debug_config.wait_for_attach).lower(),
+        "AGENTEX_DEBUG_TYPE": "acp"
+    })
+    
+    # Disable uvicorn auto-reload in debug mode to prevent conflicts
+    cmd = [
+        sys.executable,
+        "-m",
+        "uvicorn",
+        f"{acp_path.parent.name}.acp:acp",
+        "--port",
+        str(port),
+        "--host",
+        "0.0.0.0",
+        # Note: No --reload flag when debugging
+    ]
+
+    console.print(f"[blue]🐛 Starting ACP server in debug mode[/blue]")
+    console.print(f"[yellow]📡 Debug server will listen on port {debug_port}[/yellow]")
+    
+    if debug_config.wait_for_attach:
+        console.print(f"[yellow]⏳ ACP server will wait for debugger to attach[/yellow]")
+        
+    console.print(f"[dim]💡 In your IDE: Attach to localhost:{debug_port}[/dim]")
+
+    return await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=acp_path.parent.parent,
+        env=debug_env,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+
+def create_debug_startup_script() -> str:
+    """Create a Python script snippet for debug initialization"""
+    return '''
+import os
+import sys
+
+# Debug initialization for AgentEx
+if os.getenv("AGENTEX_DEBUG_ENABLED") == "true":
+    try:
+        import debugpy
+        debug_port = int(os.getenv("AGENTEX_DEBUG_PORT", "5678"))
+        debug_type = os.getenv("AGENTEX_DEBUG_TYPE", "unknown")
+        wait_for_attach = os.getenv("AGENTEX_DEBUG_WAIT_FOR_ATTACH", "false").lower() == "true"
+        
+        # Configure debugpy
+        debugpy.configure(subProcess=False)
+        debugpy.listen(debug_port)
+        
+        print(f"🐛 [{debug_type.upper()}] Debug server listening on port {debug_port}")
+        
+        if wait_for_attach:
+            print(f"⏳ [{debug_type.upper()}] Waiting for debugger to attach...")
+            debugpy.wait_for_client()
+            print(f"✅ [{debug_type.upper()}] Debugger attached!")
+        else:
+            print(f"📡 [{debug_type.upper()}] Ready for debugger attachment")
+            
+    except ImportError:
+        print("❌ debugpy not available. Install with: pip install debugpy")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Debug setup failed: {e}")
+        sys.exit(1)
+'''
+
+
+def inject_debug_code_to_worker_template() -> str:
+    """Generate debug code to inject into worker template"""
+    return """
+# === DEBUG SETUP (Auto-generated by AgentEx CLI) ===
+""" + create_debug_startup_script() + """
+# === END DEBUG SETUP ===
+"""
+
+
+def inject_debug_code_to_acp_template() -> str:
+    """Generate debug code to inject into ACP template"""
+    return """
+# === DEBUG SETUP (Auto-generated by AgentEx CLI) ===
+""" + create_debug_startup_script() + """
+# === END DEBUG SETUP ===
+""" 

agentex/lib/cli/handlers/agent_handlers.py

@@ -7,6 +7,7 @@ from rich.console import Console
 
 from agentex.lib.cli.handlers.run_handlers import RunError
 from agentex.lib.cli.handlers.run_handlers import run_agent as _run_agent
+from agentex.lib.cli.debug import DebugConfig
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
 from agentex.lib.utils.logging import make_logger
 
@@ -126,7 +127,7 @@ def build_agent(
     return image_name
 
 
-def run_agent(manifest_path: str):
+def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
     """Run an agent locally from the given manifest"""
     import asyncio
     import signal
@@ -152,7 +153,7 @@ def run_agent(manifest_path: str):
     signal.signal(signal.SIGTERM, signal_handler)
     
     try:
-        asyncio.run(_run_agent(manifest_path))
+        asyncio.run(_run_agent(manifest_path, debug_config))
     except KeyboardInterrupt:
         print("Shutdown completed.")
         sys.exit(0)

agentex/lib/cli/handlers/deploy_handlers.py

@@ -22,7 +22,7 @@ logger = make_logger(__name__)
 console = Console()
 
 TEMPORAL_WORKER_KEY = "temporal-worker"
-AGENTEX_AGENTS_HELM_CHART_VERSION = "0.1.2-v2-beta"
+AGENTEX_AGENTS_HELM_CHART_VERSION = "0.1.6-v1-beta"
 
 
 class InputDeployOverrides(BaseModel):
@@ -204,7 +204,6 @@ def merge_deployment_configs(
             for pull_secret in manifest.deployment.imagePullSecrets
         ]
         helm_values["global"]["imagePullSecrets"] = pull_secrets
-        # TODO: Remove this once i bump the chart version again
         helm_values["imagePullSecrets"] = pull_secrets
 
     # Apply cluster-specific overrides

agentex/lib/cli/handlers/run_handlers.py

@@ -18,6 +18,9 @@ from agentex.lib.cli.utils.path_utils import (
 
 from agentex.lib.environment_variables import EnvVarKeys
 from agentex.lib.sdk.config.agent_manifest import AgentManifest
+
+# Import debug functionality
+from agentex.lib.cli.debug import DebugConfig, start_acp_server_debug, start_temporal_worker_debug
 from agentex.lib.utils.logging import make_logger
 
 logger = make_logger(__name__)
@@ -249,7 +252,7 @@ async def stream_process_output(process: asyncio.subprocess.Process, prefix: str
         logger.debug(f"Output streaming ended for {prefix}: {e}")
 
 
-async def run_agent(manifest_path: str):
+async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = None):
     """Run an agent locally from the given manifest"""
 
     # Validate manifest exists
@@ -289,11 +292,16 @@ async def run_agent(manifest_path: str):
             )
         )
 
-        # Start ACP server
+        # Start ACP server (with debug support if enabled)
         manifest_dir = Path(manifest_path).parent
-        acp_process = await start_acp_server(
-            file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir
-        )
+        if debug_config and debug_config.should_debug_acp():
+            acp_process = await start_acp_server_debug(
+                file_paths["acp"], manifest.local_development.agent.port, agent_env, debug_config
+            )
+        else:
+            acp_process = await start_acp_server(
+                file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir
+            )
         process_manager.add_process(acp_process)
 
         # Start output streaming for ACP
@@ -301,9 +309,18 @@ async def run_agent(manifest_path: str):
 
         tasks = [acp_output_task]
 
-        # Start temporal worker if needed
+        # Start temporal worker if needed (with debug support if enabled)
         if is_temporal_agent(manifest) and file_paths["worker"]:
-            worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager)
+            if debug_config and debug_config.should_debug_worker():
+                # In debug mode, start worker without auto-reload to prevent conflicts
+                worker_process = await start_temporal_worker_debug(
+                    file_paths["worker"], agent_env, debug_config
+                )
+                process_manager.add_process(worker_process)
+                worker_task = asyncio.create_task(stream_process_output(worker_process, "WORKER"))
+            else:
+                # Normal mode with auto-reload
+                worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager)
             tasks.append(worker_task)
 
         console.print(

agentex/lib/cli/templates/default/pyproject.toml.j2

@@ -6,7 +6,6 @@ build-backend = "hatchling.build"
 name = "{{ project_name }}"
 version = "0.1.0"
 description = "{{ description }}"
-readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "agentex-sdk",

agentex/lib/cli/templates/sync/pyproject.toml.j2

@@ -6,7 +6,6 @@ build-backend = "hatchling.build"
 name = "{{ project_name }}"
 version = "0.1.0"
 description = "{{ description }}"
-readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "agentex-sdk",

agentex/lib/cli/templates/temporal/project/acp.py.j2

@@ -1,4 +1,35 @@
 import os
+import sys
+
+# === DEBUG SETUP (AgentEx CLI Debug Support) ===
+if os.getenv("AGENTEX_DEBUG_ENABLED") == "true":
+    try:
+        import debugpy
+        debug_port = int(os.getenv("AGENTEX_DEBUG_PORT", "5679"))
+        debug_type = os.getenv("AGENTEX_DEBUG_TYPE", "acp")
+        wait_for_attach = os.getenv("AGENTEX_DEBUG_WAIT_FOR_ATTACH", "false").lower() == "true"
+        
+        # Configure debugpy
+        debugpy.configure(subProcess=False)
+        debugpy.listen(debug_port)
+        
+        print(f"🐛 [{debug_type.upper()}] Debug server listening on port {debug_port}")
+        
+        if wait_for_attach:
+            print(f"⏳ [{debug_type.upper()}] Waiting for debugger to attach...")
+            debugpy.wait_for_client()
+            print(f"✅ [{debug_type.upper()}] Debugger attached!")
+        else:
+            print(f"📡 [{debug_type.upper()}] Ready for debugger attachment")
+            
+    except ImportError:
+        print("❌ debugpy not available. Install with: pip install debugpy")
+        sys.exit(1)
+    except Exception as e:
+        print(f"❌ Debug setup failed: {e}")
+        sys.exit(1)
+# === END DEBUG SETUP ===
+
 from agentex.lib.sdk.fastacp.fastacp import FastACP
 from agentex.lib.types.fastacp import TemporalACPConfig
 

agentex/lib/cli/templates/temporal/project/run_worker.py.j2

@@ -1,9 +1,9 @@
 import asyncio
-import os
 
 from agentex.lib.core.temporal.activities import get_all_activities
 from agentex.lib.core.temporal.workers.worker import AgentexWorker
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.utils.debug import setup_debug_if_enabled
 from agentex.lib.environment_variables import EnvironmentVariables
 
 from workflow import {{ workflow_class }}
@@ -15,6 +15,9 @@ logger = make_logger(__name__)
 
 
 async def main():
+    # Setup debug mode if enabled
+    setup_debug_if_enabled()
+    
     task_queue_name = environment_variables.WORKFLOW_TASK_QUEUE
     if task_queue_name is None:
         raise ValueError("WORKFLOW_TASK_QUEUE is not set")

agentex/lib/cli/templates/temporal/pyproject.toml.j2

@@ -6,7 +6,6 @@ build-backend = "hatchling.build"
 name = "{{ project_name }}"
 version = "0.1.0"
 description = "{{ description }}"
-readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "agentex-sdk",
@@ -20,6 +19,7 @@ dev = [
     "black",
     "isort",
     "flake8",
+    "debugpy>=1.8.15",
 ]
 
 [tool.hatch.build.targets.wheel]

agentex/lib/core/services/adk/acp/acp.py

@@ -64,7 +64,7 @@ class ACPService:
             else:
                 raise ValueError("Either agent_name or agent_id must be provided")
 
-            task_entry = Task.model_validate(json_rpc_response["result"])
+            task_entry = Task.model_validate(json_rpc_response.result)
             if span:
                 span.output = task_entry.model_dump()
             return task_entry
@@ -115,7 +115,7 @@ class ACPService:
             else:
                 raise ValueError("Either agent_name or agent_id must be provided")
 
-            task_message = TaskMessage.model_validate(json_rpc_response["result"])
+            task_message = TaskMessage.model_validate(json_rpc_response.result)
             if span:
                 span.output = task_message.model_dump()
             return task_message
@@ -147,7 +147,7 @@ class ACPService:
                     agent_name=agent_name,
                     method="event/send",
                     params={
-                        "task_name": task_name,
+                        "task_id": task_id,
                         "content": cast(TaskMessageContentParam, content.model_dump()),
                     },
                 )
@@ -163,7 +163,7 @@ class ACPService:
             else:
                 raise ValueError("Either agent_name or agent_id must be provided")
 
-            event_entry = Event.model_validate(json_rpc_response["result"])
+            event_entry = Event.model_validate(json_rpc_response.result)
             if span:
                 span.output = event_entry.model_dump()
             return event_entry
@@ -204,7 +204,7 @@ class ACPService:
             else:
                 raise ValueError("Either task_name or task_id must be provided")
 
-            task_entry = Task.model_validate(json_rpc_response["result"])
+            task_entry = Task.model_validate(json_rpc_response.result)
             if span:
                 span.output = task_entry.model_dump()
             return task_entry

agentex/lib/core/temporal/activities/__init__.py

@@ -1,3 +1,4 @@
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from scale_gp import SGPClient, SGPClientError
 
 from agentex import AsyncAgentex
@@ -58,7 +59,7 @@ def get_all_activities(sgp_client=None):
 
     llm_gateway = LiteLLMGateway()
     stream_repository = RedisStreamRepository()
-    agentex_client = AsyncAgentex()
+    agentex_client = create_async_agentex_client()
     tracer = AsyncTracer(agentex_client)
 
     # Services

agentex/lib/core/temporal/workers/worker.py

@@ -24,6 +24,8 @@ from temporalio.worker import (
 )
 
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.utils.registration import register_agent
+from agentex.lib.environment_variables import EnvironmentVariables
 
 logger = make_logger(__name__)
 
@@ -103,9 +105,16 @@ class AgentexWorker:
         workflow: type,
     ):
         await self.start_health_check_server()
+        await self._register_agent()
         temporal_client = await get_temporal_client(
             temporal_address=os.environ.get("TEMPORAL_ADDRESS", "localhost:7233"),
         )
+        
+        # Enable debug mode if AgentEx debug is enabled (disables deadlock detection)
+        debug_enabled = os.environ.get("AGENTEX_DEBUG_ENABLED", "false").lower() == "true"
+        if debug_enabled:
+            logger.info("🐛 [WORKER] Temporal debug mode enabled - deadlock detection disabled")
+        
         worker = Worker(
             client=temporal_client,
             task_queue=self.task_queue,
@@ -115,6 +124,7 @@ class AgentexWorker:
             workflow_runner=UnsandboxedWorkflowRunner(),
             max_concurrent_activities=self.max_concurrent_activities,
             build_id=str(uuid.uuid4()),
+            debug_mode=debug_enabled,  # Disable deadlock detection in debug mode
         )
 
         logger.info(f"Starting workers for task queue: {self.task_queue}")
@@ -160,3 +170,17 @@ class AgentexWorker:
                         f"Failed to start health check server on alternative port {alt_port}: {e}"
                     )
                     raise
+
+    """
+    Register the worker with the Agentex server.
+    
+    Even though the Temporal server will also register the agent with the server,
+    doing this on the worker side is required to make sure that both share the API key
+    which is returned on registration and used to authenticate the worker with the Agentex server.
+    """
+    async def _register_agent(self):
+        env_vars = EnvironmentVariables.refresh()
+        if env_vars and env_vars.AGENTEX_BASE_URL:
+            await register_agent(env_vars)
+        else:
+            logger.warning("AGENTEX_BASE_URL not set, skipping worker registration")

agentex/lib/core/tracing/processors/agentex_tracing_processor.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, override
 
 from agentex import Agentex, AsyncAgentex
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
     AsyncTracingProcessor,
     SyncTracingProcessor,
@@ -65,7 +66,7 @@ class AgentexSyncTracingProcessor(SyncTracingProcessor):
 
 class AgentexAsyncTracingProcessor(AsyncTracingProcessor):
     def __init__(self, config: AgentexTracingProcessorConfig):
-        self.client = AsyncAgentex()
+        self.client = create_async_agentex_client()
 
     @override
     async def on_span_start(self, span: Span) -> None:

agentex/lib/environment_variables.py

@@ -4,12 +4,15 @@ import os
 from enum import Enum
 from pathlib import Path
 
+from agentex.lib.utils.logging import make_logger
 from dotenv import load_dotenv
 
 from agentex.lib.utils.model_utils import BaseModel
 
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
 
+logger = make_logger(__name__)
+
 
 class EnvVarKeys(str, Enum):
     ENVIRONMENT = "ENVIRONMENT"
@@ -20,6 +23,7 @@ class EnvVarKeys(str, Enum):
     AGENT_NAME = "AGENT_NAME"
     AGENT_DESCRIPTION = "AGENT_DESCRIPTION"
     AGENT_ID = "AGENT_ID"
+    AGENT_API_KEY = "AGENT_API_KEY"
     # ACP Configuration
     ACP_URL = "ACP_URL"
     ACP_PORT = "ACP_PORT"
@@ -37,7 +41,7 @@ class Environment(str, Enum):
     PROD = "production"
 
 
-refreshed_environment_variables = None
+refreshed_environment_variables: "EnvironmentVariables" | None = None
 
 
 class EnvironmentVariables(BaseModel):
@@ -49,6 +53,7 @@ class EnvironmentVariables(BaseModel):
     AGENT_NAME: str
     AGENT_DESCRIPTION: str | None = None
     AGENT_ID: str | None = None
+    AGENT_API_KEY: str | None = None
     ACP_TYPE: str | None = "agentic"
     # ACP Configuration
     ACP_URL: str
@@ -64,6 +69,7 @@ class EnvironmentVariables(BaseModel):
         if refreshed_environment_variables is not None:
             return refreshed_environment_variables
 
+        logger.info("Refreshing environment variables")
         if os.environ.get(EnvVarKeys.ENVIRONMENT) == Environment.DEV:
             # Load global .env file first
             global_env_path = PROJECT_ROOT / ".env"