supervaizer 0.9.7__py3-none-any.whl → 0.10.0__py3-none-any.whl

supervaizer/deploy/templates/debug_env.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+# Copyright (c) 2024-2025 Alain Prasquier - Supervaize.com. All rights reserved.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+# If a copy of the MPL was not distributed with this file, you can obtain one at
+# https://mozilla.org/MPL/2.0/.
+
+"""Debug script to check environment variables in container."""
+
+import os
+import sys
+
+
+def debug_environment_variables() -> None:
+    """Print all environment variables for debugging."""
+    print("=== Environment Variables Debug ===")
+    print(f"Python version: {sys.version}")
+    print(f"Working directory: {os.getcwd()}")
+    print()
+
+    # Check specific Supervaize environment variables
+    supervaize_vars = [
+        "SUPERVAIZE_API_KEY",
+        "SUPERVAIZE_WORKSPACE_ID",
+        "SUPERVAIZE_API_URL",
+        "SUPERVAIZER_PORT",
+        "SUPERVAIZER_PUBLIC_URL",
+        "SUPERVAIZER_ENVIRONMENT",
+        "SUPERVAIZER_HOST",
+        "SUPERVAIZER_API_KEY",
+        "SV_RSA_PRIVATE_KEY",
+        "SV_LOG_LEVEL",
+    ]
+
+    print("=== Supervaize Environment Variables ===")
+    for var_name in supervaize_vars:
+        value = os.getenv(var_name)
+        if value is None:
+            print(f"{var_name}: [NOT SET]")
+        elif value == "":
+            print(f"{var_name}: [EMPTY STRING]")
+        else:
+            # Mask sensitive values
+            if "KEY" in var_name or "SECRET" in var_name:
+                masked_value = (
+                    value[:4] + "*" * (len(value) - 8) + value[-4:]
+                    if len(value) > 8
+                    else "*" * len(value)
+                )
+                print(f"{var_name}: {masked_value}")
+            else:
+                print(f"{var_name}: {value}")
+
+    print()
+    print("=== All Environment Variables ===")
+    for key, value in sorted(os.environ.items()):
+        if "KEY" in key or "SECRET" in key or "PASSWORD" in key:
+            masked_value = (
+                value[:4] + "*" * (len(value) - 8) + value[-4:]
+                if len(value) > 8
+                else "*" * len(value)
+            )
+            print(f"{key}: {masked_value}")
+        else:
+            print(f"{key}: {value}")
+
+
+if __name__ == "__main__":
+    debug_environment_variables()

supervaizer/deploy/templates/docker-compose.yml.template

@@ -0,0 +1,37 @@
+services:
+  {{SERVICE_NAME}}:
+    build:
+      context: ..
+      dockerfile: .deployment/Dockerfile
+      args:
+        - SUPERVAIZE_API_KEY={{API_KEY}}
+        - SUPERVAIZE_WORKSPACE_ID={{WORKSPACE_ID}}
+        - SUPERVAIZE_API_URL={{API_URL}}
+        - SUPERVAIZER_PORT=8000
+        - SUPERVAIZER_PUBLIC_URL={{PUBLIC_URL}}
+    ports:
+      - "{{PORT}}:8000"
+    environment:
+      - SUPERVAIZER_ENVIRONMENT={{ENVIRONMENT}}
+      - SUPERVAIZER_HOST=0.0.0.0
+      - SUPERVAIZER_PORT=8000
+      - SV_LOG_LEVEL={{ env.SV_LOG_LEVEL | default('INFO') }}
+      - SUPERVAIZER_API_KEY={{API_KEY}}
+      - SV_RSA_PRIVATE_KEY={{RSA_KEY}}
+      - SUPERVAIZE_API_KEY={{API_KEY}}
+      - SUPERVAIZE_WORKSPACE_ID={{WORKSPACE_ID}}
+      - SUPERVAIZE_API_URL={{API_URL}}
+      - SUPERVAIZER_PUBLIC_URL={{PUBLIC_URL}}
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/.well-known/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    restart: unless-stopped
+    networks:
+      - supervaizer-network
+
+networks:
+  supervaizer-network:
+    driver: bridge

supervaizer/deploy/templates/dockerignore.template

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Documentation
+docs/
+*.md
+README*
+
+# Tests
+tests/
+test_*
+*_test.py
+
+# Deployment artifacts
+.deployment/
+!.deployment/debug_env.py
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/

supervaizer/deploy/templates/entrypoint.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -e
+
+# Change to app directory
+cd /app
+
+# Remove any stale .venv references that might cause issues
+if [ -d ".venv" ] && [ ! -f ".venv/bin/python3" ]; then
+    rm -rf .venv
+fi
+
+# Install the project if not already installed
+# This ensures the supervaizer command is available
+if ! command -v supervaizer &> /dev/null; then
+    echo "Installing supervaizer..."
+    uv sync --frozen --no-dev
+fi
+
+# Run supervaizer start
+exec uv run supervaizer start

