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

supervaizer/__init__.py

@@ -14,7 +14,14 @@ from supervaizer.agent import (
     AgentMethodParams,
     AgentMethods,
 )
-from supervaizer.case import Case, CaseNodeUpdate, CaseNoteType, Cases
+from supervaizer.case import (
+    Case,
+    CaseNodeUpdate,
+    CaseNodeType,
+    Cases,
+    CaseNode,
+    CaseNodes,
+)
 from supervaizer.common import ApiError, ApiResult, ApiSuccess
 from supervaizer.event import (
     AgentRegisterEvent,
@@ -51,8 +58,10 @@ __all__ = [
     "ApiSuccess",
     "Case",
     "CaseNodeUpdate",
-    "CaseNoteType",
+    "CaseNodeType",
     "Cases",
+    "CaseNode",
+    "CaseNodes",
     "CaseStartEvent",
     "CaseUpdateEvent",
     "create_error_response",

supervaizer/__version__.py

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

supervaizer/account.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
     from supervaizer.event import Event
     from supervaizer.job import Job
     from supervaizer.server import Server
+from supervaizer.common import log
 
 
 class AccountAbstract(SvBaseModel):
@@ -268,6 +269,9 @@ class Account(AccountAbstract):
 
     def send_update_case(self, case: "Case", update: "CaseNodeUpdate") -> ApiResult:
         # Import here to avoid circular imports
+        log.debug(f"[send_update_case] CaseRef {case} with update {update}")
+        log.debug(f"[send_update_case] {type(case)}")
+        log.debug(f"[send_update_case] {type(update)}")
         from supervaizer.event import CaseUpdateEvent
 
         event = CaseUpdateEvent(case=case, update=update, account=self)

supervaizer/account_service.py

@@ -9,6 +9,7 @@
 # https://mozilla.org/MPL/2.0/.
 
 import logging
+import os
 from typing import TYPE_CHECKING, Union
 
 import httpx
@@ -19,6 +20,11 @@ logger = logging.getLogger("httpx")
 # Enable httpx debug logging (optional - uncomment for transport-level debugging)
 logger.setLevel(logging.DEBUG)
 
+_httpx_transport = httpx.HTTPTransport(
+    retries=int(os.getenv("SUPERVAIZE_HTTP_MAX_RETRIES", 2))
+)
+_httpx_client = httpx.Client(transport=_httpx_transport)
+
 if TYPE_CHECKING:
     from supervaizer.account import Account
     from supervaizer.agent import Agent
@@ -60,7 +66,7 @@ def send_event(
     curl_cmd = f"curl -X 'GET' '{account.url_event}'  {curl_headers}"
 
     try:
-        response = httpx.post(account.url_event, headers=headers, json=payload)
+        response = _httpx_client.post(account.url_event, headers=headers, json=payload)
 
         # Log response details before raising for status
 

supervaizer/admin/routes.py

@@ -27,7 +27,7 @@ from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel
 from sse_starlette.sse import EventSourceResponse
 
-from supervaizer.__version__ import API_VERSION
+from supervaizer.__version__ import API_VERSION, VERSION
 from supervaizer.common import log
 from supervaizer.lifecycle import EntityStatus
 from supervaizer.storage import (
@@ -257,10 +257,11 @@ def create_admin_routes() -> APIRouter:
             stats = get_dashboard_stats(storage)
 
             return templates.TemplateResponse(
+                request,
                 "dashboard.html",
                 {
                     "request": request,
-                    "api_version": API_VERSION,
+                    "api_version": VERSION,
                     "stats": stats,
                     "system_status": "Online",
                     "db_name": "TinyDB",
@@ -276,10 +277,11 @@ def create_admin_routes() -> APIRouter:
     async def admin_jobs_page(request: Request) -> Response:
         """Jobs management page."""
         return templates.TemplateResponse(
+            request,
             "jobs_list.html",
             {
                 "request": request,
-                "api_version": API_VERSION,
+                "api_version": VERSION,
                 "api_key": os.getenv("SUPERVAIZER_API_KEY"),
             },
         )
@@ -288,10 +290,11 @@ def create_admin_routes() -> APIRouter:
     async def admin_cases_page(request: Request) -> Response:
         """Cases management page."""
         return templates.TemplateResponse(
+            request,
             "cases_list.html",
             {
                 "request": request,
-                "api_version": API_VERSION,
+                "api_version": VERSION,
                 "api_key": os.getenv("SUPERVAIZER_API_KEY"),
             },
         )
@@ -305,10 +308,11 @@ def create_admin_routes() -> APIRouter:
             server_config = get_server_configuration(storage)
 
             return templates.TemplateResponse(
+                request,
                 "server.html",
                 {
                     "request": request,
-                    "api_version": API_VERSION,
+                    "api_version": VERSION,
                     "server_status": server_status,
                     "server_config": server_config,
                     "api_key": os.getenv("SUPERVAIZER_API_KEY"),
@@ -331,10 +335,11 @@ def create_admin_routes() -> APIRouter:
                 )
 
             return templates.TemplateResponse(
+                request,
                 "agents.html",
                 {
                     "request": request,
-                    "api_version": API_VERSION,
+                    "api_version": VERSION,
                     "agents": server_info.agents,
                     "api_key": os.getenv("SUPERVAIZER_API_KEY"),
                 },
@@ -345,6 +350,30 @@ 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(
+            request,
+            "job_start_test.html",
+            {
+                "request": request,
+                "api_version": 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."""
@@ -355,7 +384,9 @@ def create_admin_routes() -> APIRouter:
         console_token = generate_console_token()
 
         return templates.TemplateResponse(
-            "console.html", {"request": request, "console_token": console_token}
+            request,
+            "console.html",
+            {"request": request, "console_token": console_token},
         )
 
     # API Routes
@@ -371,6 +402,7 @@ def create_admin_routes() -> APIRouter:
             server_status = get_server_status()
 
             return templates.TemplateResponse(
+                request,
                 "server_status_cards.html",
                 {
                     "request": request,
@@ -443,6 +475,7 @@ def create_admin_routes() -> APIRouter:
                 pass
 
             return templates.TemplateResponse(
+                request,
                 "agents_grid.html",
                 {
                     "request": request,
@@ -480,6 +513,7 @@ def create_admin_routes() -> APIRouter:
                 raise HTTPException(status_code=404, detail="Agent not found")
 
             return templates.TemplateResponse(
+                request,
                 "agent_detail.html",
                 {
                     "request": request,
@@ -563,6 +597,7 @@ def create_admin_routes() -> APIRouter:
                 jobs.append(job)
 
             return templates.TemplateResponse(
+                request,
                 "jobs_table.html",
                 {
                     "request": request,
@@ -591,6 +626,7 @@ def create_admin_routes() -> APIRouter:
             cases_data = storage.get_cases_for_job(job_id)
 
             return templates.TemplateResponse(
+                request,
                 "job_detail.html",
                 {
                     "request": request,
@@ -681,6 +717,7 @@ def create_admin_routes() -> APIRouter:
                 cases.append(case)
 
             return templates.TemplateResponse(
+                request,
                 "cases_table.html",
                 {
                     "request": request,
@@ -711,6 +748,7 @@ def create_admin_routes() -> APIRouter:
                 job_data = storage.get_object_by_id("Job", case_data["job_id"])
 
             return templates.TemplateResponse(
+                request,
                 "case_detail.html",
                 {
                     "request": request,
@@ -862,6 +900,7 @@ def create_admin_routes() -> APIRouter:
             activities = activities[:10]  # Top 10 recent activities
 
             return templates.TemplateResponse(
+                request,
                 "recent_activity.html",
                 {
                     "request": request,

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;
+}