supervaizer 0.9.7__tar.gz → 0.9.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervaizer
-Version: 0.9.7
+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.7 → 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.7 → supervaizer-0.9.8}/src/supervaizer/__version__.py

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

{supervaizer-0.9.7 → 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.7 → 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]:

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

@@ -118,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.7/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.7 → 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.7 → 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()