@d34dman/flowdrop 0.0.56 → 0.0.58

package/dist/services/agentSpecExecutionService.js

@@ -0,0 +1,333 @@
+/**
+ * Agent Spec Execution Service
+ *
+ * Connects FlowDrop to Agent Spec runtimes (WayFlow/PyAgentSpec) for
+ * workflow execution, status tracking, and result retrieval.
+ *
+ * Follows the same singleton pattern as NodeExecutionService.
+ */
+import { buildAgentSpecUrl, getAgentSpecAuthHeaders } from '../config/agentSpecEndpoints.js';
+import { AgentSpecAdapter } from '../adapters/agentspec/AgentSpecAdapter.js';
+/**
+ * Service for executing FlowDrop workflows on Agent Spec runtimes.
+ *
+ * @example
+ * ```typescript
+ * const service = AgentSpecExecutionService.getInstance();
+ * service.configure(myRuntimeConfig);
+ *
+ * // Check runtime availability
+ * const healthy = await service.checkHealth();
+ *
+ * // Execute a workflow
+ * const handle = await service.executeWorkflow(workflow, inputs, {
+ *   onNodeUpdate: (nodeId, info) => updateNodeVisual(nodeId, info),
+ *   onComplete: (results) => showResults(results),
+ *   onError: (error) => showError(error)
+ * });
+ *
+ * // Cancel if needed
+ * await service.cancelExecution(handle.executionId);
+ * ```
+ */
+export class AgentSpecExecutionService {
+    static instance;
+    config = null;
+    adapter;
+    activeExecutions = new Map();
+    constructor() {
+        this.adapter = new AgentSpecAdapter();
+    }
+    static getInstance() {
+        if (!AgentSpecExecutionService.instance) {
+            AgentSpecExecutionService.instance = new AgentSpecExecutionService();
+        }
+        return AgentSpecExecutionService.instance;
+    }
+    /**
+     * Configure the runtime connection.
+     */
+    configure(config) {
+        this.config = config;
+    }
+    /**
+     * Check if the service has been configured with a runtime.
+     */
+    isConfigured() {
+        return this.config !== null;
+    }
+    /**
+     * Check runtime health.
+     */
+    async checkHealth() {
+        if (!this.config)
+            return false;
+        try {
+            const url = buildAgentSpecUrl(this.config, this.config.endpoints.health);
+            const response = await fetch(url, {
+                headers: getAgentSpecAuthHeaders(this.config),
+                signal: AbortSignal.timeout(5000)
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Execute a FlowDrop workflow on the Agent Spec runtime.
+     *
+     * 1. Converts StandardWorkflow → AgentSpecFlow using the adapter
+     * 2. POSTs the flow JSON to the runtime
+     * 3. Starts polling for execution status
+     * 4. Maps runtime node statuses to FlowDrop's NodeExecutionInfo
+     */
+    async executeWorkflow(workflow, inputs, callbacks, pollingIntervalMs = 2000) {
+        this.ensureConfigured();
+        // Convert to Agent Spec format
+        const agentSpecFlow = this.adapter.toAgentSpec(workflow);
+        // POST to runtime
+        const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.execute);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: getAgentSpecAuthHeaders(this.getConfig()),
+            body: JSON.stringify({
+                flow: agentSpecFlow,
+                inputs: inputs || {}
+            }),
+            signal: AbortSignal.timeout(this.getConfig().timeout || 60000)
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => 'Unknown error');
+            throw new Error(`Agent Spec runtime error (${response.status}): ${errorText}`);
+        }
+        const result = await response.json();
+        const executionId = result.execution_id || result.id;
+        if (!executionId) {
+            throw new Error('Runtime did not return an execution ID');
+        }
+        // Track execution
+        const state = {
+            id: executionId,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+            nodeStatuses: {}
+        };
+        this.activeExecutions.set(executionId, state);
+        // Build node name → FlowDrop node ID mapping for status updates
+        const nameToNodeId = new Map();
+        for (const node of workflow.nodes) {
+            const label = node.data.label || node.id;
+            nameToNodeId.set(label, node.id);
+        }
+        // Start polling
+        const stop = () => this.stopPolling(executionId);
+        if (callbacks) {
+            this.startPolling(executionId, nameToNodeId, callbacks.onNodeUpdate, callbacks.onComplete, callbacks.onError, pollingIntervalMs);
+        }
+        return { executionId, stop };
+    }
+    /**
+     * Get current execution status.
+     */
+    async getExecutionStatus(executionId) {
+        this.ensureConfigured();
+        try {
+            const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.status, {
+                id: executionId
+            });
+            const response = await fetch(url, {
+                headers: getAgentSpecAuthHeaders(this.getConfig())
+            });
+            if (!response.ok)
+                return null;
+            const data = await response.json();
+            return this.mapRuntimeStatusToNodeInfo(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Cancel a running execution.
+     */
+    async cancelExecution(executionId) {
+        this.ensureConfigured();
+        this.stopPolling(executionId);
+        const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.cancel, {
+            id: executionId
+        });
+        await fetch(url, {
+            method: 'POST',
+            headers: getAgentSpecAuthHeaders(this.getConfig())
+        });
+        const state = this.activeExecutions.get(executionId);
+        if (state) {
+            state.status = 'cancelled';
+        }
+    }
+    /**
+     * Get execution results.
+     */
+    async getResults(executionId) {
+        this.ensureConfigured();
+        try {
+            const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.results, {
+                id: executionId
+            });
+            const response = await fetch(url, {
+                headers: getAgentSpecAuthHeaders(this.getConfig())
+            });
+            if (!response.ok)
+                return null;
+            return await response.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Validate a workflow against the runtime.
+     */
+    async validateOnRuntime(workflow) {
+        this.ensureConfigured();
+        const agentSpecFlow = this.adapter.toAgentSpec(workflow);
+        const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.validate);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: getAgentSpecAuthHeaders(this.getConfig()),
+            body: JSON.stringify(agentSpecFlow)
+        });
+        if (!response.ok) {
+            return { valid: false, errors: [`Runtime validation failed: ${response.status}`] };
+        }
+        return await response.json();
+    }
+    /**
+     * Clean up all active executions.
+     */
+    destroy() {
+        for (const [id] of this.activeExecutions) {
+            this.stopPolling(id);
+        }
+        this.activeExecutions.clear();
+    }
+    // ========================================================================
+    // Private
+    // ========================================================================
+    ensureConfigured() {
+        if (!this.config) {
+            throw new Error('AgentSpecExecutionService not configured. Call configure() with runtime endpoint config first.');
+        }
+    }
+    /** Get the config, throwing if not configured */
+    getConfig() {
+        this.ensureConfigured();
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.config;
+    }
+    startPolling(executionId, nameToNodeId, onNodeUpdate, onComplete, onError, intervalMs = 2000) {
+        const state = this.activeExecutions.get(executionId);
+        if (!state)
+            return;
+        const poll = async () => {
+            try {
+                const url = buildAgentSpecUrl(this.getConfig(), this.getConfig().endpoints.status, {
+                    id: executionId
+                });
+                const response = await fetch(url, {
+                    headers: getAgentSpecAuthHeaders(this.getConfig())
+                });
+                if (!response.ok) {
+                    throw new Error(`Status check failed: ${response.status}`);
+                }
+                const data = await response.json();
+                const executionStatus = data.status || data.execution_status;
+                // Map node statuses
+                const nodeStatuses = data.node_statuses || data.nodes || {};
+                for (const [nodeName, status] of Object.entries(nodeStatuses)) {
+                    const nodeId = nameToNodeId.get(nodeName) || nodeName;
+                    const info = this.mapSingleNodeStatus(status);
+                    state.nodeStatuses[nodeId] = info;
+                    onNodeUpdate?.(nodeId, info);
+                }
+                // Check if execution is done
+                if (executionStatus === 'completed' || executionStatus === 'success') {
+                    state.status = 'completed';
+                    this.stopPolling(executionId);
+                    const results = await this.getResults(executionId);
+                    onComplete?.(results || {});
+                }
+                else if (executionStatus === 'failed' || executionStatus === 'error') {
+                    state.status = 'failed';
+                    this.stopPolling(executionId);
+                    const errorMsg = data.error || data.message || 'Execution failed';
+                    onError?.(new Error(errorMsg));
+                }
+                else if (executionStatus === 'cancelled') {
+                    state.status = 'cancelled';
+                    this.stopPolling(executionId);
+                }
+            }
+            catch (error) {
+                // Don't stop polling on transient errors — let it retry
+                console.error('[AgentSpecExecution] Polling error:', error);
+            }
+        };
+        // Initial poll immediately, then at interval
+        poll();
+        state.pollingInterval = setInterval(poll, intervalMs);
+    }
+    stopPolling(executionId) {
+        const state = this.activeExecutions.get(executionId);
+        if (state?.pollingInterval) {
+            clearInterval(state.pollingInterval);
+            state.pollingInterval = undefined;
+        }
+    }
+    mapRuntimeStatusToNodeInfo(data) {
+        const result = {};
+        const nodeStatuses = (data.node_statuses || data.nodes || {});
+        for (const [nodeName, status] of Object.entries(nodeStatuses)) {
+            result[nodeName] = this.mapSingleNodeStatus(status);
+        }
+        return result;
+    }
+    mapSingleNodeStatus(status) {
+        const runtimeStatus = (status.status || status.state || 'idle');
+        return {
+            status: this.mapToFlowDropStatus(runtimeStatus),
+            executionCount: status.execution_count || 0,
+            isExecuting: runtimeStatus === 'running' || runtimeStatus === 'executing',
+            lastExecuted: status.started_at,
+            lastExecutionDuration: status.duration_ms,
+            lastError: status.error
+        };
+    }
+    mapToFlowDropStatus(runtimeStatus) {
+        switch (runtimeStatus) {
+            case 'running':
+            case 'executing':
+                return 'running';
+            case 'completed':
+            case 'success':
+            case 'done':
+                return 'completed';
+            case 'failed':
+            case 'error':
+                return 'failed';
+            case 'cancelled':
+            case 'canceled':
+                return 'cancelled';
+            case 'pending':
+            case 'queued':
+                return 'pending';
+            case 'skipped':
+                return 'skipped';
+            default:
+                return 'idle';
+        }
+    }
+}
+/** Singleton instance */
+export const agentSpecExecutionService = AgentSpecExecutionService.getInstance();

