refactor(agents): AgentConfig holds runtime-only settings; SDK log level on Configuration

Connection/auth (server_url, api_key, auth_key, auth_secret) and the dead llm_retry_count / secret_strict_mode fields are removed from AgentConfig — connection and auth belong to the conductor Configuration. log_level moves onto Configuration (settable param + CONDUCTOR_LOG_LEVEL/AGENTSPAN_LOG_LEVEL env) so it is SDK-wide; the runtime reads it from there. run.configure() now takes a Configuration for connection. AgentConfig keeps worker + liveness settings only. Unit tests updated.

Author: v1r3n

src/conductor/ai/agents/run.py

@@ -32,7 +32,6 @@
 
 if TYPE_CHECKING:
     from conductor.ai.agents.runtime.config import AgentConfig
-    from conductor.client.configuration.configuration import Configuration
 
 from conductor.ai.agents.agent import Agent
 from conductor.ai.agents.result import (
@@ -48,23 +47,26 @@
 # ── Singleton runtime ────────────────────────────────────────────────────
 
 _default_config: Optional[AgentConfig] = None
+_default_configuration = None  # conductor Configuration (connection/auth/log level)
 _default_runtime = None
 _runtime_lock = threading.Lock()
 
 
-def configure(config: Optional[AgentConfig] = None, **kwargs):
+def configure(config: Optional[AgentConfig] = None, *, configuration=None, **kwargs):
     """Pre-configure the default singleton runtime.
 
     Must be called **before** the first :func:`run`, :func:`start`, or
     :func:`stream` call.  The configuration persists across
     :func:`shutdown` / recreate cycles.
 
     Args:
-        config: An :class:`AgentConfig` instance.  If provided, *kwargs*
-            are ignored.
-        **kwargs: Individual config fields to override on top of
-            :meth:`AgentConfig.from_env` defaults (e.g.
-            ``server_url="https://prod:8080/api"``).
+        config: An :class:`AgentConfig` (agent-runtime settings). If provided,
+            *kwargs* are ignored.
+        configuration: A conductor :class:`Configuration` carrying the server
+            connection, auth, and log level. Defaults to the env-based
+            ``Configuration()``.
+        **kwargs: Individual :class:`AgentConfig` field overrides on top of
+            :meth:`AgentConfig.from_env` defaults (e.g. ``worker_thread_count=4``).
 
     Raises:
         RuntimeError: If the singleton runtime already exists.  Call
@@ -74,19 +76,22 @@ def configure(config: Optional[AgentConfig] = None, **kwargs):
     Example::
 
         import conductor.ai.agents as ag
+        from conductor.client.configuration.configuration import Configuration
 
-        ag.configure(server_url="https://prod:8080/api")
+        ag.configure(configuration=Configuration(server_api_url="https://prod:8080/api"))
         result = ag.run(agent, "Hello!")
     """
-    global _default_config, _default_runtime
+    global _default_config, _default_configuration, _default_runtime
     if _default_runtime is not None:
         raise RuntimeError(
             "configure() must be called before the first run/start/stream call. "
             "Call shutdown() first to reset the default runtime."
         )
+    if configuration is not None:
+        _default_configuration = configuration
     if config is not None:
         _default_config = config
-    else:
+    elif kwargs:
         from conductor.ai.agents.runtime.config import AgentConfig
 
         base = AgentConfig.from_env()
@@ -97,27 +102,6 @@ def configure(config: Optional[AgentConfig] = None, **kwargs):
         _default_config = base
 
 
-def _configuration_from(cfg: AgentConfig) -> Configuration:
-    """Map an :class:`AgentConfig`'s connection fields to a conductor
-    :class:`Configuration` (the sugar layer owns this mapping — the runtime
-    itself only accepts a ``Configuration``)."""
-    from conductor.client.configuration.configuration import Configuration
-    from conductor.client.configuration.settings.authentication_settings import (
-        AuthenticationSettings,
-    )
-
-    effective_key = cfg.api_key or cfg.auth_key
-    authentication_settings = (
-        AuthenticationSettings(key_id=effective_key, key_secret=cfg.auth_secret or "")
-        if effective_key
-        else None
-    )
-    return Configuration(
-        server_api_url=cfg.server_url,
-        authentication_settings=authentication_settings,
-    )
-
-
 def _get_default_runtime():
     """Return (or create) the module-level default AgentRuntime singleton."""
     global _default_runtime
@@ -126,12 +110,9 @@ def _get_default_runtime():
             if _default_runtime is None:
                 from conductor.ai.agents.runtime.runtime import AgentRuntime
 
-                if _default_config is not None:
-                    _default_runtime = AgentRuntime(
-                        _configuration_from(_default_config), settings=_default_config
-                    )
-                else:
-                    _default_runtime = AgentRuntime()
+                _default_runtime = AgentRuntime(
+                    _default_configuration, settings=_default_config
+                )
                 logger.info("Created default AgentRuntime singleton")
     return _default_runtime
 

src/conductor/ai/agents/runtime/config.py

@@ -8,8 +8,8 @@
 
 Usage::
 
-    config = AgentConfig.from_env()                          # load from env
-    config = AgentConfig(server_url="http://custom:8080/api")  # explicit
+    config = AgentConfig.from_env()               # load from env
+    config = AgentConfig(worker_thread_count=4)   # explicit override
 """
 
 from __future__ import annotations
@@ -44,77 +44,59 @@ def _env_int(var: str, default: int = 0) -> int:
     return int(val)
 
 
+def _env_float(var: str, default: float = 0.0) -> float:
+    """Read a float environment variable."""
+    val = os.environ.get(var)
+    if val is None or val.strip() == "":
+        return default
+    return float(val)
+
+
 @dataclass
 class AgentConfig:
-    """Configuration for the agents runtime.
+    """Agent-runtime settings.
+
+    Server connection and auth (URL, credentials) and the SDK-wide log level
+    live on the conductor :class:`Configuration`, not here — this holds only
+    agent-runtime concerns (worker pool + liveness monitoring).
 
     Attributes:
-        server_url: Agentspan server API URL.
-        api_key: Bearer token or static API key for the Authorization header.
-            Preferred over auth_key/auth_secret for new deployments.
-        auth_key: Auth key (kept for backward compatibility).
-        auth_secret: Auth secret (kept for backward compatibility).
         worker_poll_interval_ms: Worker polling interval in milliseconds.
         worker_thread_count: Number of threads per worker.
         auto_start_workers: Whether to auto-start worker processes.
         daemon_workers: Whether worker processes are daemon (killed on exit).
         auto_register_integrations: Auto-create LLM integrations on startup.
-        secret_strict_mode: When ``True``, disables env var fallback for
-            credential resolution. Required credentials must come from the
-            credential service.
-        log_level: Logging level for the agentspan logger.
+        streaming_enabled: Whether ``stream()`` uses server-sent events.
+        liveness_enabled: Start a server-liveness monitor for stateful runs so
+            ``result()`` / ``join()`` don't block forever if the worker dies.
+        liveness_stall_seconds: Idle window (no polls) before a run is
+            considered stalled.
+        liveness_check_interval_seconds: How often the monitor polls.
     """
 
-    server_url: str = "http://localhost:8080/api"
-    api_key: Optional[str] = None
-    auth_key: Optional[str] = None
-    auth_secret: Optional[str] = None
-    llm_retry_count: int = 3
     worker_poll_interval_ms: int = 100
     worker_thread_count: int = 1
     auto_start_workers: bool = True
     daemon_workers: bool = True
     auto_register_integrations: bool = False
     streaming_enabled: bool = True
-    secret_strict_mode: bool = False
-    log_level: str = "INFO"
-
-    def __post_init__(self):
-        """Normalise server_url: auto-append /api if missing."""
-        if self.server_url:
-            stripped = self.server_url.rstrip("/")
-            if not stripped.endswith("/api"):
-                logger.info(
-                    "server_url %r does not end with '/api' — appending automatically.",
-                    self.server_url,
-                )
-                self.server_url = stripped + "/api"
-            else:
-                self.server_url = stripped
+    liveness_enabled: bool = True
+    liveness_stall_seconds: float = 30.0
+    liveness_check_interval_seconds: float = 10.0
 
     @classmethod
     def from_env(cls) -> AgentConfig:
         """Create an ``AgentConfig`` by reading ``AGENTSPAN_*`` env vars."""
-        log_level = _env("AGENTSPAN_LOG_LEVEL", "INFO")
-        if isinstance(log_level, str) and log_level.strip() == "":
-            log_level = "INFO"
         return cls(
-            server_url=_env("AGENTSPAN_SERVER_URL", "http://localhost:8080/api"),
-            api_key=_env("AGENTSPAN_API_KEY"),
-            auth_key=_env("AGENTSPAN_AUTH_KEY"),
-            auth_secret=_env("AGENTSPAN_AUTH_SECRET"),
-            llm_retry_count=_env_int("AGENTSPAN_LLM_RETRY_COUNT", 3),
             worker_poll_interval_ms=_env_int("AGENTSPAN_WORKER_POLL_INTERVAL", 100),
             worker_thread_count=_env_int("AGENTSPAN_WORKER_THREADS", 1),
             auto_start_workers=_env_bool("AGENTSPAN_AUTO_START_WORKERS", True),
             daemon_workers=_env_bool("AGENTSPAN_DAEMON_WORKERS", True),
             auto_register_integrations=_env_bool("AGENTSPAN_INTEGRATIONS_AUTO_REGISTER", False),
             streaming_enabled=_env_bool("AGENTSPAN_STREAMING_ENABLED", True),
-            secret_strict_mode=_env_bool("AGENTSPAN_SECRET_STRICT_MODE", False),
-            log_level=log_level,
+            liveness_enabled=_env_bool("AGENTSPAN_LIVENESS_ENABLED", True),
+            liveness_stall_seconds=_env_float("AGENTSPAN_LIVENESS_STALL_SECONDS", 30.0),
+            liveness_check_interval_seconds=_env_float(
+                "AGENTSPAN_LIVENESS_CHECK_INTERVAL_SECONDS", 10.0
+            ),
         )
-
-    @property
-    def api_secret(self) -> Optional[str]:
-        """Alias for :attr:`auth_secret` (industry-standard naming)."""
-        return self.auth_secret

src/conductor/ai/agents/runtime/runtime.py

@@ -414,10 +414,8 @@ def __init__(
         self._integration_api_available: Optional[bool] = None
         self._sse_fallback_warned = False
 
-        # Apply user-configured log level to all conductor.ai loggers
-        logging.getLogger("conductor.ai").setLevel(
-            getattr(logging, self._config.log_level.upper(), logging.INFO)
-        )
+        # Apply the SDK-wide log level (from Configuration) to conductor.ai loggers
+        logging.getLogger("conductor.ai").setLevel(self._conductor_config.log_level)
 
         # Control-plane client for the agent API (start/deploy/compile/status/
         # execution/respond/stop/signal/SSE). Built from the same Conductor

src/conductor/client/configuration/configuration.py

@@ -31,7 +31,8 @@ def __init__(
             authentication_settings: AuthenticationSettings = None,
             server_api_url: Optional[str] = None,
             auth_token_ttl_min: int = 45,
-            register_schema: Optional[bool] = None
+            register_schema: Optional[bool] = None,
+            log_level=None
     ):
         if server_api_url is not None:
             self.host = server_api_url
@@ -59,8 +60,23 @@ def __init__(
                 self.authentication_settings = None
 
 
-        # Debug switch
+        # Debug switch (sets __log_level to DEBUG/INFO)
         self.debug = debug
+        # Explicit SDK-wide log level: a level name ("INFO", "DEBUG", …) or an
+        # int. Overrides the debug-derived default; falls back to the
+        # CONDUCTOR_LOG_LEVEL / AGENTSPAN_LOG_LEVEL env vars. Applies to every
+        # SDK component (clients, workers, agent runtime).
+        resolved_level = (
+            log_level
+            if log_level is not None
+            else (os.getenv("CONDUCTOR_LOG_LEVEL") or os.getenv("AGENTSPAN_LOG_LEVEL"))
+        )
+        if resolved_level is not None and str(resolved_level).strip() != "":
+            self.__log_level = (
+                resolved_level
+                if isinstance(resolved_level, int)
+                else getattr(logging, str(resolved_level).upper(), self.__log_level)
+            )
         # Log format
         self.logger_format = "%(asctime)s %(name)-12s %(levelname)-8s %(message)s"