supervaizer 0.9.6__tar.gz → 0.9.8__tar.gz

{supervaizer-0.9.6 → supervaizer-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervaizer
-Version: 0.9.6
+Version: 0.9.8
 Summary: Controller system for Supervaize
 Project-URL: Homepage, https://supervaize.com
 Project-URL: Repository, https://github.com/supervaize/supervaizer

{supervaizer-0.9.6 → supervaizer-0.9.8}/pyproject.toml

@@ -70,7 +70,7 @@ markers = [
     "db: calls to the database",
     "current: test under development",
 ]
-addopts = "--cov=supervaizer --cov-report=term --cov-report=html"
+#addopts = "--cov=supervaizer --cov-report=term --cov-report=html"
 asyncio_default_fixture_loop_scope = "function"
 testpaths = ["tests"]
 pythonpath = ["src"]

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/__version__.py

@@ -5,6 +5,6 @@
 # https://mozilla.org/MPL/2.0/.
 
 
-VERSION = "0.9.6"
+VERSION = "0.9.8"
 API_VERSION = "v1"
 TELEMETRY_VERSION = "v1"

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/admin/routes.py

@@ -345,6 +345,29 @@ def create_admin_routes() -> APIRouter:
                 status_code=503, detail="Server information unavailable"
             ) from e
 
+    @router.get("/job-start-test", response_class=HTMLResponse)
+    async def admin_job_start_test_page(request: Request) -> Response:
+        """Job start form test page."""
+        return templates.TemplateResponse(
+            "job_start_test.html",
+            {
+                "request": request,
+                "api_version": API_VERSION,
+                "api_key": os.getenv("SUPERVAIZER_API_KEY"),
+            },
+        )
+
+    @router.get("/static/js/job-start-form.js")
+    async def serve_job_start_form_js() -> Response:
+        """Serve the JobStartForm JavaScript file."""
+        js_file_path = Path(__file__).parent / "static" / "js" / "job-start-form.js"
+        if js_file_path.exists():
+            with open(js_file_path, "r") as f:
+                content = f.read()
+            return Response(content=content, media_type="application/javascript")
+        else:
+            raise HTTPException(status_code=404, detail="JavaScript file not found")
+
     @router.get("/console", response_class=HTMLResponse)
     async def admin_console_page(request: Request) -> Response:
         """Interactive console page - publicly accessible, authentication handled by frontend."""

supervaizer-0.9.8/src/supervaizer/admin/static/js/job-start-form.js