supervaizer/deploy/utils.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2024-2025 Alain Prasquier - Supervaize.com. All rights reserved.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
+# If a copy of the MPL was not distributed with this file, you can obtain one at
+# https://mozilla.org/MPL/2.0/.
+
+"""
+Deployment State Management
+
+This module handles deployment state persistence and management.
+"""
+
+from pathlib import Path
+
+
+from supervaizer.common import log
+
+
+def create_deployment_directory(project_root: Path) -> Path:
+    """Create deployment directory and add to .gitignore."""
+    deployment_dir = project_root / ".deployment"
+    deployment_dir.mkdir(exist_ok=True)
+
+    # Create logs subdirectory
+    logs_dir = deployment_dir / "logs"
+    logs_dir.mkdir(exist_ok=True)
+
+    # Add to .gitignore if not already present
+    gitignore_path = project_root / ".gitignore"
+    gitignore_entry = ".deployment/"
+
+    if gitignore_path.exists():
+        gitignore_content = gitignore_path.read_text()
+        if gitignore_entry not in gitignore_content:
+            gitignore_path.write_text(gitignore_content + f"\n{gitignore_entry}\n")
+            log.info(f"Added {gitignore_entry} to .gitignore")
+    else:
+        gitignore_path.write_text(f"{gitignore_entry}\n")
+        log.info(f"Created .gitignore with {gitignore_entry}")
+
+    return deployment_dir

supervaizer/examples/{controller-template.py → controller_template.py}

@@ -173,19 +173,20 @@ agent: Agent = Agent(
         custom={"custom1": custom_method, "custom2": custom_method2},
     ),
     parameters_setup=agent_parameters,
+    instructions_path="supervaize_instructions.html",  # Path where instructions page is served
 )
 
+# For export purposes, use dummy values if environment variables are not set
 account: Account = Account(
-    workspace_id=os.getenv("SUPERVAIZE_WORKSPACE_ID"),  # From supervaize.com
-    api_key=os.getenv("SUPERVAIZE_API_KEY"),  # From supervaize
-    api_url=os.getenv("SUPERVAIZE_API_URL"),  # From supervaize
+    workspace_id=os.getenv("SUPERVAIZE_WORKSPACE_ID") or "dummy_workspace_id",
+    api_key=os.getenv("SUPERVAIZE_API_KEY") or "dummy_api_key",
+    api_url=os.getenv("SUPERVAIZE_API_URL") or "https://api.supervaize.com",
 )
 
 # Define the supervaizer server capabilities
 sv_server: Server = Server(
     agents=[agent],
     a2a_endpoints=True,  # Enable A2A endpoints
-    acp_endpoints=True,  # Enable ACP endpoints
     supervisor_account=account,  # Account of the supervisor from Supervaize
 )
 

supervaizer/job.py

@@ -8,7 +8,7 @@ import time
 import traceback
 import uuid
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional
 
 from supervaizer.__version__ import VERSION
 from supervaizer.common import SvBaseModel, log, singleton
@@ -242,8 +242,8 @@ class AbstractJob(SvBaseModel):
     responses: list["JobResponse"] = []
     finished_at: datetime | None = None
     created_at: datetime | None = None
-    agent_parameters: List[dict[str, Any]] | None = None
-    case_ids: List[str] = []  # Foreign key relationship to cases
+    agent_parameters: list[dict[str, Any]] | None = None
+    case_ids: list[str] = []  # Foreign key relationship to cases
 
 
 class Job(AbstractJob):
@@ -344,7 +344,7 @@ class Job(AbstractJob):
         cls,
         job_context: "JobContext",
         agent_name: str,
-        agent_parameters: Optional[List[dict[str, Any]]] = None,
+        agent_parameters: Optional[list[dict[str, Any]]] = None,
         name: Optional[str] = None,
     ) -> "Job":
         """Create a new job
@@ -352,7 +352,7 @@ class Job(AbstractJob):
         Args:
             job_context (JobContext): The context of the job
             agent_name (str): The name of the agent
-            agent_parameters (dict[str, Any] | None): Optional parameters for the job
+            agent_parameters (list[dict[str, Any]] | None): Optional parameters for the job
             name (str | None): Optional name for the job, defaults to mission name if not provided
 
         Returns:
@@ -362,6 +362,19 @@ class Job(AbstractJob):
         # Use provided name or fallback to mission name from context
         job_name = name or job_context.mission_name
 
+        # Ensure agent_parameters is a list of dicts, not nested incorrectly
+        if agent_parameters is not None:
+            # If it's a list but the first element is also a list, unwrap it
+            if isinstance(agent_parameters, list) and len(agent_parameters) > 0:
+                if isinstance(agent_parameters[0], list):
+                    # Unwrap nested list: [[{...}, {...}]] -> [{...}, {...}]
+                    agent_parameters = agent_parameters[0]
+            # Ensure all elements are dicts
+            if not all(isinstance(p, dict) for p in agent_parameters):
+                raise ValueError(
+                    f"agent_parameters must be a list of dictionaries, got: {type(agent_parameters)}"
+                )
+
         job = cls(
             id=job_id,
             name=job_name,

supervaizer/job_service.py

@@ -7,7 +7,6 @@
 import json
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
-from rich import inspect
 
 from supervaizer.common import decrypt_value, log
 from supervaizer.event import JobFinishedEvent
@@ -44,7 +43,7 @@ async def service_job_start(
     Returns:
         The created job
     """
