@flowdrop/flowdrop 1.0.0 → 1.1.0

package/dist/adapters/agentspec/AgentSpecAdapter.js

@@ -9,11 +9,11 @@
  *
  * @see https://github.com/oracle/agent-spec
  */
-import { getComponentTypeDefaults, extractComponentType, AGENTSPEC_NAMESPACE } from './componentTypeDefaults.js';
-import { computeAutoLayout } from './autoLayout.js';
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../../utils/logger.js';
-import { buildHandleId, extractPortId, extractDirection } from '../../utils/handleIds.js';
+import { getComponentTypeDefaults, extractComponentType, AGENTSPEC_NAMESPACE, } from "./componentTypeDefaults.js";
+import { computeAutoLayout } from "./autoLayout.js";
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../../utils/logger.js";
+import { buildHandleId, extractPortId, extractDirection, } from "../../utils/handleIds.js";
 // ============================================================================
 // Property ↔ Port Conversion
 // ============================================================================
@@ -24,27 +24,27 @@ function agentSpecPropertyToNodePort(prop, portType) {
     // Map JSON Schema types to FlowDrop data types
     let dataType;
     switch (prop.type) {
-        case 'string':
-            dataType = 'string';
+        case "string":
+            dataType = "string";
             break;
-        case 'number':
-        case 'float':
-            dataType = 'number';
+        case "number":
+        case "float":
+            dataType = "number";
             break;
-        case 'integer':
-            dataType = 'number';
+        case "integer":
+            dataType = "number";
             break;
-        case 'boolean':
-            dataType = 'boolean';
+        case "boolean":
+            dataType = "boolean";
             break;
-        case 'array':
-            dataType = 'array';
+        case "array":
+            dataType = "array";
             break;
-        case 'object':
-            dataType = 'json';
+        case "object":
+            dataType = "json";
             break;
         default:
-            dataType = 'mixed';
+            dataType = "mixed";
     }
     return {
         id: prop.title,
@@ -52,7 +52,7 @@ function agentSpecPropertyToNodePort(prop, portType) {
         type: portType,
         dataType,
         required: false,
-        description: prop.description
+        description: prop.description,
     };
 }
 /**
@@ -62,32 +62,32 @@ function nodePortToAgentSpecProperty(port) {
     // Map FlowDrop data types to JSON Schema types
     let type;
     switch (port.dataType) {
-        case 'string':
-            type = 'string';
+        case "string":
+            type = "string";
             break;
-        case 'number':
-        case 'float':
-            type = 'number';
+        case "number":
+        case "float":
+            type = "number";
             break;
-        case 'integer':
-            type = 'integer';
+        case "integer":
+            type = "integer";
             break;
-        case 'boolean':
-            type = 'boolean';
+        case "boolean":
+            type = "boolean";
             break;
-        case 'array':
-            type = 'array';
+        case "array":
+            type = "array";
             break;
-        case 'json':
-        case 'object':
-            type = 'object';
+        case "json":
+        case "object":
+            type = "object";
             break;
         default:
-            type = 'string';
+            type = "string";
     }
     const prop = {
         title: port.id,
-        type
+        type,
     };
     if (port.description)
         prop.description = port.description;
@@ -130,7 +130,7 @@ export class AgentSpecAdapter {
                 continue;
             const sourcePortId = extractPortId(edge.sourceHandle);
             const sourcePortDataType = this.getSourcePortDataType(sourceNode, sourcePortId);
-            if (sourcePortDataType === 'trigger') {
+            if (sourcePortDataType === "trigger") {
                 controlFlowEdges.push(this.convertToControlFlowEdge(edge, sourceNode, nodeIdToName));
             }
             else {
@@ -140,7 +140,7 @@ export class AgentSpecAdapter {
         // Find start node
         const startNodeName = this.findStartNodeName(agentSpecNodes, nodeIdToName);
         return {
-            component_type: 'flow',
+            component_type: "flow",
             name: workflow.name,
             description: workflow.description,
             start_node: startNodeName,
@@ -148,11 +148,15 @@ export class AgentSpecAdapter {
             control_flow_connections: controlFlowEdges,
             data_flow_connections: dataFlowEdges.length > 0 ? dataFlowEdges : null,
             metadata: {
-                'flowdrop:workflow_id': workflow.id,
-                'flowdrop:version': workflow.metadata?.version,
-                ...(workflow.metadata?.author ? { 'flowdrop:author': workflow.metadata.author } : {}),
-                ...(workflow.metadata?.tags ? { 'flowdrop:tags': workflow.metadata.tags } : {})
-            }
+                "flowdrop:workflow_id": workflow.id,
+                "flowdrop:version": workflow.metadata?.version,
+                ...(workflow.metadata?.author
+                    ? { "flowdrop:author": workflow.metadata.author }
+                    : {}),
+                ...(workflow.metadata?.tags
+                    ? { "flowdrop:tags": workflow.metadata.tags }
+                    : {}),
+            },
         };
     }
     /**
@@ -209,18 +213,19 @@ export class AgentSpecAdapter {
             }
         }
         return {
-            id: agentSpecFlow.metadata?.['flowdrop:workflow_id'] || uuidv4(),
+            id: agentSpecFlow.metadata?.["flowdrop:workflow_id"] ||
+                uuidv4(),
             name: agentSpecFlow.name,
             description: agentSpecFlow.description,
             nodes,
             edges,
             metadata: {
-                version: agentSpecFlow.metadata?.['flowdrop:version'] || '1.0.0',
+                version: agentSpecFlow.metadata?.["flowdrop:version"] || "1.0.0",
                 createdAt: new Date().toISOString(),
                 updatedAt: new Date().toISOString(),
-                author: agentSpecFlow.metadata?.['flowdrop:author'],
-                tags: agentSpecFlow.metadata?.['flowdrop:tags']
-            }
+                author: agentSpecFlow.metadata?.["flowdrop:author"],
+                tags: agentSpecFlow.metadata?.["flowdrop:tags"],
+            },
         };
     }
     /**
@@ -251,10 +256,10 @@ export class AgentSpecAdapter {
         const name = nodeIdToName.get(node.id) || node.id;
         // Convert data ports (skip trigger/tool ports — those are handled as edges)
         const dataInputs = node.data.metadata.inputs
-            .filter((p) => p.dataType !== 'trigger' && p.dataType !== 'tool')
+            .filter((p) => p.dataType !== "trigger" && p.dataType !== "tool")
             .map((p) => nodePortToAgentSpecProperty(p));
         const dataOutputs = node.data.metadata.outputs
-            .filter((p) => p.dataType !== 'trigger' && p.dataType !== 'tool')
+            .filter((p) => p.dataType !== "trigger" && p.dataType !== "tool")
             .map((p) => nodePortToAgentSpecProperty(p));
         // Build base node
         const base = {
@@ -264,10 +269,10 @@ export class AgentSpecAdapter {
             inputs: dataInputs.length > 0 ? dataInputs : undefined,
             outputs: dataOutputs.length > 0 ? dataOutputs : undefined,
             metadata: {
-                'flowdrop:position': node.position,
-                'flowdrop:node_id': node.id,
-                'flowdrop:node_type_id': node.data.metadata.id
-            }
+                "flowdrop:position": node.position,
+                "flowdrop:node_id": node.id,
+                "flowdrop:node_type_id": node.data.metadata.id,
+            },
         };
         // Add type-specific attributes from config
         return this.addNodeSpecificAttributes(base, node);
@@ -278,7 +283,7 @@ export class AgentSpecAdapter {
     addNodeSpecificAttributes(asNode, fdNode) {
         const config = fdNode.data.config || {};
         switch (asNode.component_type) {
-            case 'llm_node': {
+            case "llm_node": {
                 const llmNode = asNode;
                 if (config.prompt_template)
                     llmNode.prompt_template = config.prompt_template;
@@ -288,19 +293,19 @@ export class AgentSpecAdapter {
                     llmNode.llm_config = config.llm_config_ref;
                 return llmNode;
             }
-            case 'branching_node': {
+            case "branching_node": {
                 const branchNode = asNode;
                 const branches = config.branches;
                 branchNode.branches = branches
                     ? branches.map((b) => ({
                         name: b.name,
                         condition: b.condition || undefined,
-                        description: b.description || undefined
+                        description: b.description || undefined,
                     }))
                     : [];
                 return branchNode;
             }
-            case 'api_node': {
+            case "api_node": {
                 const apiNode = asNode;
                 if (config.endpoint)
                     apiNode.endpoint = config.endpoint;
@@ -309,30 +314,30 @@ export class AgentSpecAdapter {
                 if (config.headers) {
                     try {
                         apiNode.headers =
-                            typeof config.headers === 'string'
+                            typeof config.headers === "string"
                                 ? JSON.parse(config.headers)
                                 : config.headers;
                     }
                     catch (error) {
                         // Ignore parse errors
-                        logger.warn('Failed to parse header JSON', error);
+                        logger.warn("Failed to parse header JSON", error);
                     }
                 }
                 return apiNode;
             }
-            case 'agent_node': {
+            case "agent_node": {
                 const agentNode = asNode;
                 if (config.agent_ref)
                     agentNode.agent = config.agent_ref;
                 return agentNode;
             }
-            case 'flow_node': {
+            case "flow_node": {
                 const flowNode = asNode;
                 if (config.flow_ref)
                     flowNode.flow = config.flow_ref;
                 return flowNode;
             }
-            case 'map_node': {
+            case "map_node": {
                 const mapNode = asNode;
                 if (config.input_collection)
                     mapNode.input_collection = config.input_collection;
@@ -342,7 +347,7 @@ export class AgentSpecAdapter {
                     mapNode.map_flow = config.map_flow_ref;
                 return mapNode;
             }
-            case 'tool_node': {
+            case "tool_node": {
                 const toolNode = asNode;
                 if (config.tool_ref)
                     toolNode.tool = config.tool_ref;
@@ -357,8 +362,8 @@ export class AgentSpecAdapter {
      */
     resolveComponentType(node) {
         // Check extensions first (round-trip preservation)
-        const ext = node.data.metadata.extensions?.['agentspec:component_type'];
-        if (ext && typeof ext === 'string') {
+        const ext = node.data.metadata.extensions?.["agentspec:component_type"];
+        if (ext && typeof ext === "string") {
             return ext;
         }
         // Infer from FlowDrop node type ID
@@ -368,22 +373,22 @@ export class AgentSpecAdapter {
         // Infer from FlowDrop visual type + category
         const nodeType = node.data.metadata.type;
         const category = node.data.metadata.category;
-        if (nodeType === 'terminal' && category === 'triggers')
-            return 'start_node';
-        if (nodeType === 'terminal' && category === 'outputs')
-            return 'end_node';
-        if (nodeType === 'gateway')
-            return 'branching_node';
-        if (nodeType === 'tool')
-            return 'tool_node';
-        if (category === 'ai' || category === 'models')
-            return 'llm_node';
-        if (category === 'agents')
-            return 'agent_node';
-        if (category === 'data')
-            return 'api_node';
+        if (nodeType === "terminal" && category === "triggers")
+            return "start_node";
+        if (nodeType === "terminal" && category === "outputs")
+            return "end_node";
+        if (nodeType === "gateway")
+            return "branching_node";
+        if (nodeType === "tool")
+            return "tool_node";
+        if (category === "ai" || category === "models")
+            return "llm_node";
+        if (category === "agents")
+            return "agent_node";
+        if (category === "data")
+            return "api_node";
         // Default fallback
-        return 'llm_node';
+        return "llm_node";
     }
     /**
      * Convert an Agent Spec node to a FlowDrop StandardNode.
@@ -394,14 +399,14 @@ export class AgentSpecAdapter {
      */
     convertNodeFromAgentSpec(asNode, nodeId, position) {
         // Restore position from metadata if available (round-trip)
-        const savedPosition = asNode.metadata?.['flowdrop:position'];
+        const savedPosition = asNode.metadata?.["flowdrop:position"];
         const finalPosition = savedPosition || position;
         // Convert inputs/outputs to FlowDrop ports
-        const dataInputs = (asNode.inputs || []).map((p) => agentSpecPropertyToNodePort(p, 'input'));
-        const dataOutputs = (asNode.outputs || []).map((p) => agentSpecPropertyToNodePort(p, 'output'));
+        const dataInputs = (asNode.inputs || []).map((p) => agentSpecPropertyToNodePort(p, "input"));
+        const dataOutputs = (asNode.outputs || []).map((p) => agentSpecPropertyToNodePort(p, "output"));
         // Use lightweight adapter defaults (never throws on unknown types)
         const defaults = getComponentTypeDefaults(asNode.component_type);
-        const nodeTypeId = asNode.metadata?.['flowdrop:node_type_id'] ||
+        const nodeTypeId = asNode.metadata?.["flowdrop:node_type_id"] ||
             `${AGENTSPEC_NAMESPACE}.${asNode.component_type}`;
         const metadata = {
             id: nodeTypeId,
@@ -409,18 +414,18 @@ export class AgentSpecAdapter {
             type: defaults.visualType,
             description: asNode.description || defaults.defaultDescription,
             category: defaults.category,
-            version: '1.0.0',
+            version: "1.0.0",
             icon: defaults.icon,
             color: defaults.color,
             badge: defaults.badge,
             inputs: [...defaults.triggerInputs, ...dataInputs],
             outputs: [...defaults.triggerOutputs, ...dataOutputs],
-            configSchema: { type: 'object', properties: {} },
-            formats: ['agentspec'],
+            configSchema: { type: "object", properties: {} },
+            formats: ["agentspec"],
             extensions: {
-                'agentspec:component_type': asNode.component_type,
-                'agentspec:original_name': asNode.name
-            }
+                "agentspec:component_type": asNode.component_type,
+                "agentspec:original_name": asNode.name,
+            },
         };
         // Build config from Agent Spec node-specific attributes
         const config = this.extractConfigFromAgentSpec(asNode);
@@ -431,8 +436,8 @@ export class AgentSpecAdapter {
             data: {
                 label: asNode.name,
                 config,
-                metadata
-            }
+                metadata,
+            },
         };
     }
     /**
@@ -441,7 +446,7 @@ export class AgentSpecAdapter {
     extractConfigFromAgentSpec(asNode) {
         const config = {};
         switch (asNode.component_type) {
-            case 'llm_node': {
+            case "llm_node": {
                 const llm = asNode;
                 if (llm.prompt_template)
                     config.prompt_template = llm.prompt_template;
@@ -449,21 +454,23 @@ export class AgentSpecAdapter {
                     config.system_prompt = llm.system_prompt;
                 if (llm.llm_config) {
                     config.llm_config_ref =
-                        typeof llm.llm_config === 'string' ? llm.llm_config : llm.llm_config.name;
+                        typeof llm.llm_config === "string"
+                            ? llm.llm_config
+                            : llm.llm_config.name;
                 }
                 break;
             }
-            case 'branching_node': {
+            case "branching_node": {
                 const branch = asNode;
                 config.branches = branch.branches.map((b) => ({
                     name: b.name,
                     label: b.name,
-                    condition: b.condition || '',
-                    isDefault: !b.condition
+                    condition: b.condition || "",
+                    isDefault: !b.condition,
                 }));
                 break;
             }
-            case 'api_node': {
+            case "api_node": {
                 const api = asNode;
                 if (api.endpoint)
                     config.endpoint = api.endpoint;
@@ -473,35 +480,39 @@ export class AgentSpecAdapter {
                     config.headers = JSON.stringify(api.headers, null, 2);
                 break;
             }
-            case 'agent_node': {
+            case "agent_node": {
                 const agent = asNode;
                 if (agent.agent) {
-                    config.agent_ref = typeof agent.agent === 'string' ? agent.agent : agent.agent.name;
+                    config.agent_ref =
+                        typeof agent.agent === "string" ? agent.agent : agent.agent.name;
                 }
                 break;
             }
-            case 'flow_node': {
+            case "flow_node": {
                 const flow = asNode;
                 if (flow.flow) {
-                    config.flow_ref = typeof flow.flow === 'string' ? flow.flow : flow.flow.name;
+                    config.flow_ref =
+                        typeof flow.flow === "string" ? flow.flow : flow.flow.name;
                 }
                 break;
             }
-            case 'map_node': {
+            case "map_node": {
                 const map = asNode;
                 if (map.input_collection)
                     config.input_collection = map.input_collection;
                 if (map.output_collection)
                     config.output_collection = map.output_collection;
                 if (map.map_flow) {
-                    config.map_flow_ref = typeof map.map_flow === 'string' ? map.map_flow : map.map_flow.name;
+                    config.map_flow_ref =
+                        typeof map.map_flow === "string" ? map.map_flow : map.map_flow.name;
                 }
                 break;
             }
-            case 'tool_node': {
+            case "tool_node": {
                 const tool = asNode;
                 if (tool.tool) {
-                    config.tool_ref = typeof tool.tool === 'string' ? tool.tool : tool.tool.name;
+                    config.tool_ref =
+                        typeof tool.tool === "string" ? tool.tool : tool.tool.name;
                 }
                 break;
             }
@@ -522,10 +533,10 @@ export class AgentSpecAdapter {
         if (port)
             return port.dataType;
         // Check if it's a gateway branch (always trigger)
-        if (node.data.metadata.type === 'gateway') {
+        if (node.data.metadata.type === "gateway") {
             const branches = node.data.config?.branches;
             if (branches?.some((b) => b.name === portId)) {
-                return 'trigger';
+                return "trigger";
             }
         }
         // Check dynamic outputs
@@ -546,17 +557,17 @@ export class AgentSpecAdapter {
         const sourcePortId = extractPortId(edge.sourceHandle);
         // Determine from_branch for gateway nodes
         let fromBranch;
-        if (sourceNode.data.metadata.type === 'gateway' && sourcePortId) {
+        if (sourceNode.data.metadata.type === "gateway" && sourcePortId) {
             const branches = sourceNode.data.config?.branches;
             if (branches?.some((b) => b.name === sourcePortId)) {
                 fromBranch = sourcePortId;
             }
         }
         return {
-            name: `${fromNode}_to_${toNode}${fromBranch ? `_${fromBranch}` : ''}`,
+            name: `${fromNode}_to_${toNode}${fromBranch ? `_${fromBranch}` : ""}`,
             from_node: fromNode,
             to_node: toNode,
-            from_branch: fromBranch
+            from_branch: fromBranch,
         };
     }
     /**
@@ -565,14 +576,14 @@ export class AgentSpecAdapter {
     convertToDataFlowEdge(edge, nodeIdToName) {
         const sourceNode = nodeIdToName.get(edge.source) || edge.source;
         const destNode = nodeIdToName.get(edge.target) || edge.target;
-        const sourceOutput = extractPortId(edge.sourceHandle) || 'output';
-        const destInput = extractPortId(edge.targetHandle) || 'input';
+        const sourceOutput = extractPortId(edge.sourceHandle) || "output";
+        const destInput = extractPortId(edge.targetHandle) || "input";
         return {
             name: `${sourceNode}_${sourceOutput}_to_${destNode}_${destInput}`,
             source_node: sourceNode,
             source_output: sourceOutput,
             destination_node: destNode,
-            destination_input: destInput
+            destination_input: destInput,
         };
     }
     /**
@@ -584,7 +595,7 @@ export class AgentSpecAdapter {
         if (!sourceId || !targetId)
             return null;
         // Determine source handle
-        let sourcePortId = 'trigger'; // default for non-branch control flow
+        let sourcePortId = "trigger"; // default for non-branch control flow
         if (cfEdge.from_branch) {
             sourcePortId = cfEdge.from_branch;
         }
@@ -592,8 +603,8 @@ export class AgentSpecAdapter {
             id: uuidv4(),
             source: sourceId,
             target: targetId,
-            sourceHandle: buildHandleId(sourceId, 'output', sourcePortId),
-            targetHandle: buildHandleId(targetId, 'input', 'trigger')
+            sourceHandle: buildHandleId(sourceId, "output", sourcePortId),
+            targetHandle: buildHandleId(targetId, "input", "trigger"),
         };
     }
     /**
@@ -608,8 +619,8 @@ export class AgentSpecAdapter {
             id: uuidv4(),
             source: sourceId,
             target: targetId,
-            sourceHandle: buildHandleId(sourceId, 'output', dfEdge.source_output),
-            targetHandle: buildHandleId(targetId, 'input', dfEdge.destination_input)
+            sourceHandle: buildHandleId(sourceId, "output", dfEdge.source_output),
+            targetHandle: buildHandleId(targetId, "input", dfEdge.destination_input),
         };
     }
     /**
@@ -617,10 +628,10 @@ export class AgentSpecAdapter {
      */
     findStartNodeName(nodes, nodeIdToName) {
         // Look for an explicit start_node
-        const startNode = nodes.find((n) => n.component_type === 'start_node');
+        const startNode = nodes.find((n) => n.component_type === "start_node");
         if (startNode)
             return startNode.name;
         // Fall back to the first node
-        return nodes.length > 0 ? nodes[0].name : 'start';
+        return nodes.length > 0 ? nodes[0].name : "start";
     }
 }

package/dist/adapters/agentspec/agentAdapter.d.ts

@@ -4,8 +4,8 @@
  * Handles conversion between FlowDrop workflows and full Agent Spec Documents
  * (which wrap a Flow with Agent metadata like tools, LLM config, etc.)
  */
-import type { AgentSpecDocument, AgentSpecTool, AgentSpecLLMConfig } from '../../types/agentspec.js';
-import type { StandardWorkflow } from '../WorkflowAdapter.js';
+import type { AgentSpecDocument, AgentSpecTool, AgentSpecLLMConfig } from "../../types/agentspec.js";
+import type { StandardWorkflow } from "../WorkflowAdapter.js";
 /**
  * Agent-level configuration that wraps a workflow.
  * Contains the Agent Spec agent metadata that lives outside the flow.

package/dist/adapters/agentspec/agentAdapter.js

@@ -4,7 +4,7 @@
  * Handles conversion between FlowDrop workflows and full Agent Spec Documents
  * (which wrap a Flow with Agent metadata like tools, LLM config, etc.)
  */
-import { AgentSpecAdapter } from './AgentSpecAdapter.js';
+import { AgentSpecAdapter } from "./AgentSpecAdapter.js";
 export class AgentSpecAgentAdapter {
     flowAdapter;
     constructor() {
@@ -20,18 +20,18 @@ export class AgentSpecAgentAdapter {
         const doc = {
             flow,
             metadata: {
-                'flowdrop:exported_at': new Date().toISOString()
-            }
+                "flowdrop:exported_at": new Date().toISOString(),
+            },
         };
         // Add agent definition if config provided
         if (agentConfig) {
             const agent = {
-                component_type: 'agent',
+                component_type: "agent",
                 name: agentConfig.name,
                 description: agentConfig.description,
                 system_prompt: agentConfig.systemPrompt,
                 tools: agentConfig.tools,
-                llm_config: agentConfig.llmConfig
+                llm_config: agentConfig.llmConfig,
             };
             doc.agent = agent;
         }
@@ -50,11 +50,11 @@ export class AgentSpecAgentAdapter {
      */
     fromAgentSpecDocument(doc) {
         if (!doc.flow) {
-            throw new Error('AgentSpecDocument has no flow definition');
+            throw new Error("AgentSpecDocument has no flow definition");
         }
         const workflow = this.flowAdapter.fromAgentSpec(doc.flow);
         const result = {
-            workflow
+            workflow,
         };
         // Extract agent config
         if (doc.agent) {
@@ -62,10 +62,10 @@ export class AgentSpecAgentAdapter {
                 name: doc.agent.name,
                 description: doc.agent.description,
                 systemPrompt: doc.agent.system_prompt,
-                tools: doc.agent.tools?.filter((t) => typeof t !== 'string'),
-                llmConfig: doc.agent.llm_config && typeof doc.agent.llm_config !== 'string'
+                tools: doc.agent.tools?.filter((t) => typeof t !== "string"),
+                llmConfig: doc.agent.llm_config && typeof doc.agent.llm_config !== "string"
                     ? doc.agent.llm_config
-                    : undefined
+                    : undefined,
             };
         }
         // Extract shared declarations

package/dist/adapters/agentspec/autoLayout.d.ts

@@ -9,7 +9,7 @@
  * 3. Position nodes with configurable spacing
  * 4. Fan out branches vertically from BranchingNode
  */
-import type { AgentSpecFlow } from '../../types/agentspec.js';
+import type { AgentSpecFlow } from "../../types/agentspec.js";
 /** Layout configuration */
 export interface AutoLayoutConfig {
     /** Horizontal spacing between layers (px) */