@@ -0,0 +1,373 @@
+/**
+ * JobStartForm - Handles job parameter validation and submission
+ *
+ * This class provides methods to validate agent parameters and method fields
+ * before starting a job, using the new validation endpoints.
+ */
+
+class JobStartForm {
+    constructor(agentPath) {
+        this.agentPath = agentPath;
+        this.form = null;
+        this.errorContainer = null;
+        this.initialize();
+    }
+
+    initialize() {
+        // Wait for DOM to be ready
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', () => this.setupForm());
+        } else {
+            this.setupForm();
+        }
+    }
+
+    setupForm() {
+        // Find the form and error container
+        this.form = document.querySelector('form[data-job-start]');
+        this.errorContainer = document.getElementById('validation-errors');
+
+        if (!this.form) {
+            console.warn('JobStartForm: No form found with data-job-start attribute');
+            return;
+        }
+
+        if (!this.errorContainer) {
+            console.warn('JobStartForm: No validation-errors container found');
+            return;
+        }
+
+        // Add submit handler
+        this.form.addEventListener('submit', (e) => this.handleSubmit(e));
+
+        // Add validation on field change
+        this.form.addEventListener('change', () => this.clearErrors());
+
+        console.log('JobStartForm initialized for', this.agentPath);
+    }
+
+    async handleSubmit(event) {
+        event.preventDefault();
+
+        // Clear previous errors
+        this.clearErrors();
+
+        // Validate both agent parameters and method fields
+        const [agentParamsValid, methodFieldsValid] = await Promise.all([
+            this.validateAgentParameters(),
+            this.validateMethodFields()
+        ]);
+
+        if (agentParamsValid && methodFieldsValid) {
+            // All validation passed, submit the form
+            this.submitForm();
+        }
+    }
+
+    async validateAgentParameters() {
+        const encryptedParams = this.getEncryptedAgentParameters();
+
+        if (!encryptedParams) {
+            return true; // No agent parameters to validate
+        }
+
+        try {
+            const response = await fetch(
+                `${this.agentPath}/validate-agent-parameters`,
+                {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-API-Key': this.getApiKey()
+                    },
+                    body: JSON.stringify({
+                        encrypted_agent_parameters: encryptedParams,
+                    }),
+                }
+            );
+
+            const result = await response.json();
+
+            if (!result.valid) {
+                this.displayAgentParameterErrors(result);
+                return false;
+            }
+
+            return true;
+        } catch (error) {
+            console.error('Agent parameter validation failed:', error);
+            this.displayError('Agent parameter validation failed due to network error');
+            return false;
+        }
+    }
+
+    async validateMethodFields() {
+        const formData = this.getFormData();
+
+        try {
+            const response = await fetch(
+                `${this.agentPath}/validate-method-fields`,
+                {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-API-Key': this.getApiKey()
+                    },
+                    body: JSON.stringify({
+                        method_name: 'job_start',
+                        job_fields: formData,
+                    }),
+                }
+            );
+
+            const result = await response.json();
+
+            if (!result.valid) {
+                this.displayMethodFieldErrors(result);
+                return false;
+            }
+
+            return true;
+        } catch (error) {
+            console.error('Method field validation failed:', error);
+            this.displayError('Method field validation failed due to network error');
+            return false;
+        }
+    }
+
+    getFormData() {
+        const formData = {};
+        const formElements = this.form.elements;
+
+        for (let element of formElements) {
+            if (element.name && element.type !== 'submit') {
+                if (element.type === 'checkbox') {
+                    formData[element.name] = element.checked;
+                } else if (element.type === 'radio') {
+                    if (element.checked) {
+                        formData[element.name] = element.value;
+                    }
+                } else if (element.type === 'select-multiple') {
+                    formData[element.name] = Array.from(element.selectedOptions).map(option => option.value);
+                } else {
+                    formData[element.name] = element.value;
+                }
+            }
+        }
+
+        return formData;
+    }
+
+    getEncryptedAgentParameters() {
+        // Look for encrypted agent parameters in hidden fields or data attributes
+        const encryptedField = this.form.querySelector('[name="encrypted_agent_parameters"]');
+        if (encryptedField) {
+            return encryptedField.value;
+        }
+
+        // Check if agent parameters are stored in data attributes
+        const agentParamsData = this.form.dataset.agentParameters;
+        if (agentParamsData) {
+            try {
+                return JSON.parse(agentParamsData);
+            } catch (e) {
+                console.warn('Failed to parse agent parameters from data attribute');
+            }
+        }
+
+        return null;
+    }
+
+    getApiKey() {
+        // Get API key from form data, meta tag, or global variable
+        const apiKeyField = this.form.querySelector('[name="api_key"]');
+        if (apiKeyField) {
+            return apiKeyField.value;
+        }
+
+        const metaApiKey = document.querySelector('meta[name="api-key"]');
+        if (metaApiKey) {
+            return metaApiKey.content;
+        }
+
+        // Check for global variable
+        if (typeof window.SUPERVAIZER_API_KEY !== 'undefined') {
+            return window.SUPERVAIZER_API_KEY;
+        }
+
+        return '';
+    }
+
+    displayAgentParameterErrors(validationResult) {
+        const errorSection = document.getElementById('agent-parameter-errors');
+        if (!errorSection) {
+            // Create error section if it doesn't exist
+            const section = document.createElement('div');
+            section.id = 'agent-parameter-errors';
+            section.className = 'mb-4';
+            this.errorContainer.appendChild(section);
+        }
+
+        const section = document.getElementById('agent-parameter-errors');
+        section.innerHTML = `
+            <div class="alert alert-warning">
+                <strong>Agent Configuration Issues:</strong> ${validationResult.message
+            }
+                <ul>
+                    ${validationResult.errors
+                .map((error) => `<li>${error}</li>`)
+                .join('')}
+                </ul>
+            </div>
+        `;
+    }
+
+    displayMethodFieldErrors(validationResult) {
+        // Clear any existing field-specific errors
+        this.form.querySelectorAll('.is-invalid').forEach((field) => {
+            field.classList.remove('is-invalid');
+        });
+
+        // Display general error message
+        this.displayError(validationResult.message);
+
+        // Mark invalid fields and show specific error messages
+        Object.entries(validationResult.invalid_fields).forEach(([fieldName, errorMessage]) => {
+            const field = this.form.querySelector(`[name="${fieldName}"]`);
+            if (field) {
+                field.classList.add('is-invalid');
+
+                // Add error message below the field
+                let errorElement = field.parentNode.querySelector('.invalid-feedback');
+                if (!errorElement) {
+                    errorElement = document.createElement('div');
+                    errorElement.className = 'invalid-feedback';
+                    field.parentNode.appendChild(errorElement);
+                }
+                errorElement.textContent = errorMessage;
+            }
+        });
+    }
+
+    displayError(message) {
+        this.errorContainer.innerHTML = `
+            <div class="alert alert-danger">
+                <strong>Validation Error:</strong> ${message}
+            </div>
+        `;
+    }
+
+    clearErrors() {
+        this.errorContainer.innerHTML = '';
+
+        // Clear agent parameter errors
+        const agentErrorSection = document.getElementById('agent-parameter-errors');
+        if (agentErrorSection) {
+            agentErrorSection.innerHTML = '';
+        }
+
+        // Clear field errors
+        this.form.querySelectorAll('.is-invalid').forEach((field) => {
+            field.classList.remove('is-invalid');
+        });
+
+        // Clear invalid feedback messages
+        this.form.querySelectorAll('.invalid-feedback').forEach((feedback) => {
+            feedback.remove();
+        });
+    }
+
+    async submitForm() {
+        try {
+            const formData = this.getFormData();
+            const encryptedParams = this.getEncryptedAgentParameters();
+
+            const requestBody = {
+                job_context: {
+                    // Add any job context data here
+                },
+                job_fields: formData
+            };
+
+            if (encryptedParams) {
+                requestBody.encrypted_agent_parameters = encryptedParams;
+            }
+
+            const response = await fetch(`${this.agentPath}/jobs`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-API-Key': this.getApiKey()
+                },
+                body: JSON.stringify(requestBody)
+            });
+
+            if (response.ok) {
+                const result = await response.json();
+                this.handleJobStarted(result);
+            } else {
+                const error = await response.json();
+                this.handleJobError(error);
+            }
+        } catch (error) {
+            console.error('Job submission failed:', error);
+            this.displayError('Failed to submit job due to network error');
+        }
+    }
+
+    handleJobStarted(jobData) {
+        // Clear form and show success message
+        this.form.reset();
+        this.clearErrors();
+
+        this.errorContainer.innerHTML = `
+            <div class="alert alert-success">
+                <strong>Job Started Successfully!</strong><br>
+                Job ID: ${jobData.id || 'Unknown'}<br>
+                Status: ${jobData.status || 'Unknown'}
+            </div>
+        `;
+
+        // Trigger any success callbacks
+        if (typeof this.onJobStarted === 'function') {
+            this.onJobStarted(jobData);
+        }
+    }
+
+    handleJobError(error) {
+        this.displayError(`Job submission failed: ${error.detail || error.message || 'Unknown error'}`);
+
+        // Trigger any error callbacks
+        if (typeof this.onJobError === 'function') {
+            this.onJobError(error);
+        }
+    }
+
+    // Public methods for external use
+    setOnJobStarted(callback) {
+        this.onJobStarted = callback;
+    }
+
+    setOnJobError(callback) {
+        this.onJobError = callback;
+    }
+
+    // Method to manually trigger validation
+    async validate() {
+        const [agentParamsValid, methodFieldsValid] = await Promise.all([
+            this.validateAgentParameters(),
+            this.validateMethodFields()
+        ]);
+        return agentParamsValid && methodFieldsValid;
+    }
+}
+
+// Export for module systems
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = JobStartForm;
+}
+
+// Make available globally
+if (typeof window !== 'undefined') {
+    window.JobStartForm = JobStartForm;
+}

