glaip-sdk 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

glaip_sdk/cli/commands/mcps.py

@@ -25,6 +25,11 @@ from glaip_sdk.cli.display import (
 from glaip_sdk.cli.io import (
     fetch_raw_resource_details,
 )
+from glaip_sdk.cli.mcp_validators import (
+    validate_mcp_auth_structure,
+    validate_mcp_config_structure,
+)
+from glaip_sdk.cli.parsers.json_input import parse_json_input
 from glaip_sdk.cli.resolution import resolve_resource_reference
 from glaip_sdk.cli.utils import (
     coerce_to_row,
@@ -137,11 +142,25 @@ def list_mcps(ctx: Any) -> None:
 @click.option("--name", required=True, help="MCP name")
 @click.option("--transport", required=True, help="MCP transport protocol")
 @click.option("--description", help="MCP description")
-@click.option("--config", help="JSON configuration string")
+@click.option(
+    "--config",
+    help="JSON configuration string or @file reference (e.g., @config.json)",
+)
+@click.option(
+    "--auth",
+    "--authentication",
+    "auth",
+    help="JSON authentication object or @file reference (e.g., @auth.json)",
+)
 @output_flags()
 @click.pass_context
 def create(
-    ctx: Any, name: str, transport: str, description: str | None, config: str | None
+    ctx: Any,
+    name: str,
+    transport: str,
+    description: str | None,
+    config: str | None,
+    auth: str | None,
 ) -> None:
     """Create a new MCP with specified configuration.
 
@@ -150,7 +169,8 @@ def create(
         name: MCP name (required)
         transport: MCP transport protocol (required)
         description: Optional MCP description
-        config: JSON configuration string for MCP settings
+        config: JSON configuration string or @file reference
+        auth: JSON authentication object or @file reference
 
     Raises:
         ClickException: If JSON parsing fails or API request fails
@@ -158,26 +178,47 @@ def create(
     try:
         client = get_client(ctx)
 
-        # Parse config if provided
-        mcp_config = {}
-        if config:
-            try:
-                mcp_config = json.loads(config)
-            except json.JSONDecodeError:
-                raise click.ClickException("Invalid JSON in --config")
+        # Parse config if provided (supports inline JSON or @file)
+        raw_config = parse_json_input(config)
+        if raw_config is None:
+            mcp_config: dict[str, Any] = {}
+        else:
+            mcp_config = validate_mcp_config_structure(
+                raw_config,
+                transport=transport,
+                source="--config",
+            )
+
+        # Parse authentication if provided (supports inline JSON or @file)
+        mcp_auth = parse_json_input(auth)
+        validated_auth = (
+            validate_mcp_auth_structure(mcp_auth, source="--auth")
+            if mcp_auth is not None
+            else None
+        )
+
+        # Build kwargs for create_mcp
+        create_kwargs = {
+            "name": name,
+            "type": "server",  # MCPs are always server type
+            "transport": transport,
+            "config": mcp_config,
+        }
+
+        # Only add description if provided
+        if description is not None:
+            create_kwargs["description"] = description
+
+        # Only add authentication if provided
+        if validated_auth:
+            create_kwargs["authentication"] = validated_auth
 
         with spinner_context(
             ctx,
             "[bold blue]Creating MCP…[/bold blue]",
             console_override=console,
         ):
-            mcp = client.mcps.create_mcp(
-                name=name,
-                type="server",  # MCPs are always server type
-                transport=transport,
-                description=description,
-                config=mcp_config,
-            )
+            mcp = client.mcps.create_mcp(**create_kwargs)
 
         # Handle JSON output
         handle_json_output(ctx, mcp.model_dump())
@@ -525,7 +566,16 @@ def connect(ctx: Any, config_file: str) -> None:
 @click.argument("mcp_ref")
 @click.option("--name", help="New MCP name")
 @click.option("--description", help="New description")
-@click.option("--config", help="JSON configuration string")
+@click.option(
+    "--config",
+    help="JSON configuration string or @file reference (e.g., @config.json)",
+)
+@click.option(
+    "--auth",
+    "--authentication",
+    "auth",
+    help="JSON authentication object or @file reference (e.g., @auth.json)",
+)
 @output_flags()
 @click.pass_context
 def update(
@@ -534,6 +584,7 @@ def update(
     name: str | None,
     description: str | None,
     config: str | None,
+    auth: str | None,
 ) -> None:
     """Update an existing MCP with new configuration values.
 
@@ -542,7 +593,8 @@ def update(
         mcp_ref: MCP reference (ID or name)
         name: New MCP name (optional)
         description: New description (optional)
-        config: New JSON configuration string (optional)
+        config: New JSON configuration string or @file reference (optional)
+        auth: New JSON authentication object or @file reference (optional)
 
     Raises:
         ClickException: If MCP not found, JSON invalid, or no fields specified
@@ -564,10 +616,17 @@ def update(
         if description is not None:
             update_data["description"] = description
         if config is not None:
-            try:
-                update_data["config"] = json.loads(config)
-            except json.JSONDecodeError:
-                raise click.ClickException("Invalid JSON in --config")
+            parsed_config = parse_json_input(config)
+            update_data["config"] = validate_mcp_config_structure(
+                parsed_config,
+                transport=getattr(mcp, "transport", None),
+                source="--config",
+            )
+        if auth is not None:
+            parsed_auth = parse_json_input(auth)
+            update_data["authentication"] = validate_mcp_auth_structure(
+                parsed_auth, source="--auth"
+            )
 
         if not update_data:
             raise click.ClickException("No update fields specified")

glaip_sdk/cli/mcp_validators.py

@@ -0,0 +1,297 @@
+"""MCP configuration and authentication validation for CLI.
+
+This module provides validation functions for MCP config and auth structures
+that are used in CLI commands. It ensures data conforms to the MCP schema
+documented in docs/reference/schemas/mcps.md.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from typing import Any
+from urllib.parse import urlparse
+
+import click
+
+
+def format_validation_error(prefix: str, detail: str | None = None) -> str:
+    """Format a validation error message with optional detail.
+
+    Args:
+        prefix: Main error message
+        detail: Optional additional detail to append
+
+    Returns:
+        Formatted error message string
+
+    Examples:
+        >>> format_validation_error("Invalid config", "Missing 'url' field")
+        "Invalid config\\nMissing 'url' field"
+    """
+    parts = [prefix]
+    if detail:
+        parts.append(detail)
+    return "\n".join(parts)
+
+
+def validate_mcp_config_structure(
+    config: Any, *, transport: str | None = None, source: str = "--config"
+) -> dict[str, Any]:
+    """Validate MCP configuration structure for CLI commands.
+
+    Validates that the config is a dictionary with a valid 'url' field.
+    The 'url' must be an absolute HTTP/HTTPS URL as required by the MCP schema.
+
+    Args:
+        config: Configuration value to validate (expected to be a dict)
+        transport: Optional transport type ('http' or 'sse') for context in errors
+        source: Source parameter name for error messages (default: "--config")
+
+    Returns:
+        Validated configuration dictionary
+
+    Raises:
+        click.ClickException: If config is not a dict, missing 'url', or URL is invalid
+
+    Examples:
+        >>> validate_mcp_config_structure({"url": "https://api.example.com"})
+        {'url': 'https://api.example.com'}
+
+        >>> validate_mcp_config_structure([1, 2, 3])  # doctest: +SKIP
+        ClickException: Invalid --config value
+        Expected a JSON object representing MCP configuration.
+
+    Schema Reference:
+        See docs/reference/schemas/mcps.md - Config Object Structure
+        - Required field: 'url' (string, must be valid HTTP/HTTPS URL)
+        - Additional fields allowed and passed through
+    """
+    if not isinstance(config, dict):
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Expected a JSON object representing MCP configuration.",
+            )
+        )
+
+    url_value = config.get("url")
+    if not isinstance(url_value, str) or not url_value.strip():
+        requirement = "Missing required 'url' field with a non-empty string value."
+        if transport:
+            requirement += f" Required for transport '{transport}'."
+        raise click.ClickException(
+            format_validation_error(f"Invalid {source} value", requirement)
+        )
+
+    parsed_url = urlparse(url_value)
+    if parsed_url.scheme not in {"http", "https"} or not parsed_url.netloc:
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "'url' must be an absolute HTTP or HTTPS URL.",
+            )
+        )
+
+    return config
+
+
+def _validate_headers_mapping(
+    headers: Any, *, source: str, context: str
+) -> dict[str, str]:
+    """Validate headers mapping for authentication.
+
+    Args:
+        headers: Headers value to validate (expected to be a non-empty dict)
+        source: Source parameter name for error messages
+        context: Context description for error messages (e.g., "bearer-token authentication")
+
+    Returns:
+        Validated headers dictionary with string keys and values
+
+    Raises:
+        click.ClickException: If headers is not a dict, empty, or contains invalid entries
+    """
+    if not isinstance(headers, dict) or not headers:
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                f"{context} must provide a non-empty 'headers' object with string keys and values.",
+            )
+        )
+
+    normalized: dict[str, str] = {}
+    for key, value in headers.items():
+        if not isinstance(key, str) or not key.strip():
+            raise click.ClickException(
+                format_validation_error(
+                    f"Invalid {source} value",
+                    "Header names must be non-empty strings.",
+                )
+            )
+        if not isinstance(value, str) or not value.strip():
+            raise click.ClickException(
+                format_validation_error(
+                    f"Invalid {source} value",
+                    f"Header '{key}' must have a non-empty string value.",
+                )
+            )
+        normalized[key] = value
+    return normalized
+
+
+def _validate_bearer_token_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate bearer-token authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated bearer-token authentication dictionary
+
+    Raises:
+        click.ClickException: If bearer-token structure is invalid
+    """
+    token = auth.get("token")
+    if isinstance(token, str) and token.strip():
+        return {"type": "bearer-token", "token": token}
+    headers = auth.get("headers")
+    normalized_headers = _validate_headers_mapping(
+        headers, source=source, context="bearer-token authentication"
+    )
+    return {"type": "bearer-token", "headers": normalized_headers}
+
+
+def _validate_api_key_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate api-key authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated api-key authentication dictionary
+
+    Raises:
+        click.ClickException: If api-key structure is invalid
+    """
+    headers = auth.get("headers")
+    if headers is not None:
+        normalized_headers = _validate_headers_mapping(
+            headers, source=source, context="api-key authentication"
+        )
+        return {"type": "api-key", "headers": normalized_headers}
+
+    key = auth.get("key")
+    value = auth.get("value")
+    if not isinstance(key, str) or not key.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "api-key authentication requires a non-empty 'key'.",
+            )
+        )
+    if not isinstance(value, str) or not value.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "api-key authentication requires a non-empty 'value'.",
+            )
+        )
+    return {"type": "api-key", "key": key, "value": value}
+
+
+def _validate_custom_header_auth(auth: dict[str, Any], source: str) -> dict[str, Any]:
+    """Validate custom-header authentication.
+
+    Args:
+        auth: Authentication dictionary
+        source: Source parameter name for error messages
+
+    Returns:
+        Validated custom-header authentication dictionary
+
+    Raises:
+        click.ClickException: If custom-header structure is invalid
+    """
+    headers = auth.get("headers")
+    normalized_headers = _validate_headers_mapping(
+        headers, source=source, context="custom-header authentication"
+    )
+    return {"type": "custom-header", "headers": normalized_headers}
+
+
+def validate_mcp_auth_structure(auth: Any, *, source: str = "--auth") -> dict[str, Any]:
+    """Validate MCP authentication structure for CLI commands.
+
+    Validates authentication objects according to the MCP schema, supporting:
+    - no-auth: No authentication required
+    - bearer-token: Bearer token via 'token' field or 'headers'
+    - api-key: API key via 'key'/'value' fields or 'headers'
+    - custom-header: Custom headers via 'headers' object
+
+    Args:
+        auth: Authentication value to validate (expected to be a dict or None)
+        source: Source parameter name for error messages (default: "--auth")
+
+    Returns:
+        Validated authentication dictionary, or empty dict if auth is None
+
+    Raises:
+        click.ClickException: If auth structure is invalid or type is unsupported
+
+    Examples:
+        >>> validate_mcp_auth_structure(None)
+        {}
+
+        >>> validate_mcp_auth_structure({"type": "no-auth"})
+        {'type': 'no-auth'}
+
+        >>> validate_mcp_auth_structure({"type": "bearer-token", "token": "abc123"})
+        {'type': 'bearer-token', 'token': 'abc123'}
+
+    Schema Reference:
+        See docs/reference/schemas/mcps.md - Authentication Types
+        - Required field: 'type' (string, one of: no-auth, bearer-token, api-key, custom-header)
+        - Additional fields depend on type
+    """
+    if auth is None:
+        return {}
+
+    if not isinstance(auth, dict):
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Expected a JSON object representing MCP authentication.",
+            )
+        )
+
+    raw_type = auth.get("type")
+    if not isinstance(raw_type, str) or not raw_type.strip():
+        raise click.ClickException(
+            format_validation_error(
+                f"Invalid {source} value",
+                "Authentication objects must include a non-empty 'type' field.",
+            )
+        )
+
+    auth_type = raw_type.strip()
+
+    # Dispatch to type-specific validators
+    if auth_type == "no-auth":
+        return {"type": "no-auth"}
+    if auth_type == "bearer-token":
+        return _validate_bearer_token_auth(auth, source)
+    if auth_type == "api-key":
+        return _validate_api_key_auth(auth, source)
+    if auth_type == "custom-header":
+        return _validate_custom_header_auth(auth, source)
+
+    # Unknown type
+    raise click.ClickException(
+        format_validation_error(
+            f"Invalid {source} value",
+            f"Unsupported authentication type '{auth_type}'. "
+            f"Supported types: no-auth, bearer-token, api-key, custom-header",
+        )
+    )

glaip_sdk/cli/parsers/__init__.py

@@ -0,0 +1,9 @@
+"""CLI input parsers.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from glaip_sdk.cli.parsers.json_input import parse_json_input
+
+__all__ = ["parse_json_input"]

glaip_sdk/cli/parsers/json_input.py

@@ -0,0 +1,140 @@
+"""JSON input parser for CLI options.
+
+Handles both inline JSON strings and @file references.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import click
+
+
+def _format_file_error(
+    prefix: str, file_path_str: str, resolved_path: Path, *, detail: str | None = None
+) -> str:
+    """Format a file-related error message with path context.
+
+    Args:
+        prefix: Main error message
+        file_path_str: Original file path string provided by user
+        resolved_path: Resolved absolute path
+        detail: Optional additional detail to append
+
+    Returns:
+        Formatted error message string with file path context
+
+    Examples:
+        >>> from pathlib import Path
+        >>> _format_file_error("File not found", "config.json", Path("/abs/config.json"))
+        'File not found: config.json\\nResolved path: /abs/config.json'
+    """
+    parts = [f"{prefix}: {file_path_str}", f"Resolved path: {resolved_path}"]
+    if detail:
+        parts.append(detail)
+    return "\n".join(parts)
+
+
+def _parse_json_from_file(file_path_str: str) -> Any:
+    """Parse JSON from a file path.
+
+    Args:
+        file_path_str: Path to the JSON file (without @ prefix).
+
+    Returns:
+        Parsed dictionary from file.
+
+    Raises:
+        click.ClickException: If file not found, not readable, empty, or invalid JSON.
+    """
+    # Resolve relative paths against CWD
+    file_path = Path(file_path_str)
+    if not file_path.is_absolute():
+        file_path = Path.cwd() / file_path
+
+    # Check if file exists and is a regular file
+    if not file_path.is_file():
+        raise click.ClickException(
+            _format_file_error("File not found or not a file", file_path_str, file_path)
+        )
+
+    # Check if file is readable
+    if not os.access(file_path, os.R_OK):
+        raise click.ClickException(
+            _format_file_error(
+                "File not readable (permission denied)", file_path_str, file_path
+            )
+        )
+
+    # Read file content
+    try:
+        content = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        raise click.ClickException(
+            _format_file_error(
+                "Error reading file", file_path_str, file_path, detail=f"Error: {e}"
+            )
+        )
+
+    # Check for empty content
+    if not content.strip():
+        raise click.ClickException(
+            _format_file_error("File is empty", file_path_str, file_path)
+        )
+
+    # Parse JSON from file content
+    try:
+        return json.loads(content)
+    except json.JSONDecodeError as e:
+        raise click.ClickException(
+            _format_file_error(
+                "Invalid JSON in file",
+                file_path_str,
+                file_path,
+                detail=f"Error: {e.msg} at line {e.lineno}, column {e.colno}",
+            )
+        )
+
+
+def parse_json_input(value: str | None) -> Any:
+    """Parse JSON input from inline string or file reference.
+
+    Args:
+        value: JSON string or @file reference. If None, returns None.
+
+    Returns:
+        Parsed JSON value (dict, list, str, int, float, bool, None) or None if value is None.
+
+    Raises:
+        click.ClickException: If file not found, not readable, empty, or invalid JSON.
+
+    Examples:
+        >>> parse_json_input('{"key": "value"}')
+        {'key': 'value'}
+
+        >>> parse_json_input('@/path/to/config.json')
+        # Returns content of config.json parsed as JSON
+
+        >>> parse_json_input(None)
+        None
+    """
+    if value is None:
+        return None
+
+    # Check if value is a file reference (strip whitespace first)
+    trimmed = value.strip()
+    if trimmed.startswith("@"):
+        return _parse_json_from_file(trimmed[1:])
+
+    # Parse inline JSON
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as e:
+        raise click.ClickException(
+            f"Invalid JSON in inline value\n"
+            f"Error: {e.msg} at line {e.lineno}, column {e.colno}"
+        )

glaip_sdk/client/mcps.py

@@ -57,7 +57,7 @@ class MCPClient(BaseClient):
     def create_mcp(
         self,
         name: str,
-        description: str,
+        description: str | None = None,
         config: dict[str, Any] | None = None,
         **kwargs,
     ) -> MCP:
@@ -108,7 +108,7 @@ class MCPClient(BaseClient):
     def _build_create_payload(
         self,
         name: str,
-        description: str,
+        description: str | None = None,
         transport: str = DEFAULT_MCP_TRANSPORT,
         config: dict[str, Any] | None = None,
         **kwargs,
@@ -122,7 +122,7 @@ class MCPClient(BaseClient):
 
         Args:
             name: MCP name
-            description: MCP description
+            description: MCP description (optional)
             transport: MCP transport protocol (defaults to stdio)
             config: MCP configuration dictionary
             **kwargs: Additional parameters

{glaip_sdk-0.0.11.dist-info → glaip_sdk-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: glaip-sdk
-Version: 0.0.11
+Version: 0.0.12
 Summary: Python SDK for GL AIP (GDP Labs AI Agent Package) - Simplified CLI Design
 License: MIT
 Author: Raymond Christopher

{glaip_sdk-0.0.11.dist-info → glaip_sdk-0.0.12.dist-info}/RECORD

@@ -7,12 +7,15 @@ glaip_sdk/cli/auth.py,sha256=eYdtGmJ3XgiO96hq_69GF6b3W-aRWZrDQ-6bHuaRX4M,13517
 glaip_sdk/cli/commands/__init__.py,sha256=x0CZlZbZHoHvuzfoTWIyEch6WmNnbPzxajrox6riYp0,173
 glaip_sdk/cli/commands/agents.py,sha256=97dzowjHgk5knyHuI-0z2ojvqNlkebNN1-ikGEoS5sc,40623
 glaip_sdk/cli/commands/configure.py,sha256=eRDzsaKV4fl2lJt8ieS4g2-xRnaa02eAAPW8xBf-tqA,7507
-glaip_sdk/cli/commands/mcps.py,sha256=a2p8KfPYv4YaC9qiC7LEyh8oPsbLAwXv4dsnwxZ_juI,19752
+glaip_sdk/cli/commands/mcps.py,sha256=_zBT-8LMg8DTkiMO0d63tUqjy36-bdqrjxZX7bM-vpg,21514
 glaip_sdk/cli/commands/models.py,sha256=Ra3-50BPScNs0Q-j4b7U4iK0hNooucEyVgHpQ11-pt8,1700
 glaip_sdk/cli/commands/tools.py,sha256=MOM9Db3HGL1stF-WvL5cZXjw-iZo2qc-oyKQHy6VwIM,18690
 glaip_sdk/cli/display.py,sha256=jE20swoRKzpYUmc0jgbeonaXKeE9x95hfjWAEdnBYRc,8727
 glaip_sdk/cli/io.py,sha256=GPkw3pQMLBGoD5GH-KlbKpNRlVWFZOXHE17F7V3kQsI,3343
 glaip_sdk/cli/main.py,sha256=3Bl8u9t1MekzaNrAZqsx4TukbzzFdi6Wss6jvTDos00,12930
+glaip_sdk/cli/mcp_validators.py,sha256=PEJRzb7ogRkwNJwJK9k5Xmb8hvoQ58L2Qywqd_3Wayo,10125
+glaip_sdk/cli/parsers/__init__.py,sha256=Ycd4HDfYmA7GUGFt0ndBPBo5uTbv15XsXnYUj-a89ug,183
+glaip_sdk/cli/parsers/json_input.py,sha256=iISa31ZsDNYWfCVRy0cifRIg2gjnhI-XtdDLB-UOshg,4039
 glaip_sdk/cli/resolution.py,sha256=BOw2NchReLKewAwBAZLWw_3_bI7u3tfzQEO7kQbIiGE,2067
 glaip_sdk/cli/slash/__init__.py,sha256=Vdv6Y8bu-pA8dxDlyP4XrhudBPivztUozhLAz9vaLig,682
 glaip_sdk/cli/slash/agent_session.py,sha256=pDOwGXNHuyJIulrGYu1pacyF3oxHWeDQY-Uv92h2qVg,6859
@@ -25,7 +28,7 @@ glaip_sdk/client/__init__.py,sha256=nYLXfBVTTWwKjP0e63iumPYO4k5FifwWaELQPaPIKIg,
 glaip_sdk/client/agents.py,sha256=FSKubF40wptMNIheC3_iawiX2CRbhTcNLFiz4qkPC6k,34659
 glaip_sdk/client/base.py,sha256=O3dv3I7PqY91gH1FehBMRZcSXjwimfeBcJuiXidDmqw,13700
 glaip_sdk/client/main.py,sha256=LlvYHP7-Hy7Eq1ep1kfk337K-Oue5SdKWJpqYfX9eXY,7993
-glaip_sdk/client/mcps.py,sha256=yxwrAtztElYDEGhp2EHRpeYUxNsOlTLTqtw9jSKJmcI,8936
+glaip_sdk/client/mcps.py,sha256=-O-I15qjbwfSA69mouHY6g5_qgPWC4rM98VJLpOkh1A,8975
 glaip_sdk/client/tools.py,sha256=n8DIiOOf1YU_j9JK3Bx2-rDnkpckPi0MI9Ok2s1kwa4,16634
 glaip_sdk/client/validators.py,sha256=NtPsWjQLjj25LiUnmR-WuS8lL5p4MVRaYT9UVRmj9bo,8809
 glaip_sdk/config/constants.py,sha256=ysEobMiXlLZGIOEaqTdHpPF8kmg5nbLn7BIcBvTCuHM,819
@@ -55,7 +58,7 @@ glaip_sdk/utils/rich_utils.py,sha256=-Ij-1bIJvnVAi6DrfftchIlMcvOTjVmSE0Qqax0EY_s
 glaip_sdk/utils/run_renderer.py,sha256=d_VMI6LbvHPUUeRmGqh5wK_lHqDEIAcym2iqpbtDad0,1365
 glaip_sdk/utils/serialization.py,sha256=T1yt_8G2DCFpcxx7XnqFl5slksRXfBCUuLQJTreGYEQ,11806
 glaip_sdk/utils/validation.py,sha256=QNORcdyvuliEs4EH2_mkDgmoyT9utgl7YNhaf45SEf8,6992
-glaip_sdk-0.0.11.dist-info/METADATA,sha256=Z8hxLQAn8fWQtisQyZAi6QgOCSxDpEWw4gLbTBMDrxU,4984
-glaip_sdk-0.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-glaip_sdk-0.0.11.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
-glaip_sdk-0.0.11.dist-info/RECORD,,
+glaip_sdk-0.0.12.dist-info/METADATA,sha256=9nmM8Y3WqIoYIkJytD_HKN2CHtHEG-R1Kdi1_SdsLnY,4984
+glaip_sdk-0.0.12.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+glaip_sdk-0.0.12.dist-info/entry_points.txt,sha256=EGs8NO8J1fdFMWA3CsF7sKBEvtHb_fujdCoNPhfMouE,47
+glaip_sdk-0.0.12.dist-info/RECORD,,