@flowdrop/flowdrop 1.0.0

package/dist/services/agentSpecExecutionService.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 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 type { NodeExecutionInfo } from '../types/index.js';
+import type { StandardWorkflow } from '../adapters/WorkflowAdapter.js';
+import type { AgentSpecEndpointConfig } from '../config/agentSpecEndpoints.js';
+/** Result returned when starting an execution */
+export interface AgentSpecExecutionHandle {
+    /** Unique execution ID from the runtime */
+    executionId: string;
+    /** Stop polling and clean up */
+    stop: () => void;
+}
+/**
+ * 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 declare class AgentSpecExecutionService {
+    private static instance;
+    private config;
+    private adapter;
+    private activeExecutions;
+    private constructor();
+    static getInstance(): AgentSpecExecutionService;
+    /**
+     * Configure the runtime connection.
+     */
+    configure(config: AgentSpecEndpointConfig): void;
+    /**
+     * Check if the service has been configured with a runtime.
+     */
+    isConfigured(): boolean;
+    /**
+     * Check runtime health.
+     */
+    checkHealth(): Promise<boolean>;
+    /**
+     * 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
+     */
+    executeWorkflow(workflow: StandardWorkflow, inputs?: Record<string, unknown>, callbacks?: {
+        onNodeUpdate?: (nodeId: string, info: NodeExecutionInfo) => void;
+        onComplete?: (results: Record<string, unknown>) => void;
+        onError?: (error: Error) => void;
+    }, pollingIntervalMs?: number): Promise<AgentSpecExecutionHandle>;
+    /**
+     * Get current execution status.
+     */
+    getExecutionStatus(executionId: string): Promise<Record<string, NodeExecutionInfo> | null>;
+    /**
+     * Cancel a running execution.
+     */
+    cancelExecution(executionId: string): Promise<void>;
+    /**
+     * Get execution results.
+     */
+    getResults(executionId: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Validate a workflow against the runtime.
+     */
+    validateOnRuntime(workflow: StandardWorkflow): Promise<{
+        valid: boolean;
+        errors?: string[];
+    }>;
+    /**
+     * Clean up all active executions.
+     */
+    destroy(): void;
+    private ensureConfigured;
+    /** Get the config, throwing if not configured */
+    private getConfig;
+    private startPolling;
+    private stopPolling;
+    private mapRuntimeStatusToNodeInfo;
+    private mapSingleNodeStatus;
+    private mapToFlowDropStatus;
+}
+/** Singleton instance */
+export declare const agentSpecExecutionService: AgentSpecExecutionService;

package/dist/services/agentSpecExecutionService.js

@@ -0,0 +1,334 @@
+/**
+ * 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';
+import { logger } from '../utils/logger.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
+                logger.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/services/api.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Client-side API service for FlowDrop
+ * Provides methods to interact with the backend APIs using configurable endpoints
+ */
+import type { NodeMetadata, Workflow } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+/**
+ * Set the endpoint configuration at runtime
+ */
+export declare function setEndpointConfig(config: EndpointConfig): void;
+/**
+ * Get the current endpoint configuration
+ */
+export declare function getEndpointConfig(): EndpointConfig | null;
+/**
+ * Node API methods
+ */
+export declare const nodeApi: {
+    /**
+     * Get all node types with optional filtering
+     */
+    getNodes(options?: {
+        category?: string;
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<NodeMetadata[]>;
+    /**
+     * Get a specific node type by ID
+     */
+    getNode(id: string): Promise<NodeMetadata>;
+};
+/**
+ * Workflow API methods
+ */
+export declare const workflowApi: {
+    /**
+     * Get all workflows with optional filtering
+     */
+    getWorkflows(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Workflow[]>;
+    /**
+     * Get a specific workflow by ID
+     */
+    getWorkflow(id: string): Promise<Workflow>;
+    /**
+     * Create a new workflow
+     */
+    createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+    /**
+     * Update an existing workflow
+     */
+    updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
+    /**
+     * Delete a workflow
+     */
+    deleteWorkflow(id: string): Promise<void>;
+    /**
+     * Save workflow (create or update)
+     */
+    saveWorkflow(workflow: Workflow): Promise<Workflow>;
+};
+/**
+ * Export the API service
+ */
+export declare const api: {
+    nodes: {
+        /**
+         * Get all node types with optional filtering
+         */
+        getNodes(options?: {
+            category?: string;
+            search?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<NodeMetadata[]>;
+        /**
+         * Get a specific node type by ID
+         */
+        getNode(id: string): Promise<NodeMetadata>;
+    };
+    workflows: {
+        /**
+         * Get all workflows with optional filtering
+         */
+        getWorkflows(options?: {
+            search?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<Workflow[]>;
+        /**
+         * Get a specific workflow by ID
+         */
+        getWorkflow(id: string): Promise<Workflow>;
+        /**
+         * Create a new workflow
+         */
+        createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+        /**
+         * Update an existing workflow
+         */
+        updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
+        /**
+         * Delete a workflow
+         */
+        deleteWorkflow(id: string): Promise<void>;
+        /**
+         * Save workflow (create or update)
+         */
+        saveWorkflow(workflow: Workflow): Promise<Workflow>;
+    };
+};