machinaos 0.0.1

package/client/src/nodeDefinitions/workflowNodes.ts

@@ -0,0 +1,41 @@
+// Workflow Control Nodes - Start, triggers, and flow control
+import {
+  INodeTypeDescription,
+  NodeConnectionType
+} from '../types/INodeProperties';
+
+export const workflowNodes: Record<string, INodeTypeDescription> = {
+  // Start Node - Entry point for workflows
+  start: {
+    displayName: 'Start',
+    name: 'start',
+    icon: '▶',
+    group: ['workflow'],
+    version: 1,
+    subtitle: 'Workflow Entry',
+    description: 'Starting point for workflow execution. Provides initial data to connected nodes.',
+    defaults: { name: 'Start', color: '#8be9fd' },
+    inputs: [],
+    outputs: [{
+      name: 'main',
+      displayName: 'Output',
+      type: 'main' as NodeConnectionType,
+      description: 'Workflow start output'
+    }],
+    properties: [
+      {
+        displayName: 'Initial Data',
+        name: 'initialData',
+        type: 'string',
+        default: '{}',
+        typeOptions: {
+          rows: 6
+        },
+        description: 'JSON data to pass to connected nodes',
+        placeholder: '{\n  "message": "Hello World",\n  "value": 123\n}'
+      }
+    ]
+  }
+};
+
+export const WORKFLOW_NODE_TYPES = ['start'];

package/client/src/nodeDefinitions.ts

@@ -0,0 +1,104 @@
+// Main Node Definitions - Central registry importing from modular files
+import { INodeTypeDescription } from './types/INodeProperties';
+
+// Import modular node definitions
+import { aiModelNodes } from './nodeDefinitions/aiModelNodes';
+import { aiAgentNodes, AI_NODE_TYPES } from './nodeDefinitions/aiAgentNodes';
+import { toolNodes, TOOL_NODE_TYPES } from './nodeDefinitions/toolNodes';
+import { locationNodes, LOCATION_NODE_TYPES } from './nodeDefinitions/locationNodes';
+import { whatsappNodes, WHATSAPP_NODE_TYPES } from './nodeDefinitions/whatsappNodes';
+import { workflowNodes } from './nodeDefinitions/workflowNodes';
+import { schedulerNodes, SCHEDULER_NODE_TYPES } from './nodeDefinitions/schedulerNodes';
+import { androidServiceNodes, ANDROID_SERVICE_NODE_TYPES } from './nodeDefinitions/androidServiceNodes';
+import { androidDeviceNodes } from './nodeDefinitions/androidDeviceNodes';
+import { chatNodes, CHAT_NODE_TYPES } from './nodeDefinitions/chatNodes';
+import { codeNodes, CODE_NODE_TYPES } from './nodeDefinitions/codeNodes';
+import { utilityNodes, UTILITY_NODE_TYPES } from './nodeDefinitions/utilityNodes';
+import { skillNodes, SKILL_NODE_TYPES } from './nodeDefinitions/skillNodes';
+import { documentNodes, DOCUMENT_NODE_TYPES } from './nodeDefinitions/documentNodes';
+
+// ============================================================================
+// MAIN NODE REGISTRY - Combining all modular definitions
+// ============================================================================
+
+// Merge all node definitions from modular files
+export const nodeDefinitions: Record<string, INodeTypeDescription> = {
+  ...workflowNodes,
+  ...schedulerNodes,
+  ...aiModelNodes,
+  ...aiAgentNodes,
+  ...toolNodes,
+  ...locationNodes,
+  ...whatsappNodes,
+  ...androidServiceNodes,
+  ...androidDeviceNodes,
+  ...chatNodes,
+  ...codeNodes,
+  ...utilityNodes,
+  ...skillNodes,
+  ...documentNodes
+};
+
+// ============================================================================
+// HELPER FUNCTIONS AND EXPORTS
+// ============================================================================
+
+// Export helper function to get all node types
+export const getNodeTypes = (): string[] => {
+  return Object.keys(nodeDefinitions);
+};
+
+// Export helper function to get nodes by group
+export const getNodesByGroup = (group: string): INodeTypeDescription[] => {
+  return Object.values(nodeDefinitions).filter(node =>
+    node.group?.includes(group)
+  );
+};
+
+// Export AI and Location node lists for easy reference (updated with new nodes)
+export const AI_NODES = [
+  ...AI_NODE_TYPES
+];
+
+export const LOCATION_NODES = [
+  ...LOCATION_NODE_TYPES
+];
+
+export const WHATSAPP_NODES = [
+  ...WHATSAPP_NODE_TYPES
+];
+
+export const ANDROID_SERVICE_NODES = [
+  ...ANDROID_SERVICE_NODE_TYPES
+];
+
+export const SCHEDULER_NODES = [
+  ...SCHEDULER_NODE_TYPES
+];
+
+export const CHAT_NODES = [
+  ...CHAT_NODE_TYPES
+];
+
+export const CODE_NODES = [
+  ...CODE_NODE_TYPES
+];
+
+export const UTILITY_NODES = [
+  ...UTILITY_NODE_TYPES
+];
+
+export const TOOL_NODES = [
+  ...TOOL_NODE_TYPES
+];
+
+export const SKILL_NODES = [
+  ...SKILL_NODE_TYPES
+];
+
+export const DOCUMENT_NODES = [
+  ...DOCUMENT_NODE_TYPES
+];
+
+// Re-export types and utilities from modular files for external access
+export { createBaseChatModel } from './nodeDefinitions/aiModelNodes';