package/dist/stores/portCoordinateStore.js

@@ -65,10 +65,7 @@ function computeNodePortCoordinates(node, internalNode) {
     const posAbs = internalNode.internals.positionAbsolute;
     const dataTypeLookup = buildPortDataTypeLookup(node);
     const coordinates = [];
-    const allHandles = [
-        ...(handleBounds.source ?? []),
-        ...(handleBounds.target ?? [])
-    ];
+    const allHandles = [...(handleBounds.source ?? []), ...(handleBounds.target ?? [])];
     for (const handle of allHandles) {
         if (!handle.id)
             continue;

package/dist/stores/workflowStore.d.ts

@@ -86,7 +86,10 @@ export declare const workflowMetadata: import("svelte/store").Readable<{
     tags?: string[];
     versionId?: string;
     updateNumber?: number;
+    format?: import("../types").WorkflowFormat;
 }>;
+/** Derived store for the current workflow format */
+export declare const workflowFormat: import("svelte/store").Readable<import("../types").WorkflowFormat>;
 /**
  * Actions for updating the workflow
  *

package/dist/stores/workflowStore.js

@@ -7,6 +7,7 @@
  * @module stores/workflowStore
  */
 import { writable, derived, get } from 'svelte/store';
+import { DEFAULT_WORKFLOW_FORMAT } from '../types/index.js';
 import { historyService } from '../services/historyService.js';
 // =========================================================================
 // Core Workflow Store
@@ -220,6 +221,8 @@ export const workflowMetadata = derived(workflowStore, ($workflow) => $workflow?
     versionId: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
     updateNumber: 0
 });
+/** Derived store for the current workflow format */
+export const workflowFormat = derived(workflowStore, ($workflow) => $workflow?.metadata?.format ?? DEFAULT_WORKFLOW_FORMAT);
 // =========================================================================
 // Helper Functions
 // =========================================================================

package/dist/svelte-app.d.ts

@@ -10,6 +10,8 @@ import type { Workflow, NodeMetadata, PortConfig, CategoryDefinition } from './t
 import type { EndpointConfig } from './config/endpoints.js';
 import type { AuthProvider } from './types/auth.js';
 import type { FlowDropEventHandlers, FlowDropFeatures } from './types/events.js';
+import type { WorkflowFormatAdapter } from './registry/workflowFormatRegistry.js';
+import './registry/builtinFormats.js';
 import type { PartialSettings } from './types/settings.js';
 declare global {
     interface Window {
@@ -73,6 +75,8 @@ export interface FlowDropMountOptions {
     settings?: PartialSettings;
     /** Custom storage key for localStorage drafts */
     draftStorageKey?: string;
+    /** Custom workflow format adapters to register */
+    formatAdapters?: WorkflowFormatAdapter[];
 }
 /**
  * Return type for mounted FlowDrop app

package/dist/svelte-app.js

@@ -9,6 +9,8 @@
 import { mount, unmount } from 'svelte';
 import WorkflowEditor from './components/WorkflowEditor.svelte';
 import App from './components/App.svelte';
+import { workflowFormatRegistry } from './registry/workflowFormatRegistry.js';
+import './registry/builtinFormats.js';
 import { initializePortCompatibility } from './utils/connections.js';
 import { DEFAULT_PORT_CONFIG } from './config/defaultPortConfig.js';
 import { fetchPortConfig } from './services/portConfigApi.js';
@@ -43,7 +45,13 @@ import { initializeSettings } from './stores/settingsStore.js';
  * ```
  */
 export async function mountFlowDropApp(container, options = {}) {
-    const { workflow, nodes, endpointConfig, portConfig, categories, height = '100vh', width = '100%', showNavbar = false, disableSidebar, lockWorkflow, readOnly, nodeStatuses, pipelineId, navbarTitle, navbarActions, showSettings, authProvider, eventHandlers, features: userFeatures, settings: initialSettings, draftStorageKey: customDraftKey } = options;
+    const { workflow, nodes, endpointConfig, portConfig, categories, height = '100vh', width = '100%', showNavbar = false, disableSidebar, lockWorkflow, readOnly, nodeStatuses, pipelineId, navbarTitle, navbarActions, showSettings, authProvider, eventHandlers, features: userFeatures, settings: initialSettings, draftStorageKey: customDraftKey, formatAdapters } = options;
+    // Register custom format adapters before mounting
+    if (formatAdapters) {
+        for (const adapter of formatAdapters) {
+            workflowFormatRegistry.register(adapter);
+        }
+    }
     // Merge features with defaults
     const features = mergeFeatures(userFeatures);
     // Apply initial settings overrides and initialize theme