add validation connection for customer provided model

Author: mainred

src/aks-sreclaw/azext_aks_sreclaw/__init__.py

@@ -3,9 +3,9 @@
 # Licensed under the MIT License. See License.txt in the project root for license information.
 # --------------------------------------------------------------------------------------------
 
-from azext_aks_sreclaw._client_factory import CUSTOM_MGMT_AKS
-
 # pylint: disable=unused-import
+import azext_aks_sreclaw._help
+from azext_aks_sreclaw._client_factory import CUSTOM_MGMT_AKS
 from azure.cli.core import AzCommandsLoader
 from azure.cli.core.profiles import register_resource_type
 

src/aks-sreclaw/azext_aks_sreclaw/custom.py

@@ -5,8 +5,6 @@
 
 # pylint: disable=too-many-lines, disable=broad-except, disable=line-too-long
 
-import subprocess
-
 from azext_aks_sreclaw.sreclaw.aks import get_aks_credentials
 from azext_aks_sreclaw.sreclaw.console import (
     ERROR_COLOR,
@@ -25,7 +23,6 @@
 from azure.cli.core.azclierror import AzCLIError
 from azure.cli.core.commands.client_factory import get_subscription_id
 from knack.log import get_logger
-from knack.util import CLIError
 
 logger = get_logger(__name__)
 
@@ -259,7 +256,6 @@ def aks_sreclaw_status(
         namespace,
 ):
     """Display the status of the SREClaw deployment."""
-    console = get_console()
 
     kubeconfig_path = get_aks_credentials(
         client,
@@ -453,7 +449,7 @@ def aks_sreclaw_connect(
             console.print(
                 f"🚀 Port-forwarding: localhost:{local_port} -> {aks_sreclaw_manager.chart_name}:{target_port}", style=INFO_COLOR)
             console.print(f"🌐 Open your browser and navigate to: http://localhost:{local_port}", style=INFO_COLOR)
-            console.print(f"Press Ctrl+C to stop\n", style="dim")
+            console.print("Press Ctrl+C to stop\n", style="dim")
 
             # Start blocking port-forward
             aks_sreclaw_manager.start_port_forward(pod_name, target_port, local_port)

src/aks-sreclaw/azext_aks_sreclaw/sreclaw/k8s/aks_sreclaw_manager.py

@@ -8,13 +8,11 @@
 import os
 import tempfile
 from abc import ABC, abstractmethod
-from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
 
 from azext_aks_sreclaw._consts import (
     AGENT_NAMESPACE,
     AKS_SRECLAW_LABEL_SELECTOR,
-    AKS_SRECLAW_VERSION,
 )
 from azext_aks_sreclaw.sreclaw.k8s.helm_manager import HelmManager
 from azext_aks_sreclaw.sreclaw.llm_config_manager import LLMConfigManager
@@ -480,7 +478,6 @@ def _wait_for_pods_ready(self, timeout: int = 300, interval: int = 5) -> bool:
 
         while time.time() - start_time < timeout:
             try:
-                # Check for pods with label selector
                 pod_list = self.core_v1.list_namespaced_pod(
                     namespace=self.namespace,
                     label_selector=AKS_SRECLAW_LABEL_SELECTOR
@@ -491,30 +488,7 @@ def _wait_for_pods_ready(self, timeout: int = 300, interval: int = 5) -> bool:
                     time.sleep(interval)
                     continue
 
-                # Check if all pods are ready
-                all_ready = True
-                for pod in pod_list.items:
-                    pod_name = pod.metadata.name
-                    pod_phase = pod.status.phase
-
-                    if pod_phase != "Running":
-                        logger.debug("Pod %s is in phase %s, waiting...", pod_name, pod_phase)
-                        all_ready = False
-                        break
-
-                    # Check pod readiness condition
-                    pod_ready = False
-                    if pod.status.conditions:
-                        for condition in pod.status.conditions:
-                            if condition.type == "Ready" and condition.status == "True":
-                                pod_ready = True
-                                break
-
-                    if not pod_ready:
-                        logger.debug("Pod %s is not ready yet, waiting...", pod_name)
-                        all_ready = False
-                        break
-
+                all_ready = self._check_all_pods_ready(pod_list.items)
                 if all_ready:
                     logger.info("All SREClaw pods are ready")
                     return True
@@ -531,6 +505,30 @@ def _wait_for_pods_ready(self, timeout: int = 300, interval: int = 5) -> bool:
         logger.warning("Timeout waiting for SREClaw pods to be ready")
         return False
 
+    def _check_all_pods_ready(self, pods) -> bool:
+        """Check if all pods are ready."""
+        for pod in pods:
+            pod_name = pod.metadata.name
+            pod_phase = pod.status.phase
+
+            if pod_phase != "Running":
+                logger.debug("Pod %s is in phase %s, waiting...", pod_name, pod_phase)
+                return False
+
+            if not self._is_pod_ready(pod):
+                logger.debug("Pod %s is not ready yet, waiting...", pod_name)
+                return False
+
+        return True
+
+    def _is_pod_ready(self, pod) -> bool:
+        """Check if a pod is ready."""
+        if pod.status.conditions:
+            for condition in pod.status.conditions:
+                if condition.type == "Ready" and condition.status == "True":
+                    return True
+        return False
+
     def deploy_sreclaw(self, chart_version: Optional[str] = None, no_wait: bool = False) -> Tuple[bool, str]:
         """
         Deploy SREClaw using helm chart.
@@ -1042,7 +1040,7 @@ def get_gateway_token(self) -> str:
                 )
             raise AzCLIError(f"Failed to retrieve gateway token: {e}")
 
-    def port_forward_to_service(self, local_port: int = 18789) -> str:
+    def port_forward_to_service(self, local_port: int = 18789) -> str:  # pylint: disable=unused-argument
         """Port-forward to aks-sreclaw service.
 
         Args:
@@ -1054,12 +1052,6 @@ def port_forward_to_service(self, local_port: int = 18789) -> str:
         Raises:
             AzCLIError: If service or pod is not found, or port-forwarding fails
         """
-        import select
-        import socket
-        import threading
-
-        from kubernetes.stream import portforward
-
         # Get gateway token first before starting port-forward
         gateway_token = self.get_gateway_token()
 
@@ -1092,7 +1084,7 @@ def port_forward_to_service(self, local_port: int = 18789) -> str:
         pod_name = pod.metadata.name
         target_port = 18789
 
-        logger.info(f"Found running pod: {pod_name}")
+        logger.info("Found running pod: %s", pod_name)
 
         # Return token to caller before starting blocking port-forward
         return gateway_token, pod_name, target_port
@@ -1114,7 +1106,7 @@ def start_port_forward(self, pod_name: str, target_port: int, local_port: int =
 
         from kubernetes.stream import portforward
 
-        logger.info(f"Port-forwarding localhost:{local_port} -> {pod_name}:{target_port}")
+        logger.info("Port-forwarding localhost:%d -> %s:%d", local_port, pod_name, target_port)
 
         # Start a local TCP server and forward each connection through the k8s portforward API
         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -1146,7 +1138,7 @@ def _forward(local_conn, pf_socket):
                         if not data:
                             break
                         local_conn.sendall(data)
-            except Exception:
+            except Exception:  # pylint: disable=broad-exception-caught
                 pass
             finally:
                 local_conn.close()

src/aks-sreclaw/azext_aks_sreclaw/sreclaw/llm_config_manager.py

@@ -5,7 +5,6 @@
 
 from typing import Dict
 
-import yaml
 from azext_aks_sreclaw.sreclaw.llm_providers import LLMProvider
 from knack.log import get_logger
 

src/aks-sreclaw/azext_aks_sreclaw/sreclaw/llm_providers/anthropic_provider.py

@@ -6,7 +6,7 @@
 
 from typing import Tuple
 
-import requests
+from openai import OpenAI
 
 from .base import LLMProvider, non_empty
 
@@ -16,10 +16,6 @@ class AnthropicProvider(LLMProvider):
     def readable_name(self) -> str:
         return "Anthropic"
 
-    @property
-    def provider(self) -> str:
-        return "anthropic"
-
     @property
     def name(self) -> str:
         return "anthropic"
@@ -48,28 +44,24 @@ def validate_connection(self, params: dict) -> Tuple[str, str]:
             return "Missing required Anthropic parameters.", "retry_input"
 
         models = [m.strip() for m in models_str.split(",")]
-        model_name = models[0]
+        client = OpenAI(
+            api_key=api_key,
+            base_url="https://api.anthropic.com/v1"
+        )
 
-        url = "https://api.anthropic.com/v1/messages"
-        headers = {
-            "x-api-key": api_key,
-            "anthropic-version": "2023-06-01",
-            "Content-Type": "application/json"
-        }
-        payload = {
-            "model": model_name,
-            "max_tokens": 16,
-            "messages": [{"role": "user", "content": "ping"}]
-        }
+        for model_name in models:
+            try:
+                client.chat.completions.create(
+                    model=model_name,
+                    messages=[{"role": "user", "content": "ping"}],
+                    max_tokens=16,
+                    timeout=10
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                error_str = str(e).lower()
+                if any(x in error_str for x in ["api key", "authentication", "unauthorized",
+                                                "invalid", "bad request"]):
+                    return f"Model '{model_name}' validation failed: {e}", "retry_input"
+                return f"Model '{model_name}' connection error: {e}", "connection_error"
 
-        try:
-            resp = requests.post(url, headers=headers,
-                                 json=payload, timeout=10)
-            resp.raise_for_status()
-            return None, "save"
-        except requests.exceptions.HTTPError as e:
-            if 400 <= resp.status_code < 500:
-                return f"Client error: {e} - {resp.text}", "retry_input"
-            return f"Server error: {e} - {resp.text}", "connection_error"
-        except requests.exceptions.RequestException as e:
-            return f"Request error: {e}", "connection_error"
+        return None, "save"

src/aks-sreclaw/azext_aks_sreclaw/sreclaw/llm_providers/azure_provider.py

@@ -5,17 +5,13 @@
 
 
 from typing import Tuple
-from urllib.parse import urlencode, urljoin
 
-import requests
+from openai import AzureOpenAI
 
 from .base import LLMProvider, is_valid_url, non_empty
 
 
 def is_valid_api_base(v: str) -> bool:
-    # A valid api_base should be a URL and starts with https://, and ends with either .openai.azure.com/ or
-    # .cognitiveservices.azure.com/. Until there's a convergence on the endpoint format for Azure OpenAI service,
-    # we will accept both formats without validation.
     if not v.startswith("https://"):
         return False
     return is_valid_url(v)
@@ -36,7 +32,7 @@ def parameter_schema(self):
             "models": {
                 "secret": False,
                 "default": None,
-                "hint": "comma-separated model names, e.g., gpt-5.4,gpt-5.1",
+                "hint": "comma-separated deployment names, e.g., gpt-5.4,gpt-5.1",
                 "validator": non_empty,
                 "alias": "models"
             },
@@ -55,4 +51,32 @@ def parameter_schema(self):
         }
 
     def validate_connection(self, params: dict) -> Tuple[str, str]:
-        return None, "save"  # None error means success
+        api_key = params.get("api_key")
+        api_base = params.get("api_base")
+        models_str = params.get("models")
+
+        if not all([api_key, api_base, models_str]):
+            return "Missing required Azure OpenAI parameters.", "retry_input"
+
+        models = [m.strip() for m in models_str.split(",")]
+        client = AzureOpenAI(
+            api_key=api_key,
+            azure_endpoint=api_base
+        )
+
+        for model_name in models:
+            try:
+                client.responses.create(
+                    model=model_name,
+                    instructions="You are a helpful assistant.",
+                    input="ping",
+                    timeout=10
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                error_str = str(e).lower()
+                if any(x in error_str for x in ["api key", "authentication", "unauthorized",
+                                                "invalid", "bad request", "deployment"]):
+                    return f"Model '{model_name}' validation failed: {e}", "retry_input"
+                return f"Model '{model_name}' connection error: {e}", "connection_error"
+
+        return None, "save"

src/aks-sreclaw/azext_aks_sreclaw/sreclaw/llm_providers/base.py

@@ -4,7 +4,7 @@
 # --------------------------------------------------------------------------------------------
 
 
-import base64
+import base64  # pylint: disable=unused-import
 from abc import ABC, abstractmethod
 from typing import Any, Callable, Dict, Tuple
 from urllib.parse import urlparse
@@ -45,18 +45,11 @@ def readable_name(self) -> str:
     @property
     def name(self) -> str:
         """Return the provider name for this provider.
-        provider name is the key to identity a llmprovider.
-        https://docs.litellm.ai/docs/providers
+        This name is used as the OpenClaw LLM provider identifier and must match
+        the provider name expected by the OpenClaw configuration.
+        Examples: "azure-openai", "openai", "anthropic"
         """
-        return self.provider
-
-    def model_name(self, model_name) -> str:
-        """Return the model name for this provider.
-        The models name combines the model route and model name, e.g., "azure/gpt-5"
-        https://docs.litellm.ai/docs/providers
-        """
-
-        return model_name
+        return ""
 
     @property
     @abstractmethod
@@ -145,7 +138,6 @@ def validate_params(self, params: dict):
                 raise ValueError(f"Invalid value for parameter: {param}")
         return True
 
-    # pylint: disable=unused-argument
     @abstractmethod
     def validate_connection(self, params: dict) -> Tuple[str, str]:
         """
@@ -154,6 +146,4 @@ def validate_connection(self, params: dict) -> Tuple[str, str]:
         where error is None if validation is successful, otherwise contains the error message.
         Action can be "retry_input", "connection_error", or "save".
         """
-        # TODO(mainred): leverage 3rd party libraries like litellm instead of
-        # calling http request in each provider to complete the connection check.
         raise NotImplementedError()