package/client/src/schemas/workflowSchema.ts

@@ -0,0 +1,264 @@
+/**
+ * JSON Schema for Workflow Definition
+ * Defines the structure and validation rules for workflow data
+ */
+
+export const WorkflowJSONSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Workflow",
+  description: "A workflow automation definition containing nodes and connections",
+  type: "object",
+  required: ["id", "name", "nodes", "edges", "createdAt", "lastModified"],
+  properties: {
+    id: {
+      type: "string",
+      description: "Unique identifier for the workflow",
+      pattern: "^workflow_[0-9]+$"
+    },
+    name: {
+      type: "string",
+      description: "Human-readable workflow name",
+      minLength: 1,
+      maxLength: 100
+    },
+    description: {
+      type: "string",
+      description: "Optional workflow description"
+    },
+    nodes: {
+      type: "array",
+      description: "Array of workflow nodes",
+      items: {
+        $ref: "#/definitions/node"
+      }
+    },
+    edges: {
+      type: "array",
+      description: "Array of connections between nodes",
+      items: {
+        $ref: "#/definitions/edge"
+      }
+    },
+    createdAt: {
+      type: "string",
+      format: "date-time",
+      description: "ISO 8601 timestamp of workflow creation"
+    },
+    lastModified: {
+      type: "string",
+      format: "date-time",
+      description: "ISO 8601 timestamp of last modification"
+    },
+    version: {
+      type: "string",
+      description: "Workflow schema version",
+      default: "1.0.0"
+    }
+  },
+  definitions: {
+    node: {
+      type: "object",
+      required: ["id", "type", "position"],
+      properties: {
+        id: {
+          type: "string",
+          description: "Unique node identifier"
+        },
+        type: {
+          type: "string",
+          description: "Node type identifier",
+          enum: [
+            "start",
+            "aiAgent",
+            "openaiChatModel",
+            "anthropicChatModel",
+            "googleChatModel",
+            "createMap",
+            "addLocations",
+            "showNearbyPlaces",
+            "whatsappSendMessage",
+            "whatsappReceiveMessage"
+          ]
+        },
+        position: {
+          type: "object",
+          required: ["x", "y"],
+          properties: {
+            x: {
+              type: "number",
+              description: "X coordinate on canvas"
+            },
+            y: {
+              type: "number",
+              description: "Y coordinate on canvas"
+            }
+          }
+        },
+        data: {
+          type: "object",
+          description: "Node-specific parameters and configuration",
+          properties: {
+            label: {
+              type: "string",
+              description: "Display label for the node"
+            }
+          },
+          additionalProperties: true
+        },
+        selected: {
+          type: "boolean",
+          description: "Whether node is currently selected"
+        },
+        dragging: {
+          type: "boolean",
+          description: "Whether node is being dragged"
+        }
+      },
+      additionalProperties: true
+    },
+    edge: {
+      type: "object",
+      required: ["id", "source", "target"],
+      properties: {
+        id: {
+          type: "string",
+          description: "Unique edge identifier"
+        },
+        source: {
+          type: "string",
+          description: "Source node ID"
+        },
+        target: {
+          type: "string",
+          description: "Target node ID"
+        },
+        sourceHandle: {
+          type: "string",
+          description: "Source handle identifier",
+          default: "output-main"
+        },
+        targetHandle: {
+          type: "string",
+          description: "Target handle identifier",
+          default: "input-main"
+        },
+        type: {
+          type: "string",
+          description: "Edge rendering type",
+          enum: ["default", "straight", "step", "smoothstep", "simplebezier"],
+          default: "default"
+        },
+        animated: {
+          type: "boolean",
+          description: "Whether edge is animated"
+        },
+        style: {
+          type: "object",
+          description: "Custom edge styling"
+        },
+        label: {
+          type: "string",
+          description: "Edge label text"
+        }
+      },
+      additionalProperties: true
+    }
+  }
+};
+
+/**
+ * Validates a workflow object against the JSON schema
+ */
+export function validateWorkflow(workflow: any): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!workflow.id || typeof workflow.id !== 'string') {
+    errors.push('Workflow must have a valid id');
+  }
+
+  if (!workflow.name || typeof workflow.name !== 'string') {
+    errors.push('Workflow must have a valid name');
+  }
+
+  if (!Array.isArray(workflow.nodes)) {
+    errors.push('Workflow must have a nodes array');
+  }
+
+  if (!Array.isArray(workflow.edges)) {
+    errors.push('Workflow must have an edges array');
+  }
+
+  if (!workflow.createdAt) {
+    errors.push('Workflow must have a createdAt timestamp');
+  }
+
+  if (!workflow.lastModified) {
+    errors.push('Workflow must have a lastModified timestamp');
+  }
+
+  workflow.nodes?.forEach((node: any, index: number) => {
+    if (!node.id) {
+      errors.push(`Node at index ${index} must have an id`);
+    }
+    if (!node.type) {
+      errors.push(`Node at index ${index} must have a type`);
+    }
+    if (!node.position || typeof node.position.x !== 'number' || typeof node.position.y !== 'number') {
+      errors.push(`Node at index ${index} must have a valid position with x and y coordinates`);
+    }
+  });
+
+  workflow.edges?.forEach((edge: any, index: number) => {
+    if (!edge.id) {
+      errors.push(`Edge at index ${index} must have an id`);
+    }
+    if (!edge.source) {
+      errors.push(`Edge at index ${index} must have a source node`);
+    }
+    if (!edge.target) {
+      errors.push(`Edge at index ${index} must have a target node`);
+    }
+
+    const sourceExists = workflow.nodes?.some((n: any) => n.id === edge.source);
+    const targetExists = workflow.nodes?.some((n: any) => n.id === edge.target);
+
+    if (!sourceExists) {
+      errors.push(`Edge ${edge.id} references non-existent source node: ${edge.source}`);
+    }
+    if (!targetExists) {
+      errors.push(`Edge ${edge.id} references non-existent target node: ${edge.target}`);
+    }
+  });
+
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Serializes a workflow to JSON format
+ */
+export function serializeWorkflow(workflow: any): string {
+  return JSON.stringify(workflow, null, 2);
+}
+
+/**
+ * Deserializes a JSON string to workflow object
+ */
+export function deserializeWorkflow(json: string): any {
+  try {
+    const workflow = JSON.parse(json);
+
+    if (workflow.createdAt) {
+      workflow.createdAt = new Date(workflow.createdAt);
+    }
+    if (workflow.lastModified) {
+      workflow.lastModified = new Date(workflow.lastModified);
+    }
+
+    return workflow;
+  } catch (error) {
+    throw new Error(`Failed to parse workflow JSON: ${error}`);
+  }
+}

