agentex-sdk 0.4.18__py3-none-any.whl → 0.4.20__py3-none-any.whl

agentex/lib/core/temporal/activities/adk/streaming_activities.py

@@ -2,11 +2,11 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.streaming import StreamingService
-from agentex.types.task_message_update import TaskMessageUpdate
 from agentex.lib.utils.logging import make_logger
-from agentex.lib.utils.model_utils import BaseModel
 from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.utils.model_utils import BaseModel
+from agentex.types.task_message_update import TaskMessageUpdate
+from agentex.lib.core.services.adk.streaming import StreamingService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/tasks_activities.py

@@ -2,10 +2,10 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.tasks import TasksService
 from agentex.types.task import Task
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.services.adk.tasks import TasksService
 
 logger = make_logger(__name__)
 
@@ -40,7 +40,7 @@ class TasksActivities:
 
     @activity.defn(name=TasksActivityName.DELETE_TASK)
     async def delete_task(self, params: DeleteTaskParams) -> Task:
-        return await self._tasks_service.delete_task(
+        return await self._tasks_service.delete_task(  # type: ignore[return-value]
             task_id=params.task_id,
             task_name=params.task_name,
             trace_id=params.trace_id,

agentex/lib/core/temporal/activities/adk/tracing_activities.py

@@ -3,10 +3,10 @@ from typing import Any
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.tracing import TracingService
 from agentex.types.span import Span
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.model_utils import BaseModel
+from agentex.lib.core.services.adk.tracing import TracingService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/utils/templating_activities.py

@@ -3,8 +3,8 @@ from typing import Any
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.utils.templating import TemplatingService
 from agentex.lib.types.tracing import BaseModelWithTraceParams
+from agentex.lib.core.services.adk.utils.templating import TemplatingService
 
 
 class JinjaActivityName(str, Enum):

agentex/lib/core/temporal/services/temporal_task_service.py

@@ -1,13 +1,13 @@
 from typing import Any
-from agentex.lib.core.clients.temporal.temporal_client import TemporalClient
-from agentex.lib.core.clients.temporal.types import WorkflowState
-from agentex.lib.core.temporal.types.workflow import SignalName
-from agentex.lib.environment_variables import EnvironmentVariables
-from agentex.lib.types.acp import CreateTaskParams
-from agentex.lib.types.acp import SendEventParams
+
+from agentex.types.task import Task
 from agentex.types.agent import Agent
 from agentex.types.event import Event
-from agentex.types.task import Task
+from agentex.lib.types.acp import SendEventParams, CreateTaskParams
+from agentex.lib.environment_variables import EnvironmentVariables
+from agentex.lib.core.clients.temporal.types import WorkflowState
+from agentex.lib.core.temporal.types.workflow import SignalName
+from agentex.lib.core.clients.temporal.temporal_client import TemporalClient
 
 
 class TemporalTaskService:

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

@@ -1,28 +1,28 @@
-import dataclasses
-import datetime
 import os
 import uuid
+import datetime
+import dataclasses
+from typing import Any, overload, override
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, overload
 
 from aiohttp import web
 from temporalio.client import Client, Plugin as ClientPlugin
+from temporalio.worker import (
+    Plugin as WorkerPlugin,
+    Worker,
+    UnsandboxedWorkflowRunner,
+)
+from temporalio.runtime import Runtime, TelemetryConfig, OpenTelemetryConfig
 from temporalio.converter import (
-    AdvancedJSONEncoder,
-    CompositePayloadConverter,
     DataConverter,
+    JSONTypeConverter,
+    AdvancedJSONEncoder,
     DefaultPayloadConverter,
+    CompositePayloadConverter,
     JSONPlainPayloadConverter,
-    JSONTypeConverter,
     _JSONTypeConverterUnhandled,
 )
-from temporalio.runtime import OpenTelemetryConfig, Runtime, TelemetryConfig
-from temporalio.worker import (
-    Plugin as WorkerPlugin,
-    UnsandboxedWorkflowRunner,
-    Worker,
-)
 
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.registration import register_agent
@@ -32,6 +32,7 @@ logger = make_logger(__name__)
 
 
 class DateTimeJSONEncoder(AdvancedJSONEncoder):
+    @override
     def default(self, o: Any) -> Any:
         if isinstance(o, datetime.datetime):
             return o.isoformat()
@@ -39,9 +40,8 @@ class DateTimeJSONEncoder(AdvancedJSONEncoder):
 
 
 class DateTimeJSONTypeConverter(JSONTypeConverter):
-    def to_typed_value(
-        self, hint: type, value: Any
-    ) -> Any | None | _JSONTypeConverterUnhandled:
+    @override
+    def to_typed_value(self, hint: type, value: Any) -> Any | None | _JSONTypeConverterUnhandled:
         if hint == datetime.datetime:
             return datetime.datetime.fromisoformat(value)
         return JSONTypeConverter.Unhandled
@@ -66,6 +66,7 @@ custom_data_converter = dataclasses.replace(
     payload_converter_class=DateTimePayloadConverter,
 )
 
+
 def _validate_plugins(plugins: list) -> None:
     """Validate that all items in the plugins list are valid Temporal plugins."""
     for i, plugin in enumerate(plugins):
@@ -76,10 +77,8 @@ def _validate_plugins(plugins: list) -> None:
             )
 
 
-
-async def get_temporal_client(temporal_address: str, metrics_url: str = None, plugins: list = []) -> Client:
-
-    if plugins != []: # We don't need to validate the plugins if they are empty
+async def get_temporal_client(temporal_address: str, metrics_url: str | None = None, plugins: list = []) -> Client:
+    if plugins != []:  # We don't need to validate the plugins if they are empty
         _validate_plugins(plugins)
 
     if not metrics_url:
@@ -87,13 +86,12 @@ async def get_temporal_client(temporal_address: str, metrics_url: str = None, pl
             target_host=temporal_address, data_converter=custom_data_converter, plugins=plugins
         )
     else:
-        runtime = Runtime(
-            telemetry=TelemetryConfig(metrics=OpenTelemetryConfig(url=metrics_url))
-        )
+        runtime = Runtime(telemetry=TelemetryConfig(metrics=OpenTelemetryConfig(url=metrics_url)))
         client = await Client.connect(
             target_host=temporal_address,
             data_converter=custom_data_converter,
             runtime=runtime,
+            plugins=plugins,
         )
     return client
 
@@ -123,7 +121,7 @@ class AgentexWorker:
         *,
         workflow: type,
     ) -> None: ...