-    agent_parameters: dict[str, Any] | None = None
+    agent_parameters = None
     # If agent has parameters_setup defined, validate parameters
     if getattr(agent, "parameters_setup") and encrypted_agent_parameters:
         agent_parameters_str = decrypt_value(
@@ -54,14 +53,16 @@ async def service_job_start(
             json.loads(agent_parameters_str) if agent_parameters_str else None
         )
 
-        inspect(agent)
-        log.debug(f"[Decrypted parameters] : parameters = {agent_parameters}")
+        # inspect(agent)
+        log.debug(
+            f"[service_job_start Decrypted parameters] : parameters = {agent_parameters}"
+        )
 
     # Create and prepare the job
     new_saas_job = Job.new(
         job_context=sv_context,
         agent_name=agent.name,
-        agent_parameters=[agent_parameters] if agent_parameters else None,
+        agent_parameters=agent_parameters,
         name=sv_context.job_id,
     )
 

supervaizer/parameter.py

@@ -63,7 +63,7 @@ class Parameter(ParameterAbstract):
         """
         Override the to_dict method to handle the value field.
         """
-        data = self.model_dump(mode="json")
+        data = super().to_dict
         if self.is_secret:
             data["value"] = "********"
         return data
@@ -171,3 +171,63 @@ class ParametersSetup(SvBaseModel):
                 raise ValueError(message)
 
         return self
+
+    def validate_parameters(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate parameters against their expected types and return validation errors.
+
+        Args:
+            parameters: Dictionary of parameter names and values to validate
+
+        Returns:
+            Dictionary with validation results:
+            - "valid": bool - whether all parameters are valid
+            - "errors": List[str] - list of validation error messages
+            - "invalid_parameters": Dict[str, str] - parameter name to error message mapping
+        """
+        errors = []
+        invalid_parameters = {}
+
+        # Ensure parameters is a dictionary
+        if not isinstance(parameters, dict):
+            error_msg = (
+                f"Parameters must be a dictionary, got {type(parameters).__name__}"
+            )
+            errors.append(error_msg)
+            return {
+                "valid": False,
+                "errors": errors,
+                "invalid_parameters": {"parameters": error_msg},
+            }
+
+        # First check for missing required parameters
+        for param_name, param_def in self.definitions.items():
+            if param_def.is_required and param_name not in parameters:
+                error_msg = f"Required parameter '{param_name}' is missing"
+                errors.append(error_msg)
+                invalid_parameters[param_name] = error_msg
+
+        # Then validate the provided parameters
+        for param_name, param_value in parameters.items():
+            if param_name not in self.definitions:
+                error_msg = f"Unknown parameter '{param_name}'"
+                errors.append(error_msg)
+                invalid_parameters[param_name] = error_msg
+                continue
+
+            param_def = self.definitions[param_name]
+
+            # Skip validation for None values (optional parameters)
+            if param_value is None:
+                continue
+
+            # Since Parameter values are always strings, validate that input parameters are strings
+            if not isinstance(param_value, str):
+                error_msg = f"Parameter '{param_name}' must be a string, got {type(param_value).__name__}"
+                errors.append(error_msg)
+                invalid_parameters[param_name] = error_msg
+
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors,
+            "invalid_parameters": invalid_parameters,
+        }

supervaizer/protocol/__init__.py

@@ -6,6 +6,6 @@
 
 """Protocol implementations for SUPERVAIZER."""
 
-from supervaizer.protocol import a2a, acp
+from supervaizer.protocol import a2a
 
-__all__ = ["a2a", "acp"]
+__all__ = ["a2a"]

supervaizer/protocol/a2a/routes.py

@@ -48,7 +48,7 @@ def create_routes(server: "Server") -> APIRouter:
     @handle_route_errors()
     async def get_health() -> Dict[str, Any]:
         """Get health information for the server and all agents."""
-        log.debug("[A2A] GET /.well-known/health [Health status]")
+        # log.debug("[A2A] GET /.well-known/health [Health status]")
         return create_health_data(server.agents)
 
     # Create explicit routes for each agent in the versioned format