supervaizer-0.9.8/src/supervaizer/admin/templates/job_start_test.html

@@ -0,0 +1,109 @@
+{% extends "base.html" %}
+
+{% block content %}
+<div class="max-w-4xl mx-auto">
+    <div class="bg-white shadow rounded-lg p-6">
+        <h1 class="text-2xl font-bold text-gray-900 mb-6">Job Start Form Test</h1>
+
+        <!-- Validation Errors Container -->
+        <div id="validation-errors" class="mb-6"></div>
+
+        <!-- Agent Parameter Errors Container -->
+        <div id="agent-parameter-errors" class="mb-6"></div>
+
+        <!-- Job Start Form -->
+        <form data-job-start method="POST" class="space-y-6">
+            <!-- Job Fields -->
+            <div class="space-y-4">
+                <h3 class="text-lg font-medium text-gray-900">Job Parameters</h3>
+
+                <div>
+                    <label for="company_name" class="block text-sm font-medium text-gray-700">
+                        Company Name *
+                    </label>
+                    <input
+                        type="text"
+                        id="company_name"
+                        name="company_name"
+                        required
+                        class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
+                        placeholder="Enter company name"
+                    >
+                </div>
+
+                <div>
+                    <label for="max_results" class="block text-sm font-medium text-gray-700">
+                        Max Results *
+                    </label>
+                    <input
+                        type="number"
+                        id="max_results"
+                        name="max_results"
+                        required
+                        class="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
+                        placeholder="Enter maximum results"
+                    >
+                </div>
+
+                <div>
+                    <label for="subscribe_updates" class="block text-sm font-medium text-gray-700">
+                        Subscribe to Updates
+                    </label>
+                    <input
+                        type="checkbox"
+                        id="subscribe_updates"
+                        name="subscribe_updates"
+                        class="mt-1 h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 rounded"
+                    >
+                    <span class="ml-2 text-sm text-gray-600">Receive email updates about this job</span>
+                </div>
+            </div>
+
+            <!-- Hidden Fields for Testing -->
+            <input type="hidden" name="encrypted_agent_parameters" value="test_encrypted_params">
+            <input type="hidden" name="api_key" value="{{ api_key }}">
+
+            <!-- Submit Button -->
+            <div class="flex justify-end">
+                <button
+                    type="submit"
+                    class="bg-blue-600 hover:bg-blue-700 text-white font-medium py-2 px-4 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2"
+                >
+                    Start Job
+                </button>
+            </div>
+        </form>
+    </div>
+</div>
+
+<script>
+    // Initialize JobStartForm when the page loads
+    document.addEventListener('DOMContentLoaded', function() {
+        // Wait for JobStartForm class to be available
+        function waitForJobStartForm() {
+            if (typeof window.JobStartForm !== 'undefined') {
+                console.log('JobStartForm class found, initializing...');
+
+                // Initialize the form with the current agent path
+                const form = new JobStartForm('/test-agent');
+
+                // Set up callbacks
+                form.setOnJobStarted(function(jobData) {
+                    console.log('Job started successfully:', jobData);
+                });
+
+                form.setOnJobError(function(error) {
+                    console.error('Job failed:', error);
+                });
+
+                console.log('JobStartForm initialized successfully');
+            } else {
+                console.log('JobStartForm class not ready yet, waiting...');
+                setTimeout(waitForJobStartForm, 100);
+            }
+        }
+
+        waitForJobStartForm();
+    });
+</script>
+{% endblock %}

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/agent.py

