gaard-api 0.1.1__tar.gz → 0.1.3__tar.gz

{gaard_api-0.1.1/src/gaard_api.egg-info → gaard_api-0.1.3}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.1.1
+Version: 0.1.3
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: gaard-core==0.1.0
-Requires-Dist: gaard-connectors==0.1.0
+Requires-Dist: gaard-connectors==0.1.1
 Requires-Dist: gaard-llm==0.1.0
+Requires-Dist: gaard-plugin-api<0.2.0,>=0.1.0
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.30.0
 Requires-Dist: pydantic>=2.7.0

{gaard_api-0.1.1 → gaard_api-0.1.3}/pyproject.toml

@@ -4,15 +4,16 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gaard-api"
-version = "0.1.1"
+version = "0.1.3"
 description = "GAARD backend web services providing admin interface"
 readme = "README.md"
 requires-python = ">=3.11"
 
 dependencies = [
     "gaard-core==0.1.0",
-    "gaard-connectors==0.1.0",
+    "gaard-connectors==0.1.1",
     "gaard-llm==0.1.0",
+    "gaard-plugin-api>=0.1.0,<0.2.0",
     "fastapi>=0.111.0",
     "uvicorn[standard]>=0.30.0",
     "pydantic>=2.7.0",

{gaard_api-0.1.1 → gaard_api-0.1.3}/src/gaard_api/admin/services.py

@@ -5,12 +5,10 @@ from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
 from typing import Any
 
-from sqlalchemy import create_engine, text
 from sqlalchemy import delete, desc, select
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session
 
-from gaard_connectors.sqlalchemy.introspector import SQLAlchemySchemaIntrospector
 from gaard_core.errors import LlmProviderError
 from gaard_core.llm_output import remove_thinking_blocks
 from gaard_core.query_pipeline.models import OutputClassification, QueryRequest, QueryResponse
@@ -33,6 +31,7 @@ from gaard_api.admin.models import (
     PromptTemplate,
 )
 from gaard_api.core.settings import settings
+from gaard_api.extensions import get_connector_registry
 
 
 def json_dumps(value: Any) -> str:
@@ -43,24 +42,16 @@ def json_loads(value: str) -> Any:
     return json.loads(value or "{}")
 
 
-SUPPORTED_DATABASE_TYPES = {
-    "sqlite": ("sqlite://", "sqlite"),
-    "postgresql": ("postgresql://", "postgresql+psycopg://"),
-    "mysql": ("mysql://", "mysql+pymysql://"),
-}
-
-
 def validate_datasource_url(database_type: str, database_url: str) -> None:
-    prefixes = SUPPORTED_DATABASE_TYPES.get(database_type)
+    get_connector_registry().get(database_type).validate_database_url(database_url)
 
-    if prefixes is None:
-        raise ValueError("Unsupported datasource type.")
 
-    if not database_url.startswith(prefixes):
-        raise ValueError(
-            f"Datasource URL for {database_type} must start with one of: "
-            f"{', '.join(prefixes)}"
-        )
+def validate_datasource_configuration(
+    database_type: str,
+    database_url: str,
+    sql_dialect: str,
+) -> None:
+    get_connector_registry().validate(database_type, database_url, sql_dialect)
 
 
 def mask_database_url(database_url: str) -> str:
@@ -827,6 +818,104 @@ def set_llm_runtime_config(
     return get_llm_runtime_config(session)
 
 
+def build_llm_runtime_config(
+    session: Session,
+    *,
+    provider: str,
+    base_url: str,
+    api_key: str | None,
+    clear_api_key: bool,
+    model: str,
+    timeout_seconds: int | None,
+    extra_body: dict[str, Any],
+) -> LlmRuntimeConfig:
+    if provider != "openai-compatible":
+        raise ValueError("Only openai-compatible LLM provider is supported.")
+
+    current_config = get_llm_runtime_config(session)
+    normalized_base_url = str(base_url or "").strip()
+    normalized_model = str(model or "").strip()
+    if not normalized_base_url:
+        raise ValueError("LLM Base URL is required.")
+    if not normalized_model:
+        raise ValueError("LLM model is required.")
+    if timeout_seconds is not None and timeout_seconds < 1:
+        raise ValueError("LLM timeout seconds must be greater than 0.")
+    if not isinstance(extra_body, dict):
+        raise ValueError("LLM Extra body JSON must be an object.")
+
+    next_api_key = current_config.api_key
+    if clear_api_key:
+        next_api_key = "change-me"
+    elif api_key is not None and api_key.strip():
+        next_api_key = api_key.strip()
+
+    return LlmRuntimeConfig(
+        provider=provider,
+        base_url=normalized_base_url,
+        api_key=next_api_key,
+        model=normalized_model,
+        timeout_seconds=timeout_seconds or current_config.timeout_seconds,
+        extra_body=extra_body,
+    )
+
+
+def test_llm_runtime_config(
+    session: Session,
+    *,
+    provider: str,
+    base_url: str,
+    api_key: str | None,
+    clear_api_key: bool,
+    model: str,
+    timeout_seconds: int | None,
+    extra_body: dict[str, Any],
+) -> dict[str, Any]:
+    config = build_llm_runtime_config(
+        session,
+        provider=provider,
+        base_url=base_url,
+        api_key=api_key,
+        clear_api_key=clear_api_key,
+        model=model,
+        timeout_seconds=timeout_seconds,
+        extra_body=extra_body,
+    )
+    if not config.api_key or config.api_key == "change-me":
+        raise ValueError("LLM API key is required for the connection test.")
+
+    client = OpenAICompatibleClient(
+        base_url=config.base_url,
+        api_key=config.api_key,
+        timeout_seconds=config.timeout_seconds,
+    )
+
+    try:
+        response = client.create_chat_completion(
+            ChatCompletionRequest(
+                model=config.model,
+                messages=[
+                    ChatMessage(
+                        role="user",
+                        content="GAARD LLM connection test. Reply with OK.",
+                    )
+                ],
+                temperature=0,
+                extra_body=config.extra_body,
+            )
+        )
+    except LlmProviderError as exc:
+        raise ValueError(str(exc)) from exc
+
+    if not response.content.strip():
+        raise ValueError("LLM provider returned an empty response.")
+
+    return {
+        "ok": True,
+        "model": response.model or config.model,
+    }
+
+
 def get_data_query_audit_retention_days(session: Session) -> int:
     value = get_setting(
         session,
@@ -1896,18 +1985,7 @@ def set_active_datasource_connector(
 
 
 def test_datasource_connection(connector: DatasourceConnector) -> None:
-    connect_args = (
-        {"check_same_thread": False}
-        if connector.database_url.startswith("sqlite")
-        else {}
-    )
-    engine = create_engine(connector.database_url, connect_args=connect_args)
-
-    try:
-        with engine.connect() as connection:
-            connection.execute(text("SELECT 1"))
-    finally:
-        engine.dispose()
+    get_connector_registry().get(connector.database_type).connection_tester(connector.database_url)
 
 
 def get_datasource_schema_cache(
@@ -1935,7 +2013,12 @@ def introspect_datasource_connector(
     connector: DatasourceConnector,
     actor: str,
 ) -> DatasourceSchemaCache:
-    schema = SQLAlchemySchemaIntrospector(connector.database_url).introspect()
+    schema = (
+        get_connector_registry()
+        .get(connector.database_type)
+        .introspector_factory(connector.database_url)
+        .introspect()
+    )
     existing = get_datasource_schema_cache(session, connector.id)
     existing_settings = (
         json_loads(existing.table_settings_json) if existing is not None else {}