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

agentex/_base_client.py

@@ -532,7 +532,10 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         is_body_allowed = options.method.lower() != "get"
 
         if is_body_allowed:
-            kwargs["json"] = json_data if is_given(json_data) else None
+            if isinstance(json_data, bytes):
+                kwargs["content"] = json_data
+            else:
+                kwargs["json"] = json_data if is_given(json_data) else None
             kwargs["files"] = files
         else:
             headers.pop("Content-Type", None)

agentex/_files.py

@@ -69,12 +69,12 @@ def _transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], _read_file_content(file[1]), *file[2:])
+        return (file[0], read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-def _read_file_content(file: FileContent) -> HttpxFileContent:
+def read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return pathlib.Path(file).read_bytes()
     return file
@@ -111,12 +111,12 @@ async def _async_transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], await _async_read_file_content(file[1]), *file[2:])
+        return (file[0], await async_read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-async def _async_read_file_content(file: FileContent) -> HttpxFileContent:
+async def async_read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return await anyio.Path(file).read_bytes()
 

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.2.5"  # x-release-please-version
+__version__ = "0.2.7"  # x-release-please-version

agentex/lib/adk/_modules/acp.py

@@ -4,7 +4,7 @@ from typing import Any
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.acp.acp import ACPService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.acp.acp_activities import (
@@ -41,7 +41,7 @@ class ACPModule:
             acp_activities (Optional[ACPActivities]): Optional pre-configured ACP activities. If None, will be auto-initialized.
         """
         if acp_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._acp_service = ACPService(agentex_client=agentex_client, tracer=tracer)
         else:

agentex/lib/adk/_modules/agent_task_tracker.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.agent_task_tracker_activities import (
@@ -34,7 +34,7 @@ class AgentTaskTrackerModule:
         agent_task_tracker_service: AgentTaskTrackerService | None = None,
     ):
         if agent_task_tracker_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._agent_task_tracker_service = AgentTaskTrackerService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/agents.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.temporal.activities.adk.agents_activities import AgentsActivityName, GetAgentParams
 from temporalio.common import RetryPolicy
 
@@ -29,7 +29,7 @@ class AgentsModule:
         agents_service: Optional[AgentsService] = None,
     ):
         if agents_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._agents_service = AgentsService(agentex_client=agentex_client, tracer=tracer)
         else:

agentex/lib/adk/_modules/events.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.events import EventsService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.events_activities import (
@@ -33,7 +33,7 @@ class EventsModule:
         events_service: EventsService | None = None,
     ):
         if events_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._events_service = EventsService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/messages.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.messages import MessagesService
 from agentex.lib.core.services.adk.streaming import StreamingService
@@ -38,7 +38,7 @@ class MessagesModule:
         messages_service: MessagesService | None = None,
     ):
         if messages_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/_modules/state.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.state import StateService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.state_activities import (
@@ -37,7 +37,7 @@ class StateModule:
         state_service: StateService | None = None,
     ):
         if state_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._state_service = StateService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/streaming.py

@@ -1,7 +1,7 @@
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
 from agentex.lib.core.services.adk.streaming import (
     StreamingService,
@@ -35,7 +35,7 @@ class StreamingModule:
         """
         if streaming_service is None:
             stream_repository = RedisStreamRepository()
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             self._streaming_service = StreamingService(
                 agentex_client=agentex_client,
                 stream_repository=stream_repository,

agentex/lib/adk/_modules/tasks.py

@@ -3,7 +3,7 @@ from datetime import timedelta
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.tasks import TasksService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.tasks_activities import (
@@ -32,7 +32,7 @@ class TasksModule:
         tasks_service: TasksService | None = None,
     ):
         if tasks_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._tasks_service = TasksService(
                 agentex_client=agentex_client, tracer=tracer

agentex/lib/adk/_modules/tracing.py

@@ -6,7 +6,7 @@ from typing import Any
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
-from agentex.lib.adk.utils._modules.client import get_async_agentex_client
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.services.adk.tracing import TracingService
 from agentex.lib.core.temporal.activities.activity_helpers import ActivityHelpers
 from agentex.lib.core.temporal.activities.adk.tracing_activities import (
@@ -39,7 +39,7 @@ class TracingModule:
             tracing_activities (Optional[TracingActivities]): Optional pre-configured tracing activities. If None, will be auto-initialized.
         """
         if tracing_service is None:
-            agentex_client = get_async_agentex_client()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._tracing_service = TracingService(tracer=tracer)
         else:

agentex/lib/adk/providers/_modules/litellm.py

@@ -1,6 +1,7 @@
 from collections.abc import AsyncGenerator
 from datetime import timedelta
 
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
@@ -39,7 +40,7 @@ class LiteLLMModule:
     ):
         if litellm_service is None:
             # Create default service
-            agentex_client = AsyncAgentex()
+            agentex_client = create_async_agentex_client()
             stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/providers/_modules/openai.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 from typing import Any, Literal
 
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agents import Agent, RunResult, RunResultStreaming
 from agents.agent import StopAtTools, ToolsToFinalOutputFunction
 from agents.agent_output import AgentOutputSchemaBase
@@ -46,7 +47,7 @@ class OpenAIModule:
     ):
         if openai_service is None:
             # Create default service
-            agentex_client = AsyncAgentex()
+            agentex_client = create_async_agentex_client()
             stream_repository = RedisStreamRepository()
             streaming_service = StreamingService(
                 agentex_client=agentex_client,

agentex/lib/adk/providers/_modules/sgp.py

@@ -1,5 +1,6 @@
 from datetime import timedelta
 
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from scale_gp import SGPClient, SGPClientError
 from temporalio.common import RetryPolicy
 
@@ -33,7 +34,7 @@ class SGPModule:
         if sgp_service is None:
             try:
                 sgp_client = SGPClient()
-                agentex_client = AsyncAgentex()
+                agentex_client = create_async_agentex_client()
                 tracer = AsyncTracer(agentex_client)
                 self._sgp_service = SGPService(sgp_client=sgp_client, tracer=tracer)
             except SGPClientError:

agentex/lib/adk/utils/_modules/client.py

@@ -1,43 +1,29 @@
-import threading
-from typing import Dict, Optional, Any
+import httpx
 
 from agentex import AsyncAgentex
-from agentex.lib.environment_variables import EnvironmentVariables, refreshed_environment_variables
+from agentex.lib.environment_variables import EnvironmentVariables
+from agentex.lib.utils.logging import make_logger
 
-_client: Optional["AsyncAgentex"] = None
-_cached_headers: Dict[str, str] = {}
-_init_kwargs: Dict[str, Any] = {}
-_lock = threading.RLock()
+logger = make_logger(__name__)
 
 
-def _build_headers() -> Dict[str, str]:
-    EnvironmentVariables.refresh()
-    if refreshed_environment_variables and getattr(refreshed_environment_variables, "AGENT_ID", None):
-        return {"x-agent-identity": refreshed_environment_variables.AGENT_ID}
-    return {}
+class EnvAuth(httpx.Auth):
+    def __init__(self, header_name="x-agent-api-key"):
+        self.header_name = header_name
 
+    def auth_flow(self, request):
+        # This gets called for every request
+        env_vars = EnvironmentVariables.refresh()
+        if env_vars:
+            agent_api_key = env_vars.AGENT_API_KEY  
+            if agent_api_key:
+                request.headers[self.header_name] = agent_api_key
+                masked_key = agent_api_key[-4:] if agent_api_key and len(agent_api_key) > 4 else "****"
+                logger.info(f"Adding header {self.header_name}:{masked_key}")
+        yield request
 
-def get_async_agentex_client(**kwargs) -> "AsyncAgentex":
-    """
-    Return a cached AsyncAgentex instance (created synchronously).
-    Each call re-checks env vars and updates client.default_headers if needed.
-    """
-    global _client, _cached_headers, _init_kwargs
 
-    new_headers = _build_headers()
-
-    with _lock:
-        # First time (or kwargs changed) -> build a new client
-        if _client is None or kwargs != _init_kwargs:
-            _client = AsyncAgentex(default_headers=new_headers.copy(), **kwargs)
-            _cached_headers = new_headers
-            _init_kwargs = dict(kwargs)
-            return _client
-
-        # Same client; maybe headers changed
-        if new_headers != _cached_headers:
-            _cached_headers = new_headers
-            _client.default_headers.clear()
-            _client.default_headers.update(new_headers)
-
-        return _client
+def create_async_agentex_client(**kwargs) -> AsyncAgentex:
+    client = AsyncAgentex(**kwargs)
+    client._client.auth = EnvAuth()
+    return client

agentex/lib/adk/utils/_modules/templating.py

@@ -1,6 +1,7 @@
 from datetime import timedelta
 from typing import Any
 
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from temporalio.common import RetryPolicy
 
 from agentex import AsyncAgentex
@@ -39,7 +40,7 @@ class TemplatingModule:
             templating_service (Optional[TemplatingService]): Optional pre-configured templating service. If None, will be auto-initialized.
         """
         if templating_service is None:
-            agentex_client = AsyncAgentex()
+            agentex_client = create_async_agentex_client()
             tracer = AsyncTracer(agentex_client)
             self._templating_service = TemplatingService(tracer=tracer)
         else:

agentex/lib/cli/commands/agents.py

@@ -11,6 +11,7 @@ from agentex.lib.cli.handlers.agent_handlers import (
     build_agent,
     run_agent,
 )
+from agentex.lib.cli.debug import DebugConfig, DebugMode
 from agentex.lib.cli.handlers.cleanup_handlers import cleanup_agent_workflows
 from agentex.lib.cli.handlers.deploy_handlers import (
     DeploymentError,
@@ -171,7 +172,13 @@ def run(
         False, 
         help="Clean up existing workflows for this agent before starting"
     ),
-):
+    # Debug options
+    debug: bool = typer.Option(False, help="Enable debug mode for both worker and ACP (disables auto-reload)"),
+    debug_worker: bool = typer.Option(False, help="Enable debug mode for temporal worker only"),
+    debug_acp: bool = typer.Option(False, help="Enable debug mode for ACP server only"),
+    debug_port: int = typer.Option(5678, help="Port for remote debugging (worker uses this, ACP uses port+1)"),
+    wait_for_debugger: bool = typer.Option(False, help="Wait for debugger to attach before starting"),
+) -> None:
     """
     Run an agent locally from the given manifest.
     """
@@ -196,8 +203,35 @@ def run(
             console.print(f"[yellow]⚠ Pre-run cleanup failed: {str(e)}[/yellow]")
             logger.warning(f"Pre-run cleanup failed: {e}")
     
+    # Create debug configuration based on CLI flags
+    debug_config = None
+    if debug or debug_worker or debug_acp:
+        # Determine debug mode
+        if debug:
+            mode = DebugMode.BOTH
+        elif debug_worker and debug_acp:
+            mode = DebugMode.BOTH
+        elif debug_worker:
+            mode = DebugMode.WORKER
+        elif debug_acp:
+            mode = DebugMode.ACP
+        else:
+            mode = DebugMode.NONE
+        
+        debug_config = DebugConfig(
+            enabled=True,
+            mode=mode,
+            port=debug_port,
+            wait_for_attach=wait_for_debugger,
+            auto_port=False  # Use fixed port to match VS Code launch.json
+        )
+        
+        console.print(f"[blue]🐛 Debug mode enabled: {mode.value}[/blue]")
+        if wait_for_debugger:
+            console.print("[yellow]⏳ Processes will wait for debugger attachment[/yellow]")
+    
     try:
-        run_agent(manifest_path=manifest)
+        run_agent(manifest_path=manifest, debug_config=debug_config)
     except Exception as e:
         typer.echo(f"Error running agent: {str(e)}", err=True)
         logger.exception("Error running agent")

agentex/lib/cli/debug/__init__.py

@@ -0,0 +1,15 @@
+"""
+Debug functionality for AgentEx CLI
+
+Provides debug support for temporal workers and ACP servers during local development.
+"""
+
+from .debug_config import DebugConfig, DebugMode
+from .debug_handlers import start_acp_server_debug, start_temporal_worker_debug
+
+__all__ = [
+    "DebugConfig",
+    "DebugMode", 
+    "start_acp_server_debug",
+    "start_temporal_worker_debug",
+] 

agentex/lib/cli/debug/debug_config.py

@@ -0,0 +1,116 @@
+"""
+Debug configuration models for AgentEx CLI debugging.
+"""
+
+import socket
+from enum import Enum
+from typing import Optional
+
+from agentex.lib.utils.model_utils import BaseModel
+
+
+class DebugMode(str, Enum):
+    """Debug mode options"""
+    WORKER = "worker"
+    ACP = "acp"
+    BOTH = "both"
+    NONE = "none"
+
+
+class DebugConfig(BaseModel):
+    """Configuration for debug mode"""
+    
+    enabled: bool = False
+    mode: DebugMode = DebugMode.NONE
+    port: int = 5678
+    wait_for_attach: bool = False
+    auto_port: bool = True  # Automatically find available port if specified port is busy
+    
+    @classmethod
+    def create_worker_debug(
+        cls, 
+        port: int = 5678, 
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for worker debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.WORKER,
+            port=port,
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    @classmethod
+    def create_acp_debug(
+        cls, 
+        port: int = 5679, 
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for ACP debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.ACP,
+            port=port,
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    @classmethod
+    def create_both_debug(
+        cls, 
+        worker_port: int = 5678,
+        acp_port: int = 5679,
+        wait_for_attach: bool = False,
+        auto_port: bool = True
+    ) -> "DebugConfig":
+        """Create debug config for both worker and ACP debugging"""
+        return cls(
+            enabled=True,
+            mode=DebugMode.BOTH,
+            port=worker_port,  # Primary port for worker
+            wait_for_attach=wait_for_attach,
+            auto_port=auto_port
+        )
+    
+    def should_debug_worker(self) -> bool:
+        """Check if worker should be debugged"""
+        return self.enabled and self.mode in (DebugMode.WORKER, DebugMode.BOTH)
+    
+    def should_debug_acp(self) -> bool:
+        """Check if ACP should be debugged"""
+        return self.enabled and self.mode in (DebugMode.ACP, DebugMode.BOTH)
+    
+    def get_worker_port(self) -> int:
+        """Get port for worker debugging"""
+        return self.port
+    
+    def get_acp_port(self) -> int:
+        """Get port for ACP debugging"""
+        if self.mode == DebugMode.BOTH:
+            return self.port + 1  # Use port + 1 for ACP when debugging both
+        return self.port
+
+
+def find_available_port(start_port: int = 5678, max_attempts: int = 10) -> int:
+    """Find an available port starting from start_port"""
+    for port in range(start_port, start_port + max_attempts):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.bind(('localhost', port))
+                return port
+        except OSError:
+            continue
+    
+    # If we can't find an available port, just return the start port
+    # and let the debug server handle the error
+    return start_port
+
+
+def resolve_debug_port(config: DebugConfig, target_port: int) -> int:
+    """Resolve the actual port to use for debugging"""
+    if config.auto_port:
+        return find_available_port(target_port)
+    return target_port