@@ -83,8 +83,7 @@ class AgentMethodField(BaseModel):
     description: str | None = Field(
         default=None, description="Description of the field - displayed in the UI"
     )
-    # TODO: confirm the structure of choices (list[str] or list[tuple(str)) - How do we integrate it in Supervaize
-    choices: list[str] | None = Field(
+    choices: list[tuple[str, str]] | list[str] | None = Field(
         default=None, description="For choice fields, list of [value, label] pairs"
     )
 
@@ -244,32 +243,151 @@ class AgentMethod(AgentMethodAbstract):
             return type("EmptyFieldsModel", (BaseModel,), {"to_dict": lambda self: {}})
 
         field_annotations = {}
-        field_defaults: Dict[str, None] = {}
         for field in self.fields:
             field_name = field.name
             field_type = field.type
-            is_required = field.required
+
+            # Convert Python types to proper typing annotations
+            if field_type is str:
+                annotation_type: type = str
+            elif field_type is int:
+                annotation_type = int
+            elif field_type is bool:
+                annotation_type = bool
+            elif field_type is list:
+                annotation_type = list
+            elif field_type is dict:
+                annotation_type = dict
+            elif field_type is float:
+                annotation_type = float
+            elif hasattr(field_type, "__origin__") and field_type.__origin__ is list:
+                # Handle generic list types like list[str]
+                annotation_type = list
+            elif hasattr(field_type, "__origin__") and field_type.__origin__ is dict:
+                # Handle generic dict types like dict[str, Any]
+                annotation_type = dict
+            else:
+                # Default to Any for unknown types
+                annotation_type = Any
+
+            # Make field optional if not required
             field_annotations[field_name] = (
-                field_type if is_required else Optional[field_type]
+                annotation_type if field.required else Optional[annotation_type]
             )
-            if not is_required:
-                field_defaults[field_name] = None
 
-        def to_dict(self: BaseModel) -> Dict[str, Any]:
+        # Create the dynamic model with proper module information
+        model_dict = {
+            "__module__": "supervaizer.agent",
+            "__annotations__": field_annotations,
+            "to_dict": lambda self: {
+                k: getattr(self, k)
+                for k in field_annotations.keys()
+                if hasattr(self, k)
+            },
+        }
+
+        return type("DynamicFieldsModel", (BaseModel,), model_dict)
+
+    def validate_method_fields(self, job_fields: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate job fields against the method's field definitions.
+
+        Args:
+            job_fields: Dictionary of field names and values to validate
+
+        Returns:
+            Dictionary with validation results:
+            - "valid": bool - whether all fields are valid
+            - "errors": List[str] - list of validation error messages
+            - "invalid_fields": Dict[str, str] - field name to error message mapping
+        """
+        if self.fields is None:
+            return {
+                "valid": True,
+                "message": "Method has no field definitions",
+                "errors": [],
+                "invalid_fields": {},
+            }
+
+        if len(self.fields) == 0:
             return {
-                field_name: getattr(self, field_name)
-                for field_name in self.__annotations__
+                "valid": True,
+                "message": "Method fields validated successfully",
+                "errors": [],
+                "invalid_fields": {},
             }
 
-        return type(
-            "DynamicFieldsModel",
-            (BaseModel,),
-            {
-                "__annotations__": field_annotations,
-                "to_dict": to_dict,
-                **field_defaults,
-            },
-        )
+        errors = []
+        invalid_fields = {}
+
+        # First check for missing required fields
+        for field in self.fields:
+            if field.required and field.name not in job_fields:
+                error_msg = f"Required field '{field.name}' is missing"
+                errors.append(error_msg)
+                invalid_fields[field.name] = error_msg
+
+        # Then validate the provided fields
+        for field_name, field_value in job_fields.items():
+            # Find the field definition
+            field_def = next((f for f in self.fields if f.name == field_name), None)
+            if not field_def:
+                error_msg = f"Unknown field '{field_name}'"
+                errors.append(error_msg)
+                invalid_fields[field_name] = error_msg
+                continue
+
+            # Skip validation for None values (optional fields)
+            if field_value is None:
+                continue
+
+            # Type validation
+            expected_type = field_def.type
+            if expected_type:
+                try:
+                    # Handle special cases for type validation
+                    if expected_type is str:
+                        if not isinstance(field_value, str):
+                            error_msg = f"Field '{field_name}' must be a string, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                    elif expected_type is int:
+                        if not isinstance(field_value, int):
+                            error_msg = f"Field '{field_name}' must be an integer, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                    elif expected_type is bool:
+                        if not isinstance(field_value, bool):
+                            error_msg = f"Field '{field_name}' must be a boolean, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                    elif expected_type is list:
+                        if not isinstance(field_value, list):
+                            error_msg = f"Field '{field_name}' must be a list, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                    elif expected_type is dict:
+                        if not isinstance(field_value, dict):
+                            error_msg = f"Field '{field_name}' must be a dictionary, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                    elif expected_type is float:
+                        if not isinstance(field_value, (int, float)):
+                            error_msg = f"Field '{field_name}' must be a number, got {type(field_value).__name__}"
+                            errors.append(error_msg)
+                            invalid_fields[field_name] = error_msg
+                except Exception as e:
+                    error_msg = f"Field '{field_name}' validation failed: {str(e)}"
+                    errors.append(error_msg)
+                    invalid_fields[field_name] = error_msg
+
+        return {
+            "valid": len(errors) == 0,
+            "message": "Method fields validated successfully"
+            if len(errors) == 0
+            else "Method field validation failed",
+            "errors": errors,
+            "invalid_fields": invalid_fields,
+        }
 
     @property
     def job_model(self) -> type[AgentJobContextBase]:
@@ -553,7 +671,7 @@ class Agent(AgentAbstract):
         """Returns registration info for the agent"""
         return {
             "name": self.name,
-            "id": self.id,
+            "id": f"{self.id}",
             "author": self.author,
             "developer": self.developer,
             "maintainer": self.maintainer,
@@ -567,7 +685,7 @@ class Agent(AgentAbstract):
             "parameters_setup": self.parameters_setup.registration_info
             if self.parameters_setup
             else None,
-            "server_agent_id": self.server_agent_id,
+            "server_agent_id": f"{self.server_agent_id}",
             "server_agent_status": self.server_agent_status,
             "server_agent_onboarding_status": self.server_agent_onboarding_status,
             "server_encrypted_parameters": self.server_encrypted_parameters,

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/cli.py

@@ -6,7 +6,10 @@
 
 import os
 import shutil
+import signal
+import subprocess
 import sys
+from typing import Any
 from pathlib import Path
 from typing import Optional
 
@@ -79,12 +82,20 @@ def start(
     console.print(f"[bold green]Starting Supervaizer Controller v{VERSION}[/]")
     console.print(f"Loading configuration from [bold]{script_path}[/]")
 
-    # Execute the script
-    with open(script_path, "r") as f:
-        script_content = f.read()
+    # Execute the script in a new Python process with proper signal handling
 
-    # Execute the script in the current global namespace
-    exec(script_content, globals())
+    def signal_handler(signum: int, frame: Any) -> None:
+        # Send the signal to the subprocess
+        if "process" in globals():
+            globals()["process"].terminate()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    process = subprocess.Popen([sys.executable, script_path])
+    globals()["process"] = process
+    process.wait()
 
 
 @app.command()
@@ -107,7 +118,7 @@ def scaffold(
 
     # Get the path to the examples directory
     examples_dir = Path(__file__).parent / "examples"
-    example_file = examples_dir / "controller-template.py"
+    example_file = examples_dir / "controller_template.py"
 
     if not example_file.exists():
         console.print("[bold red]Error:[/] Example file not found")

supervaizer-0.9.6/src/supervaizer/examples/controller-template.py → supervaizer-0.9.8/src/supervaizer/examples/controller_template.py

@@ -175,10 +175,11 @@ agent: Agent = Agent(
     parameters_setup=agent_parameters,
 )
 
+# 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

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/parameter.py

@@ -171,3 +171,51 @@ 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 = {}
+
+        # 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-0.9.6 → supervaizer-0.9.8}/src/supervaizer/routes.py

@@ -383,6 +383,129 @@ def create_agent_route(server: "Server", agent: Agent) -> APIRouter:
             **agent.registration_info,
         )
 
+    @router.post(
+        "/validate-agent-parameters",
+        summary=f"Validate agent parameters for agent: {agent.name}",
+        description="Validate agent configuration parameters (secrets, API keys, etc.) before starting a job",
+        response_model=Dict[str, Any],
+        responses={
+            http_status.HTTP_200_OK: {"model": Dict[str, Any]},
+            http_status.HTTP_400_BAD_REQUEST: {"model": Dict[str, Any]},
+            http_status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
+        },
+        dependencies=[Security(server.verify_api_key)],
+    )
+    @handle_route_errors()
+    async def validate_agent_parameters(
+        body_params: Any = Body(...),
+        agent: Agent = Depends(get_agent),
+    ) -> Dict[str, Any]:
+        """Validate agent parameters for this agent"""
+        log.info(
+            f"📥 POST /validate-agent-parameters [Validate agent parameters] {agent.name}"
+        )
+
+        if not agent.parameters_setup:
+            return {
+                "valid": True,
+                "message": "Agent has no parameter setup defined",
+                "errors": [],
+                "invalid_parameters": {},
+            }
+
+        encrypted_agent_parameters = body_params.get("encrypted_agent_parameters")
+
+        # Decrypt agent parameters if provided
+        agent_parameters: Dict[str, Any] = {}
+        if encrypted_agent_parameters:
+            try:
+                from supervaizer.common import decrypt_value
+                import json
+
+                agent_parameters_str = decrypt_value(
+                    encrypted_agent_parameters, server.private_key
+                )
+                agent_parameters = (
+                    json.loads(agent_parameters_str) if agent_parameters_str else {}
+                )
+            except Exception as e:
+                return {
+                    "valid": False,
+                    "message": f"Failed to decrypt agent parameters: {str(e)}",
+                    "errors": [f"Decryption failed: {str(e)}"],
+                    "invalid_parameters": {
+                        "encrypted_agent_parameters": f"Decryption failed: {str(e)}"
+                    },
+                }
+
+        # Validate agent parameters
+        validation_result = agent.parameters_setup.validate_parameters(agent_parameters)
+
+        return {
+            "valid": validation_result["valid"],
+            "message": "Agent parameters validated successfully"
+            if validation_result["valid"]
+            else "Agent parameter validation failed",
+            "errors": validation_result["errors"],
+            "invalid_parameters": validation_result["invalid_parameters"],
+        }
+
+    @router.post(
+        "/validate-method-fields",
+        summary=f"Validate method fields for agent: {agent.name}",
+        description="Validate job input fields against the method's field definitions before starting a job",
+        response_model=Dict[str, Any],
+        responses={
+            http_status.HTTP_200_OK: {"model": Dict[str, Any]},
+            http_status.HTTP_400_BAD_REQUEST: {"model": Dict[str, Any]},
+            http_status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
+        },
+        dependencies=[Security(server.verify_api_key)],
+    )
+    @handle_route_errors()
+    async def validate_method_fields(
+        body_params: Any = Body(...),
+        agent: Agent = Depends(get_agent),
+    ) -> Dict[str, Any]:
+        """Validate method fields for this agent"""
+        log.info(
+            f"📥 POST /validate-method-fields [Validate method fields] {agent.name}"
+        )
+
+        method_name = body_params.get("method_name", "job_start")
+        job_fields = body_params.get("job_fields", {})
+
+        # Get the method to validate against
+        if not agent.methods:
+            return {
+                "valid": False,
+                "message": "Agent has no methods defined",
+                "errors": ["Agent has no methods defined"],
+                "invalid_fields": {},
+            }
+
+        if method_name == "job_start":
+            method = agent.methods.job_start
+        elif agent.methods.custom and method_name in agent.methods.custom:
+            method = agent.methods.custom[method_name]
+        else:
+            return {
+                "valid": False,
+                "message": f"Method '{method_name}' not found",
+                "errors": [f"Method '{method_name}' not found"],
+                "invalid_fields": {},
+            }
+
+        # Validate method fields
+        validation_result = method.validate_method_fields(job_fields)
+
+        return {
+            "valid": validation_result["valid"],
+            "message": validation_result["message"],
+            "errors": validation_result["errors"],
+            "invalid_fields": validation_result["invalid_fields"],
+        }
+
     if not agent.methods:
         raise ValueError(f"Agent {agent.name} has no methods defined")
 
@@ -400,6 +523,7 @@ def create_agent_route(server: "Server", agent: Agent) -> APIRouter:
         description=f"{agent.methods.job_start.description}",
         responses={
             http_status.HTTP_202_ACCEPTED: {"model": Job},
+            http_status.HTTP_400_BAD_REQUEST: {"model": Dict[str, Any]},
             http_status.HTTP_409_CONFLICT: {"model": ErrorResponse},
             http_status.HTTP_500_INTERNAL_SERVER_ERROR: {"model": ErrorResponse},
         },
@@ -415,13 +539,12 @@ def create_agent_route(server: "Server", agent: Agent) -> APIRouter:
     ) -> Union[Job, JSONResponse]:
         """Start a new job for this agent"""
         log.info(f"📥 POST /jobs [Start job] {agent.name} with params {body_params}")
-        sv_context: JobContext = body_params.job_context
-        job_fields = body_params.job_fields.to_dict()
+
+        sv_context: JobContext = JobContext(**body_params["job_context"])
+        job_fields = body_params["job_fields"]
 
         # Get job encrypted parameters if available
-        encrypted_agent_parameters = getattr(
-            body_params, "encrypted_agent_parameters", None
-        )
+        encrypted_agent_parameters = body_params.get("encrypted_agent_parameters")
 
         # Delegate job creation and scheduling to the service
         new_job = await service_job_start(
@@ -623,6 +746,7 @@ def create_agent_custom_routes(server: "Server", agent: Agent) -> APIRouter:
             response_model=JobResponse,
             responses={
                 http_status.HTTP_202_ACCEPTED: {"model": JobResponse},
+                http_status.HTTP_400_BAD_REQUEST: {"model": Dict[str, Any]},
                 http_status.HTTP_405_METHOD_NOT_ALLOWED: {"model": ErrorResponse},
             },
             dependencies=[Security(server.verify_api_key)],
@@ -637,6 +761,8 @@ def create_agent_custom_routes(server: "Server", agent: Agent) -> APIRouter:
             log.info(
                 f"📥 POST /custom/{method_name} [custom job] {agent.name} with params {body_params}"
             )
+            log.info(f"body_params: {body_params}")
+
             sv_context: JobContext = body_params.job_context
             job_fields = body_params.job_fields.to_dict()
 

{supervaizer-0.9.6 → supervaizer-0.9.8}/src/supervaizer/server.py

@@ -131,6 +131,8 @@ class ServerAbstract(SvBaseModel):
     The server can be configured with various endpoints (A2A, ACP, admin interface)
     and supports encryption/decryption of parameters using RSA keys.
 
+    Note that when the supervisor ccount is set, the A2A protocol is automatically activated to provide HEALTH CHECK endpoints.
+
     public_url: full url (including scheme and port) to use for outbound connections and registration.
                 This is especially important in Docker environments where the binding
                 address (0.0.0.0) can't be used for outbound connections. Set to
@@ -359,12 +361,15 @@ class Server(ServerAbstract):
 
         # Create routes
         if self.supervisor_account:
-            log.info("[Server launch] 🚀 Deploy Supervaizer routes")
+            log.info(
+                "[Server launch] 🚀 Deploy Supervaizer routes - also activates A2A routes"
+            )
             self.app.include_router(create_default_routes(self))
             self.app.include_router(create_utils_routes(self))
             self.app.include_router(create_agents_routes(self))
+            self.a2a_endpoints = True  # Needed by supervaize.
         if self.a2a_endpoints:
-            log.info("[Server launch] 📢 Deploy A2A routes")
+            log.info("[Server launch] 📢 Deploy A2A routes  ")
             self.app.include_router(create_a2a_routes(self))
         if self.acp_endpoints:
             log.info("[Server launch] 📢 Deploy ACP routes")