-    
+
     @overload
     async def run(
         self,
@@ -145,15 +143,15 @@ class AgentexWorker:
             temporal_address=os.environ.get("TEMPORAL_ADDRESS", "localhost:7233"),
             plugins=self.plugins,
         )
-        
+
         # 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")
-        
+
         if workflow is None and workflows is None:
             raise ValueError("Either workflow or workflows must be provided")
-        
+
         worker = Worker(
             client=temporal_client,
             task_queue=self.task_queue,
@@ -178,7 +176,7 @@ class AgentexWorker:
     async def start_health_check_server(self):
         if not self.health_check_server_running:
             app = web.Application()
-            app.router.add_get("/readyz", lambda request: self._health_check())
+            app.router.add_get("/readyz", lambda request: self._health_check())  # noqa: ARG005
 
             # Disable access logging
             runner = web.AppRunner(app, access_log=None)
@@ -187,27 +185,19 @@ class AgentexWorker:
             try:
                 site = web.TCPSite(runner, "0.0.0.0", self.health_check_port)
                 await site.start()
-                logger.info(
-                    f"Health check server running on http://0.0.0.0:{self.health_check_port}/readyz"
-                )
+                logger.info(f"Health check server running on http://0.0.0.0:{self.health_check_port}/readyz")
                 self.health_check_server_running = True
             except OSError as e:
-                logger.error(
-                    f"Failed to start health check server on port {self.health_check_port}: {e}"
-                )
+                logger.error(f"Failed to start health check server on port {self.health_check_port}: {e}")
                 # Try alternative port if default fails
                 try:
                     alt_port = self.health_check_port + 1
                     site = web.TCPSite(runner, "0.0.0.0", alt_port)
                     await site.start()
-                    logger.info(
-                        f"Health check server running on alternative port http://0.0.0.0:{alt_port}/readyz"
-                    )
+                    logger.info(f"Health check server running on alternative port http://0.0.0.0:{alt_port}/readyz")
                     self.health_check_server_running = True
                 except OSError as e:
-                    logger.error(
-                        f"Failed to start health check server on alternative port {alt_port}: {e}"
-                    )
+                    logger.error(f"Failed to start health check server on alternative port {alt_port}: {e}")
                     raise
 
     """
@@ -217,9 +207,10 @@ class AgentexWorker:
     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")
+            logger.warning("AGENTEX_BASE_URL not set, skipping worker registration")

agentex/lib/core/temporal/workflows/workflow.py

@@ -2,9 +2,9 @@ from abc import ABC, abstractmethod
 
 from temporalio import workflow
 
-from agentex.lib.core.temporal.types.workflow import SignalName
-from agentex.lib.types.acp import CreateTaskParams, SendEventParams
+from agentex.lib.types.acp import SendEventParams, CreateTaskParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.temporal.types.workflow import SignalName
 
 logger = make_logger(__name__)
 

agentex/lib/core/tracing/__init__.py

@@ -1,5 +1,5 @@
-from agentex.lib.core.tracing.trace import AsyncTrace, Trace
-from agentex.lib.core.tracing.tracer import AsyncTracer, Tracer
 from agentex.types.span import Span
+from agentex.lib.core.tracing.trace import Trace, AsyncTrace
+from agentex.lib.core.tracing.tracer import Tracer, AsyncTracer
 
 __all__ = ["Trace", "AsyncTrace", "Span", "Tracer", "AsyncTracer"]

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

@@ -1,17 +1,17 @@
 from typing import Any, Dict, override
 
-from agentex import Agentex, AsyncAgentex
+from agentex import Agentex
+from agentex.types.span import Span
+from agentex.lib.types.tracing import AgentexTracingProcessorConfig
 from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
-    AsyncTracingProcessor,
     SyncTracingProcessor,
+    AsyncTracingProcessor,
 )
-from agentex.types.span import Span
-from agentex.lib.types.tracing import AgentexTracingProcessorConfig
 
 
 class AgentexSyncTracingProcessor(SyncTracingProcessor):
-    def __init__(self, config: AgentexTracingProcessorConfig):
+    def __init__(self, config: AgentexTracingProcessorConfig):  # noqa: ARG002
         self.client = Agentex()
 
     @override
@@ -65,7 +65,7 @@ class AgentexSyncTracingProcessor(SyncTracingProcessor):
 
 
 class AgentexAsyncTracingProcessor(AsyncTracingProcessor):
-    def __init__(self, config: AgentexTracingProcessorConfig):
+    def __init__(self, config: AgentexTracingProcessorConfig):  # noqa: ARG002
         self.client = create_async_agentex_client()
 
     @override

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

@@ -1,17 +1,17 @@
 from typing import override
 
 import scale_gp_beta.lib.tracing as tracing
-from scale_gp_beta import AsyncSGPClient, SGPClient
+from scale_gp_beta import SGPClient, AsyncSGPClient
 from scale_gp_beta.lib.tracing import create_span, flush_queue
 from scale_gp_beta.lib.tracing.span import Span as SGPSpan
 
-from agentex.lib.core.tracing.processors.tracing_processor_interface import (
-    AsyncTracingProcessor,
-    SyncTracingProcessor,
-)
 from agentex.types.span import Span
 from agentex.lib.types.tracing import SGPTracingProcessorConfig
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.tracing.processors.tracing_processor_interface import (
+    SyncTracingProcessor,
+    AsyncTracingProcessor,
+)
 
 logger = make_logger(__name__)
 
@@ -36,7 +36,7 @@ class SGPSyncTracingProcessor(SyncTracingProcessor):
             output=span.output,
             metadata=span.data,
         )
-        sgp_span.start_time = span.start_time.isoformat()
+        sgp_span.start_time = span.start_time.isoformat()  # type: ignore[union-attr]
         sgp_span.flush(blocking=False)
 
         self._spans[span.id] = sgp_span
@@ -50,9 +50,9 @@ class SGPSyncTracingProcessor(SyncTracingProcessor):
             )
             return
 
-        sgp_span.output = span.output
-        sgp_span.metadata = span.data
-        sgp_span.end_time = span.end_time.isoformat()
+        sgp_span.output = span.output  # type: ignore[assignment]
+        sgp_span.metadata = span.data  # type: ignore[assignment]
+        sgp_span.end_time = span.end_time.isoformat()  # type: ignore[union-attr]
         sgp_span.flush(blocking=False)
 
     @override
@@ -82,11 +82,11 @@ class SGPAsyncTracingProcessor(AsyncTracingProcessor):
             output=span.output,
             metadata=span.data,
         )
-        sgp_span.start_time = span.start_time.isoformat()
+        sgp_span.start_time = span.start_time.isoformat()  # type: ignore[union-attr]
 
         if self.disabled:
             return
-        await self.sgp_async_client.spans.upsert_batch(
+        await self.sgp_async_client.spans.upsert_batch(  # type: ignore[union-attr]
             items=[sgp_span.to_request_params()]
         )
 
@@ -101,19 +101,19 @@ class SGPAsyncTracingProcessor(AsyncTracingProcessor):
             )
             return
 
-        sgp_span.output = span.output
-        sgp_span.metadata = span.data
-        sgp_span.end_time = span.end_time.isoformat()
+        sgp_span.output = span.output  # type: ignore[assignment]
+        sgp_span.metadata = span.data  # type: ignore[assignment]
+        sgp_span.end_time = span.end_time.isoformat()  # type: ignore[union-attr]
 
         if self.disabled:
             return
-        await self.sgp_async_client.spans.upsert_batch(
+        await self.sgp_async_client.spans.upsert_batch(  # type: ignore[union-attr]
             items=[sgp_span.to_request_params()]
         )
 
     @override
     async def shutdown(self) -> None:
-        await self.sgp_async_client.spans.upsert_batch(
+        await self.sgp_async_client.spans.upsert_batch(  # type: ignore[union-attr]
             items=[sgp_span.to_request_params() for sgp_span in self._spans.values()]
         )
         self._spans.clear()

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

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
-from agentex.lib.types.tracing import TracingProcessorConfig
 from agentex.types.span import Span
+from agentex.lib.types.tracing import TracingProcessorConfig
 
 
 class SyncTracingProcessor(ABC):

agentex/lib/core/tracing/trace.py

@@ -1,19 +1,19 @@
+import uuid
 import asyncio
-from contextlib import asynccontextmanager, contextmanager
-from datetime import UTC, datetime
 from typing import Any, AsyncGenerator
-import uuid
+from datetime import UTC, datetime
+from contextlib import contextmanager, asynccontextmanager
 
 from pydantic import BaseModel
 
 from agentex import Agentex, AsyncAgentex
+from agentex.types.span import Span
+from agentex.lib.utils.logging import make_logger
+from agentex.lib.utils.model_utils import recursive_model_dump
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
-    AsyncTracingProcessor,
     SyncTracingProcessor,
+    AsyncTracingProcessor,
 )
-from agentex.lib.utils.logging import make_logger
-from agentex.lib.utils.model_utils import recursive_model_dump
-from agentex.types.span import Span
 
 logger = make_logger(__name__)
 

agentex/lib/core/tracing/tracer.py

@@ -1,8 +1,8 @@
 from agentex import Agentex, AsyncAgentex
-from agentex.lib.core.tracing.trace import AsyncTrace, Trace
+from agentex.lib.core.tracing.trace import Trace, AsyncTrace
 from agentex.lib.core.tracing.tracing_processor_manager import (
-    get_async_tracing_processors,
     get_sync_tracing_processors,
+    get_async_tracing_processors,
 )
 
 

agentex/lib/core/tracing/tracing_processor_manager.py

@@ -1,38 +1,53 @@
+from typing import TYPE_CHECKING
 from threading import Lock
 
-from agentex.lib.core.tracing.processors.agentex_tracing_processor import (
-    AgentexAsyncTracingProcessor,
-    AgentexSyncTracingProcessor,
-)
+from agentex.lib.types.tracing import TracingProcessorConfig, AgentexTracingProcessorConfig
 from agentex.lib.core.tracing.processors.sgp_tracing_processor import (
-    SGPAsyncTracingProcessor,
     SGPSyncTracingProcessor,
+    SGPAsyncTracingProcessor,
 )
 from agentex.lib.core.tracing.processors.tracing_processor_interface import (
-    AsyncTracingProcessor,
     SyncTracingProcessor,
+    AsyncTracingProcessor,
 )
-from agentex.lib.types.tracing import AgentexTracingProcessorConfig, TracingProcessorConfig
+
+if TYPE_CHECKING:
+    from agentex.lib.core.tracing.processors.agentex_tracing_processor import (  # noqa: F401
+        AgentexSyncTracingProcessor,
+        AgentexAsyncTracingProcessor,
+    )
 
 
 class TracingProcessorManager:
     def __init__(self):
         # Mapping of processor config type to processor class
+        # Use lazy loading for agentex processors to avoid circular imports
         self.sync_config_registry: dict[str, type[SyncTracingProcessor]] = {
-            "agentex": AgentexSyncTracingProcessor,
             "sgp": SGPSyncTracingProcessor,
         }
         self.async_config_registry: dict[str, type[AsyncTracingProcessor]] = {
-            "agentex": AgentexAsyncTracingProcessor,
             "sgp": SGPAsyncTracingProcessor,
         }
         # Cache for processors
         self.sync_processors: list[SyncTracingProcessor] = []
         self.async_processors: list[AsyncTracingProcessor] = []
         self.lock = Lock()
+        self._agentex_registered = False
+
+    def _ensure_agentex_registered(self):
+        """Lazily register agentex processors to avoid circular imports."""
+        if not self._agentex_registered:
+            from agentex.lib.core.tracing.processors.agentex_tracing_processor import (
+                AgentexSyncTracingProcessor,
+                AgentexAsyncTracingProcessor,
+            )
+            self.sync_config_registry["agentex"] = AgentexSyncTracingProcessor
+            self.async_config_registry["agentex"] = AgentexAsyncTracingProcessor
+            self._agentex_registered = True
 
     def add_processor_config(self, processor_config: TracingProcessorConfig) -> None:
         with self.lock:
+            self._ensure_agentex_registered()
             sync_processor = self.sync_config_registry[processor_config.type]
             async_processor = self.async_config_registry[processor_config.type]
             self.sync_processors.append(sync_processor(processor_config))
@@ -55,8 +70,23 @@ GLOBAL_TRACING_PROCESSOR_MANAGER = TracingProcessorManager()
 
 add_tracing_processor_config = GLOBAL_TRACING_PROCESSOR_MANAGER.add_processor_config
 set_tracing_processor_configs = GLOBAL_TRACING_PROCESSOR_MANAGER.set_processor_configs
-get_sync_tracing_processors = GLOBAL_TRACING_PROCESSOR_MANAGER.get_sync_processors
-get_async_tracing_processors = GLOBAL_TRACING_PROCESSOR_MANAGER.get_async_processors
 
-# Add the Agentex tracing processor by default
-add_tracing_processor_config(AgentexTracingProcessorConfig())
+# Lazy initialization to avoid circular imports
+_default_initialized = False
+
+def _ensure_default_initialized():
+    """Ensure default processor is initialized (lazy to avoid circular imports)."""
+    global _default_initialized
+    if not _default_initialized:
+        add_tracing_processor_config(AgentexTracingProcessorConfig())
+        _default_initialized = True
+
+def get_sync_tracing_processors():
+    """Get sync processors, initializing defaults if needed."""
+    _ensure_default_initialized()
+    return GLOBAL_TRACING_PROCESSOR_MANAGER.get_sync_processors()
+
+def get_async_tracing_processors():
+    """Get async processors, initializing defaults if needed."""
+    _ensure_default_initialized()
+    return GLOBAL_TRACING_PROCESSOR_MANAGER.get_async_processors()

agentex/lib/environment_variables.py

@@ -5,9 +5,9 @@ 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.logging import make_logger
 from agentex.lib.utils.model_utils import BaseModel
 
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
@@ -39,12 +39,13 @@ class EnvVarKeys(str, Enum):
 
 
 class Environment(str, Enum):
+    LOCAL = "local"
     DEV = "development"
     STAGING = "staging"
     PROD = "production"
 
 
-refreshed_environment_variables: "EnvironmentVariables" | None = None
+refreshed_environment_variables: EnvironmentVariables | None = None
 
 
 class EnvironmentVariables(BaseModel):
@@ -79,13 +80,13 @@ class EnvironmentVariables(BaseModel):
             # Load global .env file first
             global_env_path = PROJECT_ROOT / ".env"
             if global_env_path.exists():
-                print(f"Loading global environment variables FROM: {global_env_path}")
+                logger.debug(f"Loading global environment variables FROM: {global_env_path}")
                 load_dotenv(dotenv_path=global_env_path, override=False)
 
             # Load local project .env.local file (takes precedence)
             local_env_path = Path.cwd().parent / ".env.local"
             if local_env_path.exists():
-                print(f"Loading local environment variables FROM: {local_env_path}")
+                logger.debug(f"Loading local environment variables FROM: {local_env_path}")
                 load_dotenv(dotenv_path=local_env_path, override=True)
 
         # Create kwargs dict with environment variables, using None for missing values

agentex/lib/sdk/config/agent_config.py

@@ -2,10 +2,10 @@ from typing import Any, Literal
 
 from pydantic import Field
 
-from agentex.lib.types.agent_configs import TemporalConfig, TemporalWorkflowConfig
-from agentex.lib.types.credentials import CredentialMapping
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.types.credentials import CredentialMapping
 from agentex.lib.utils.model_utils import BaseModel
+from agentex.lib.types.agent_configs import TemporalConfig, TemporalWorkflowConfig
 
 logger = make_logger(__name__)
 

agentex/lib/sdk/config/agent_manifest.py

@@ -1,25 +1,25 @@
 from __future__ import annotations
 
 import io
+import time
 import shutil
-import subprocess
 import tarfile
 import tempfile
-import time
-from collections.abc import Iterator
-from contextlib import contextmanager
-from pathlib import Path
+import subprocess
 from typing import IO, Any
+from pathlib import Path
+from contextlib import contextmanager
+from collections.abc import Iterator
 
 from pydantic import Field
 
+from agentex.lib.utils.logging import make_logger
+from agentex.lib.utils.model_utils import BaseModel
 from agentex.lib.sdk.config.agent_config import AgentConfig
 from agentex.lib.sdk.config.build_config import BuildConfig
-from agentex.lib.sdk.config.environment_config import AgentEnvironmentsConfig
 from agentex.lib.sdk.config.deployment_config import DeploymentConfig
+from agentex.lib.sdk.config.environment_config import AgentEnvironmentsConfig
 from agentex.lib.sdk.config.local_development_config import LocalDevelopmentConfig
-from agentex.lib.utils.logging import make_logger
-from agentex.lib.utils.model_utils import BaseModel
 
 logger = make_logger(__name__)
 

agentex/lib/sdk/config/environment_config.py

@@ -7,11 +7,11 @@ configurations that are separate from the main manifest.yaml file.
 
 from __future__ import annotations
 
-from pathlib import Path
 from typing import Any, Dict, override
+from pathlib import Path
 
 import yaml
-from pydantic import BaseModel, Field, field_validator
+from pydantic import Field, BaseModel, field_validator
 
 from agentex.lib.utils.model_utils import BaseModel as UtilsBaseModel
 
@@ -73,6 +73,14 @@ class AgentEnvironmentConfig(BaseModel):
         ..., 
         description="Authentication and authorization configuration"
     )
+    helm_repository_name: str = Field(
+        default="scale-egp", 
+        description="Helm repository name for the environment"
+    )
+    helm_repository_url: str = Field(
+        default="https://scale-egp-helm-charts-us-west-2.s3.amazonaws.com/charts", 
+        description="Helm repository url for the environment"
+    )
     helm_overrides: Dict[str, Any] = Field(
         default_factory=dict, 
         description="Helm chart value overrides for environment-specific tuning"