agentex-sdk 0.1.0a6__py3-none-any.whl

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

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "{{ description }}"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "agentex-sdk",
+    "scale-gp",
+    "temporalio",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "black",
+    "isort",
+    "flake8",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["project"]
+
+[tool.black]
+line-length = 88
+target-version = ['py312']
+
+[tool.isort]
+profile = "black"
+line_length = 88

agentex/lib/cli/templates/temporal/requirements.txt.j2

@@ -0,0 +1,5 @@
+# Install agentex-sdk from local path
+agentex-sdk
+
+# Scale GenAI Platform Python SDK
+scale-gp

agentex/lib/cli/utils/cli_utils.py

@@ -0,0 +1,14 @@
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def handle_questionary_cancellation(
+    result: str | None, operation: str = "operation"
+) -> str:
+    """Handle questionary cancellation by checking for None and exiting gracefully"""
+    if result is None:
+        console.print(f"[yellow]{operation.capitalize()} cancelled by user[/yellow]")
+        raise typer.Exit(0)
+    return result

agentex/lib/cli/utils/credential_utils.py

@@ -0,0 +1,103 @@
+import subprocess
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from agentex.lib.types.credentials import CredentialMapping
+
+console = Console()
+
+
+def check_secret_exists(secret_name: str, namespace: str) -> bool:
+    """Check if a Kubernetes secret exists in the given namespace."""
+    try:
+        result = subprocess.run(
+            ["kubectl", "get", "secret", secret_name, "-n", namespace],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def create_env_var_secret(credential: CredentialMapping, namespace: str) -> bool:
+    """Create a generic secret for environment variable credentials."""
+    console.print(
+        f"[yellow]Secret '{credential.secret_name}' not found in namespace '{namespace}'[/yellow]"
+    )
+
+    if not Confirm.ask(
+        f"Would you like to create the secret '{credential.secret_name}'?"
+    ):
+        return False
+
+    # Prompt for the secret value
+    secret_value = Prompt.ask(
+        f"Enter the value for '{credential.secret_key}'", password=True
+    )
+
+    try:
+        # Create the secret using kubectl
+        subprocess.run(
+            [
+                "kubectl",
+                "create",
+                "secret",
+                "generic",
+                credential.secret_name,
+                f"--from-literal={credential.secret_key}={secret_value}",
+                "-n",
+                namespace,
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        console.print(
+            f"[green]✓ Created secret '{credential.secret_name}' in namespace '{namespace}'[/green]"
+        )
+        return True
+
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]✗ Failed to create secret: {e.stderr}[/red]")
+        return False
+
+
+# def create_image_pull_secret(credential: ImagePullCredential, namespace: str) -> bool:
+#     """Create an image pull secret with interactive prompts."""
+#     console.print(f"[yellow]Image pull secret '{credential.secret_name}' not found in namespace '{namespace}'[/yellow]")
+
+#     if not Confirm.ask(f"Would you like to create the image pull secret '{credential.secret_name}'?"):
+#         return False
+
+#     # Prompt for registry details
+#     registry_server = Prompt.ask("Docker registry server (e.g., docker.io, gcr.io)")
+#     username = Prompt.ask("Username")
+#     password = Prompt.ask("Password", password=True)
+#     email = Prompt.ask("Email (optional)", default="")
+
+#     try:
+#         # Create the image pull secret using kubectl
+#         cmd = [
+#             "kubectl", "create", "secret", "docker-registry",
+#             credential.secret_name,
+#             f"--docker-server={registry_server}",
+#             f"--docker-username={username}",
+#             f"--docker-password={password}",
+#             "-n", namespace
+#         ]
+
+#         if email:
+#             cmd.append(f"--docker-email={email}")
+
+#         result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+#         console.print(f"[green]✓ Created image pull secret '{credential.secret_name}' in namespace '{namespace}'[/green]")
+#         return True
+
+#     except subprocess.CalledProcessError as e:
+#         console.print(f"[red]✗ Failed to create image pull secret: {e.stderr}[/red]")
+#         return False

agentex/lib/cli/utils/exceptions.py

@@ -0,0 +1,6 @@
+class HelmError(Exception):
+    """An error occurred during helm operations"""
+
+
+class DeploymentError(Exception):
+    """An error occurred during deployment"""

agentex/lib/cli/utils/kubectl_utils.py

@@ -0,0 +1,135 @@
+import subprocess
+
+from kubernetes import client, config
+from kubernetes.client.rest import ApiException
+from rich.console import Console
+
+from agentex.lib.cli.utils.exceptions import DeploymentError
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+
+class KubernetesClientManager:
+    """Manages Kubernetes clients for different contexts"""
+
+    def __init__(self):
+        self._clients: dict[str, client.CoreV1Api] = {}
+
+    def get_client(self, context: str | None = None) -> client.CoreV1Api:
+        """Get a Kubernetes client for the specified context"""
+        if context is None:
+            context = get_current_context()
+
+        if context not in self._clients:
+            try:
+                # Load config for specific context
+                config.load_kube_config(context=context)
+                self._clients[context] = client.CoreV1Api()
+                logger.info(f"Created Kubernetes client for context: {context}")
+            except Exception as e:
+                raise DeploymentError(
+                    f"Failed to create Kubernetes client for context '{context}': {e}"
+                ) from e
+
+        return self._clients[context]
+
+    def clear_cache(self):
+        """Clear cached clients (useful when contexts change)"""
+        self._clients.clear()
+
+
+def get_current_context() -> str:
+    """Get the current kubectl context"""
+    try:
+        contexts, active_context = config.list_kube_config_contexts()
+        if active_context is None:
+            raise DeploymentError("No active kubectl context found")
+        return active_context["name"]
+    except Exception as e:
+        raise DeploymentError(f"Failed to get current kubectl context: {e}") from e
+
+
+# Global client manager instance
+_client_manager = KubernetesClientManager()
+
+
+def list_available_contexts() -> list[str]:
+    """List all available kubectl contexts"""
+    try:
+        contexts, _ = config.list_kube_config_contexts()
+        return [ctx["name"] for ctx in contexts]
+    except Exception as e:
+        raise DeploymentError(f"Failed to list kubectl contexts: {e}") from e
+
+
+def validate_cluster_context(cluster_name: str) -> bool:
+    """Check if a cluster name corresponds to an available kubectl context"""
+    try:
+        available_contexts = list_available_contexts()
+        return cluster_name in available_contexts
+    except DeploymentError:
+        return False
+
+
+def switch_kubectl_context(cluster_name: str) -> None:
+    """Switch to the specified kubectl context"""
+    try:
+        # Use subprocess for context switching as it's a local kubeconfig operation
+        subprocess.run(
+            ["kubectl", "config", "use-context", cluster_name],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        # Clear client cache since context changed
+        _client_manager.clear_cache()
+        logger.info(f"Switched to kubectl context: {cluster_name}")
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        raise DeploymentError(
+            f"Failed to switch to kubectl context '{cluster_name}': {e}"
+        ) from e
+
+
+def validate_namespace(namespace: str, context: str | None = None) -> bool:
+    """Check if a namespace exists in the specified cluster context"""
+    try:
+        k8s_client = _client_manager.get_client(context)
+        k8s_client.read_namespace(name=namespace)
+        return True
+    except ApiException as e:
+        if e.status == 404:
+            return False
+        raise DeploymentError(f"Failed to validate namespace '{namespace}': {e}") from e
+    except Exception as e:
+        raise DeploymentError(f"Failed to validate namespace '{namespace}': {e}") from e
+
+
+def check_and_switch_cluster_context(cluster_name: str) -> None:
+    """Check and switch to the specified kubectl context"""
+    # Validate cluster context
+    if not validate_cluster_context(cluster_name):
+        available_contexts = list_available_contexts()
+        raise DeploymentError(
+            f"Cluster '{cluster_name}' not found in kubectl contexts.\n"
+            f"Available contexts: {', '.join(available_contexts)}\n"
+            f"Please ensure you have a valid kubeconfig for this cluster."
+        )
+
+    # Switch to the specified cluster context
+    current_context = get_current_context()
+    if current_context != cluster_name:
+        console.print(
+            f"[blue]ℹ[/blue] Switching from context '{current_context}' to '{cluster_name}'"
+        )
+        switch_kubectl_context(cluster_name)
+    else:
+        console.print(
+            f"[blue]ℹ[/blue] Using current kubectl context: [bold]{cluster_name}[/bold]"
+        )
+
+
+def get_k8s_client(context: str | None = None) -> client.CoreV1Api:
+    """Get a Kubernetes client for the specified context (or current context if None)"""
+    return _client_manager.get_client(context)

agentex/lib/cli/utils/kubernetes_secrets_utils.py

@@ -0,0 +1,185 @@
+import base64
+
+from kubernetes import client
+from kubernetes.client.rest import ApiException
+from rich.console import Console
+
+from agentex.lib.cli.utils.kubectl_utils import get_k8s_client
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+console = Console()
+
+KUBERNETES_SECRET_TYPE_OPAQUE = "Opaque"
+KUBERNETES_SECRET_TYPE_DOCKERCONFIGJSON = "kubernetes.io/dockerconfigjson"
+KUBERNETES_SECRET_TYPE_BASIC_AUTH = "kubernetes.io/basic-auth"
+KUBERNETES_SECRET_TYPE_TLS = "kubernetes.io/tls"
+
+VALID_SECRET_TYPES = [
+    KUBERNETES_SECRET_TYPE_OPAQUE,
+    KUBERNETES_SECRET_TYPE_DOCKERCONFIGJSON,
+    KUBERNETES_SECRET_TYPE_BASIC_AUTH,
+    KUBERNETES_SECRET_TYPE_TLS,
+]
+
+KUBERNETES_SECRET_TO_MANIFEST_KEY = {
+    KUBERNETES_SECRET_TYPE_OPAQUE: "credentials",
+    KUBERNETES_SECRET_TYPE_DOCKERCONFIGJSON: "imagePullSecrets",
+}
+
+
+def _create_secret_object(
+    name: str, data: dict[str, str], secret_type: str = KUBERNETES_SECRET_TYPE_OPAQUE
+) -> client.V1Secret:
+    """Helper to create a V1Secret object with multiple key-value pairs"""
+    return client.V1Secret(
+        metadata=client.V1ObjectMeta(name=name),
+        type=secret_type,
+        string_data=data,  # Use string_data for automatic base64 encoding
+    )
+
+
+def create_secret_with_data(
+    name: str, data: dict[str, str], namespace: str, context: str | None = None
+) -> None:
+    """Create a new Kubernetes secret with multiple key-value pairs"""
+    v1 = get_k8s_client(context)
+
+    try:
+        # Check if secret exists
+        v1.read_namespaced_secret(name=name, namespace=namespace)
+        console.print(
+            f"[red]Error: Secret '{name}' already exists in namespace '{namespace}'[/red]"
+        )
+        return
+    except ApiException as e:
+        if e.status != 404:  # If error is not "Not Found"
+            raise
+
+    # Create the secret
+    secret = _create_secret_object(name, data)
+
+    try:
+        v1.create_namespaced_secret(namespace=namespace, body=secret)
+        console.print(
+            f"[green]Created secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+        )
+    except ApiException as e:
+        console.print(f"[red]Error creating secret: {e.reason}[/red]")
+        raise RuntimeError(f"Failed to create secret: {str(e)}") from e
+
+
+def update_secret_with_data(
+    name: str, data: dict[str, str], namespace: str, context: str | None = None
+) -> None:
+    """Create or update a Kubernetes secret with multiple key-value pairs"""
+    v1 = get_k8s_client(context)
+    secret = _create_secret_object(name, data)
+
+    try:
+        # Try to update first
+        v1.replace_namespaced_secret(name=name, namespace=namespace, body=secret)
+        console.print(
+            f"[green]Updated secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+        )
+    except ApiException as e:
+        if e.status == 404:
+            # Secret doesn't exist, create it
+            try:
+                v1.create_namespaced_secret(namespace=namespace, body=secret)
+                console.print(
+                    f"[green]Created secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+                )
+            except ApiException as create_error:
+                console.print(
+                    f"[red]Error creating secret: {create_error.reason}[/red]"
+                )
+                raise RuntimeError(
+                    f"Failed to create secret: {str(create_error)}"
+                ) from create_error
+        else:
+            console.print(f"[red]Error updating secret: {e.reason}[/red]")
+            raise RuntimeError(f"Failed to update secret: {str(e)}") from e
+
+
+def create_image_pull_secret_with_data(
+    name: str, data: dict[str, str], namespace: str, context: str | None = None
+) -> None:
+    """Create a new Kubernetes image pull secret with dockerconfigjson type"""
+    v1 = get_k8s_client(context)
+
+    try:
+        # Check if secret exists
+        v1.read_namespaced_secret(name=name, namespace=namespace)
+        console.print(
+            f"[red]Error: Secret '{name}' already exists in namespace '{namespace}'[/red]"
+        )
+        return
+    except ApiException as e:
+        if e.status != 404:  # If error is not "Not Found"
+            raise
+
+    # Create the secret with dockerconfigjson type
+    secret = _create_secret_object(name, data, KUBERNETES_SECRET_TYPE_DOCKERCONFIGJSON)
+
+    try:
+        v1.create_namespaced_secret(namespace=namespace, body=secret)
+        console.print(
+            f"[green]Created image pull secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+        )
+    except ApiException as e:
+        console.print(f"[red]Error creating image pull secret: {e.reason}[/red]")
+        raise RuntimeError(f"Failed to create image pull secret: {str(e)}") from e
+
+
+def update_image_pull_secret_with_data(
+    name: str, data: dict[str, str], namespace: str, context: str | None = None
+) -> None:
+    """Create or update a Kubernetes image pull secret with dockerconfigjson type"""
+    v1 = get_k8s_client(context)
+    secret = _create_secret_object(name, data, KUBERNETES_SECRET_TYPE_DOCKERCONFIGJSON)
+
+    try:
+        # Try to update first
+        v1.replace_namespaced_secret(name=name, namespace=namespace, body=secret)
+        console.print(
+            f"[green]Updated image pull secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+        )
+    except ApiException as e:
+        if e.status == 404:
+            # Secret doesn't exist, create it
+            try:
+                v1.create_namespaced_secret(namespace=namespace, body=secret)
+                console.print(
+                    f"[green]Created image pull secret '{name}' in namespace '{namespace}' with {len(data)} keys[/green]"
+                )
+            except ApiException as create_error:
+                console.print(
+                    f"[red]Error creating image pull secret: {create_error.reason}[/red]"
+                )
+                raise RuntimeError(
+                    f"Failed to create image pull secret: {str(create_error)}"
+                ) from create_error
+        else:
+            console.print(f"[red]Error updating image pull secret: {e.reason}[/red]")
+            raise RuntimeError(f"Failed to update image pull secret: {str(e)}") from e
+
+
+def get_secret_data(
+    name: str, namespace: str, context: str | None = None
+) -> dict[str, str]:
+    """Get the actual data from a secret"""
+    v1 = get_k8s_client(context)
+    try:
+        secret = v1.read_namespaced_secret(name=name, namespace=namespace)
+        if secret.data:
+            # Decode base64 data
+            return {
+                key: base64.b64decode(value).decode("utf-8")
+                for key, value in secret.data.items()
+            }
+        return {}
+    except ApiException as e:
+        if e.status == 404:
+            return {}
+        raise RuntimeError(f"Failed to get secret data: {str(e)}") from e

agentex/lib/core/adapters/llm/__init__.py

@@ -0,0 +1 @@
+

agentex/lib/core/adapters/llm/adapter_litellm.py

@@ -0,0 +1,46 @@
+from collections.abc import AsyncGenerator, Generator
+
+import litellm as llm
+
+from agentex.lib.core.adapters.llm.port import LLMGateway
+from agentex.lib.types.llm_messages import Completion
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+
+
+class LiteLLMGateway(LLMGateway):
+    def completion(self, *args, **kwargs) -> Completion:
+        if kwargs.get("stream", True):
+            raise ValueError(
+                "Please use self.completion_stream instead of self.completion to stream responses"
+            )
+
+        response = llm.completion(*args, **kwargs)
+        return Completion.model_validate(response)
+
+    def completion_stream(self, *args, **kwargs) -> Generator[Completion, None, None]:
+        if not kwargs.get("stream"):
+            raise ValueError("To use streaming, please set stream=True in the kwargs")
+
+        for chunk in llm.completion(*args, **kwargs):
+            yield Completion.model_validate(chunk)
+
+    async def acompletion(self, *args, **kwargs) -> Completion:
+        if kwargs.get("stream", True):
+            raise ValueError(
+                "Please use self.acompletion_stream instead of self.acompletion to stream responses"
+            )
+
+        # Return a single completion for non-streaming
+        response = await llm.acompletion(*args, **kwargs)
+        return Completion.model_validate(response)
+
+    async def acompletion_stream(
+        self, *args, **kwargs
+    ) -> AsyncGenerator[Completion, None]:
+        if not kwargs.get("stream"):
+            raise ValueError("To use streaming, please set stream=True in the kwargs")
+
+        async for chunk in await llm.acompletion(*args, **kwargs):
+            yield Completion.model_validate(chunk)

agentex/lib/core/adapters/llm/adapter_sgp.py

@@ -0,0 +1,55 @@
+import os
+from collections.abc import AsyncGenerator, Generator
+
+from scale_gp import AsyncSGPClient, SGPClient
+
+from agentex.lib.core.adapters.llm.port import LLMGateway
+from agentex.lib.types.llm_messages import Completion
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+
+
+class SGPLLMGateway(LLMGateway):
+    def __init__(self, sgp_api_key: str | None = None):
+        self.sync_client = SGPClient(api_key=os.environ.get("SGP_API_KEY", sgp_api_key))
+        self.async_client = AsyncSGPClient(
+            api_key=os.environ.get("SGP_API_KEY", sgp_api_key)
+        )
+
+    def completion(self, *args, **kwargs) -> Completion:
+        if kwargs.get("stream", True):
+            raise ValueError(
+                "Please use self.completion_stream instead of self.completion to stream responses"
+            )
+
+        response = self.sync_client.beta.chat.completions.create(*args, **kwargs)
+        return Completion.model_validate(response)
+
+    def completion_stream(self, *args, **kwargs) -> Generator[Completion, None, None]:
+        if not kwargs.get("stream"):
+            raise ValueError("To use streaming, please set stream=True in the kwargs")
+
+        for chunk in self.sync_client.beta.chat.completions.create(*args, **kwargs):
+            yield Completion.model_validate(chunk)
+
+    async def acompletion(self, *args, **kwargs) -> Completion:
+        if kwargs.get("stream", True):
+            raise ValueError(
+                "Please use self.acompletion_stream instead of self.acompletion to stream responses"
+            )
+
+        # Return a single completion for non-streaming
+        response = await self.async_client.beta.chat.completions.create(*args, **kwargs)
+        return Completion.model_validate(response)
+
+    async def acompletion_stream(
+        self, *args, **kwargs
+    ) -> AsyncGenerator[Completion, None]:
+        if not kwargs.get("stream"):
+            raise ValueError("To use streaming, please set stream=True in the kwargs")
+
+        async for chunk in await self.async_client.beta.chat.completions.create(
+            *args, **kwargs
+        ):
+            yield Completion.model_validate(chunk)

agentex/lib/core/adapters/llm/port.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator, Generator
+
+from agentex.lib.types.llm_messages import Completion
+
+
+class LLMGateway(ABC):
+    @abstractmethod
+    def completion(self, *args, **kwargs) -> Completion:
+        raise NotImplementedError
+
+    @abstractmethod
+    def completion_stream(self, *args, **kwargs) -> Generator[Completion, None, None]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def acompletion(self, *args, **kwargs) -> Completion:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def acompletion_stream(
+        self, *args, **kwargs
+    ) -> AsyncGenerator[Completion, None]:
+        raise NotImplementedError