package/client/src/services/dynamicParameterService.ts

@@ -0,0 +1,96 @@
+// Dynamic Parameter Service - Manages runtime parameter option updates
+import { INodePropertyOption } from '../types/INodeProperties';
+
+interface DynamicParameterOptions {
+  [nodeId: string]: {
+    [parameterName: string]: INodePropertyOption[];
+  };
+}
+
+class DynamicParameterService {
+  private static dynamicOptions: DynamicParameterOptions = {};
+  private static listeners: ((nodeId: string, parameterName: string, options: INodePropertyOption[]) => void)[] = [];
+
+  // Subscribe to dynamic option updates
+  static subscribe(callback: (nodeId: string, parameterName: string, options: INodePropertyOption[]) => void) {
+    this.listeners.push(callback);
+    return () => {
+      this.listeners = this.listeners.filter(listener => listener !== callback);
+    };
+  }
+
+  // Update options for a specific parameter
+  static updateParameterOptions(nodeId: string, parameterName: string, options: INodePropertyOption[]) {
+    if (!this.dynamicOptions[nodeId]) {
+      this.dynamicOptions[nodeId] = {};
+    }
+
+    this.dynamicOptions[nodeId][parameterName] = options;
+
+    // Notify all listeners
+    this.listeners.forEach((listener) => {
+      listener(nodeId, parameterName, options);
+    });
+  }
+
+  // Get options for a specific parameter
+  static getParameterOptions(nodeId: string, parameterName: string): INodePropertyOption[] | null {
+    return this.dynamicOptions[nodeId]?.[parameterName] || null;
+  }
+
+  // Clear options for a specific parameter
+  static clearParameterOptions(nodeId: string, parameterName: string) {
+    if (this.dynamicOptions[nodeId]) {
+      delete this.dynamicOptions[nodeId][parameterName];
+
+      // Notify listeners with empty array
+      this.listeners.forEach(listener => {
+        listener(nodeId, parameterName, []);
+      });
+    }
+  }
+
+  // Clear all options for a node
+  static clearNodeOptions(nodeId: string) {
+    if (this.dynamicOptions[nodeId]) {
+      const parameterNames = Object.keys(this.dynamicOptions[nodeId]);
+      delete this.dynamicOptions[nodeId];
+
+      // Notify listeners for each parameter
+      parameterNames.forEach(parameterName => {
+        this.listeners.forEach(listener => {
+          listener(nodeId, parameterName, []);
+        });
+      });
+    }
+  }
+
+  // Convert model strings to INodePropertyOption format
+  static createModelOptions(models: string[]): INodePropertyOption[] {
+    return models.map(model => ({
+      name: this.formatModelName(model),
+      value: model,
+      label: this.formatModelName(model),
+      description: `Model: ${model}`
+    }));
+  }
+
+  // Format model name for display
+  private static formatModelName(modelId: string): string {
+    // Preserve [FREE] prefix if present
+    const hasFreePrefix = modelId.startsWith('[FREE] ');
+    const cleanId = hasFreePrefix ? modelId.slice(7) : modelId;
+
+    const formatted = cleanId
+      .replace(/^gpt-/, 'GPT-')
+      .replace(/^claude-/, 'Claude ')
+      .replace(/^gemini-/, 'Gemini ')
+      .replace(/turbo/i, 'Turbo')
+      .replace(/^o1-/, 'O1-');
+
+    // Return with [FREE] prefix preserved if it was there
+    return hasFreePrefix ? `[FREE] ${formatted}` : formatted;
+  }
+}
+
+export default DynamicParameterService;

package/client/src/services/execution/aiAgentExecutionService.ts

@@ -0,0 +1,35 @@
+import { ExecutionResult } from '../executionService';
+
+// AI Agent execution result (simplified)
+export interface AIAgentExecutionResult extends ExecutionResult {
+  aiResponse?: string;
+  toolCalls?: any[];
+  iterations?: number;
+  tokens?: {
+    prompt: number;
+    completion: number;
+    total: number;
+  };
+}
+
+export class AIAgentExecutionService {
+  /**
+   * Basic validation for UI feedback - backend handles full validation
+   */
+  static validateConfiguration(nodeData: any): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Basic required field checks for immediate UI feedback
+    if (!nodeData.prompt || nodeData.prompt.trim() === '') {
+      errors.push('Prompt is required');
+    }
+
+    // Backend handles all complex validation, API keys, etc.
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+export default AIAgentExecutionService;