@zerowidth/workbench-sdk 2.0.0-alpha.0

package/nodes/divide/divide.tests.json

@@ -0,0 +1,42 @@
+[
+  {
+    "description": "Divide positive numbers",
+    "inputs": {
+      "a": 10,
+      "b": 2
+    },
+    "expected": {
+      "result": 5
+    }
+  },
+  {
+    "description": "Divide negative numbers",
+    "inputs": {
+      "a": -6,
+      "b": -2
+    },
+    "expected": {
+      "result": 3
+    }
+  },
+  {
+    "description": "Divide decimals",
+    "inputs": {
+      "a": 5.4,
+      "b": 2
+    },
+    "expected": {
+      "result": 2.7
+    }
+  },
+  {
+    "description": "Handle division by zero",
+    "inputs": {
+      "a": 5,
+      "b": 0
+    },
+    "expected": {
+      "result": null
+    }
+  }
+] 

package/nodes/duration-calculator/duration-calculator.config.json

@@ -0,0 +1,77 @@
+{
+  "display_name": "Duration Calculator",
+  "tagline": "Calculate time duration",
+  "description": "Calculate duration between two timestamps in various units (seconds, minutes, hours, days)",
+  "icon": "timer",
+  "category": "date",
+  "provider": "internal",
+  "is_plugin": false,
+  "inputs": [
+    {
+      "name": "start_time",
+      "display_name": "Start Time",
+      "type": "string",
+      "description": "Start timestamp (ISO string, Unix timestamp, or any parseable date format)",
+      "required": true
+    },
+    {
+      "name": "end_time",
+      "display_name": "End Time",
+      "type": "string",
+      "description": "End timestamp (ISO string, Unix timestamp, or any parseable date format). Leave empty for current time",
+      "required": false
+    },
+    {
+      "name": "output_unit",
+      "display_name": "Output Unit",
+      "type": "string",
+      "description": "Unit for the duration output",
+      "required": false,
+      "options": [
+        "seconds",
+        "minutes",
+        "hours",
+        "days"
+      ]
+    }
+  ],
+  "outputs": [
+    {
+      "name": "duration",
+      "display_name": "Duration",
+      "type": "number",
+      "description": "Duration in the specified unit"
+    },
+    {
+      "name": "duration_seconds",
+      "display_name": "Duration (seconds)",
+      "type": "number",
+      "description": "Duration in seconds"
+    },
+    {
+      "name": "duration_minutes",
+      "display_name": "Duration (minutes)",
+      "type": "number",
+      "description": "Duration in minutes"
+    },
+    {
+      "name": "duration_hours",
+      "display_name": "Duration (hours)",
+      "type": "number",
+      "description": "Duration in hours"
+    },
+    {
+      "name": "duration_days",
+      "display_name": "Duration (days)",
+      "type": "number",
+      "description": "Duration in days"
+    },
+    {
+      "name": "human_readable",
+      "display_name": "Human Readable",
+      "type": "string",
+      "description": "Duration in human-readable format (e.g., '2 hours 30 minutes')"
+    }
+  ],
+  "settings": []
+}

package/nodes/duration-calculator/duration-calculator.process.js

@@ -0,0 +1,96 @@
+export default async ({inputs, settings, config, nodeConfig}) => {
+  try {
+    const startTime = inputs.start_time;
+    const endTime = inputs.end_time || new Date().toISOString();
+    const outputUnit = inputs.output_unit || 'seconds';
+    
+    // Parse timestamps
+    const startDate = parseTimestamp(startTime);
+    const endDate = parseTimestamp(endTime);
+    
+    if (!startDate || !endDate) {
+      throw new Error("Invalid timestamp format. Use ISO strings, Unix timestamps, or parseable date formats");
+    }
+    
+    // Calculate duration in milliseconds
+    const durationMs = endDate.getTime() - startDate.getTime();
+    const durationSeconds = durationMs / 1000;
+    const durationMinutes = durationSeconds / 60;
+    const durationHours = durationMinutes / 60;
+    const durationDays = durationHours / 24;
+    
+    // Get duration in requested unit
+    let duration;
+    switch (outputUnit) {
+      case 'seconds':
+        duration = Math.round(durationSeconds * 100) / 100; // Round to 2 decimal places
+        break;
+      case 'minutes':
+        duration = Math.round(durationMinutes * 100) / 100;
+        break;
+      case 'hours':
+        duration = Math.round(durationHours * 100) / 100;
+        break;
+      case 'days':
+        duration = Math.round(durationDays * 100) / 100;
+        break;
+      default:
+        duration = Math.round(durationSeconds * 100) / 100;
+    }
+    
+    // Generate human readable format
+    const humanReadable = formatHumanReadable(durationMs);
+    
+    return {
+      duration: duration,
+      duration_seconds: Math.round(durationSeconds * 100) / 100,
+      duration_minutes: Math.round(durationMinutes * 100) / 100,
+      duration_hours: Math.round(durationHours * 100) / 100,
+      duration_days: Math.round(durationDays * 100) / 100,
+      human_readable: humanReadable
+    };
+    
+  } catch (error) {
+    throw new Error(`Duration Calculator error: ${error.message}`);
+  }
+};
+
+// Helper function to parse various timestamp formats
+function parseTimestamp(timestamp) {
+  if (!timestamp) return null;
+  
+  // Try parsing as Unix timestamp (number)
+  if (!isNaN(timestamp) && !isNaN(parseFloat(timestamp))) {
+    const num = parseFloat(timestamp);
+    // If it's a large number, assume it's milliseconds, otherwise seconds
+    const date = num > 1000000000000 ? new Date(num) : new Date(num * 1000);
+    if (!isNaN(date.getTime())) return date;
+  }
+  
+  // Try parsing as ISO string or other date format
+  const date = new Date(timestamp);
+  if (!isNaN(date.getTime())) return date;
+  
+  return null;
+}
+
+// Helper function to format duration in human readable format
+function formatHumanReadable(durationMs) {
+  const seconds = Math.floor(durationMs / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  
+  const remainingHours = hours % 24;
+  const remainingMinutes = minutes % 60;
+  const remainingSeconds = seconds % 60;
+  
+  const parts = [];
+  
+  if (days > 0) parts.push(`${days} day${days !== 1 ? 's' : ''}`);
+  if (remainingHours > 0) parts.push(`${remainingHours} hour${remainingHours !== 1 ? 's' : ''}`);
+  if (remainingMinutes > 0) parts.push(`${remainingMinutes} minute${remainingMinutes !== 1 ? 's' : ''}`);
+  if (remainingSeconds > 0 || parts.length === 0) parts.push(`${remainingSeconds} second${remainingSeconds !== 1 ? 's' : ''}`);
+  
+  return parts.join(' ');
+}

package/nodes/duration-calculator/duration-calculator.tests.json

@@ -0,0 +1,124 @@
+[
+  {
+    "inputs": {
+      "start_time": "2024-01-15T10:00:00Z",
+      "end_time": "2024-01-15T12:30:00Z"
+    },
+    "expected": {
+      "duration": 9000,
+      "duration_seconds": 9000,
+      "duration_minutes": 150,
+      "duration_hours": 2.5,
+      "duration_days": 0.1,
+      "human_readable": "2 hours 30 minutes"
+    },
+    "description": "Basic duration calculation - ISO timestamps"
+  },
+  {
+    "inputs": {
+      "start_time": "2024-01-15T10:00:00Z",
+      "end_time": "2024-01-15T12:30:00Z",
+      "output_unit": "minutes"
+    },
+    "expected": {
+      "duration": 150,
+      "duration_seconds": 9000,
+      "duration_minutes": 150,
+      "duration_hours": 2.5,
+      "duration_days": 0.1,
+      "human_readable": "2 hours 30 minutes"
+    },
+    "description": "Duration in minutes"
+  },
+  {
+    "inputs": {
+      "start_time": "2024-01-15T10:00:00Z",
+      "end_time": "2024-01-15T12:30:00Z",
+      "output_unit": "hours"
+    },
+    "expected": {
+      "duration": 2.5,
+      "duration_seconds": 9000,
+      "duration_minutes": 150,
+      "duration_hours": 2.5,
+      "duration_days": 0.1,
+      "human_readable": "2 hours 30 minutes"
+    },
+    "description": "Duration in hours"
+  },
+  {
+    "inputs": {
+      "start_time": "1705312800",
+      "end_time": "1705320000"
+    },
+    "expected": {
+      "duration": 7200,
+      "duration_seconds": 7200,
+      "duration_minutes": 120,
+      "duration_hours": 2,
+      "duration_days": 0.08,
+      "human_readable": "2 hours"
+    },
+    "description": "Unix timestamp inputs"
+  },
+  {
+    "inputs": {
+      "start_time": "2024-01-01T00:00:00Z",
+      "end_time": "2024-01-05T12:00:00Z",
+      "output_unit": "days"
+    },
+    "expected": {
+      "duration": 4.5,
+      "duration_seconds": 388800,
+      "duration_minutes": 6480,
+      "duration_hours": 108,
+      "duration_days": 4.5,
+      "human_readable": "4 days 12 hours"
+    },
+    "description": "Multi-day duration"
+  },
+  {
+    "inputs": {
+      "start_time": "2024-01-15T10:00:00Z"
+    },
+    "expectedSchema": {
+      "duration": { "type": "number" },
+      "duration_seconds": { "type": "number" },
+      "duration_minutes": { "type": "number" },
+      "duration_hours": { "type": "number" },
+      "duration_days": { "type": "number" },
+      "human_readable": { "type": "string" }
+    },
+    "description": "Current time as end time - schema validation"
+  },
+  {
+    "inputs": {
+      "start_time": "2024-01-15T12:00:00Z",
+      "end_time": "2024-01-15T10:00:00Z"
+    },
+    "expected": {
+      "duration": -7200,
+      "duration_seconds": -7200,
+      "duration_minutes": -120,
+      "duration_hours": -2,
+      "duration_days": -0.08,
+      "human_readable": "-2 hours"
+    },
+    "description": "Negative duration (end before start)"
+  },
+  {
+    "inputs": {
+      "start_time": "invalid-date",
+      "end_time": "2024-01-15T12:00:00Z"
+    },
+    "expectedError": "Duration Calculator error: Invalid timestamp format. Use ISO strings, Unix timestamps, or parseable date formats",
+    "description": "Error - invalid start time"
+  },
+  {
+    "inputs": {
+      "end_time": "2024-01-15T12:00:00Z"
+    },
+    "expectedError": "Duration Calculator error: Invalid timestamp format. Use ISO strings, Unix timestamps, or parseable date formats",
+    "description": "Error - missing start time"
+  }
+]

package/nodes/embedding/embedding.config.json

@@ -0,0 +1,81 @@
+{
+  "display_name": "Embedding",
+  "tagline": "Generate embeddings (any model)",
+  "description": "Generate vector embeddings using any OpenRouter embedding model. The model is an input, so it can be specified or swapped from outside the flow rather than baked into the node.",
+  "category": "embedding",
+  "provider": "openrouter",
+  "inputs": [
+    {
+      "name": "input",
+      "display_name": "Input",
+      "type": "string or array of strings",
+      "description": "Text, or an array of texts, to convert into embedding vectors",
+      "required": true
+    },
+    {
+      "name": "model",
+      "display_name": "Model",
+      "type": "string",
+      "description": "OpenRouter embedding model id (e.g. openai/text-embedding-3-small, google/gemini-embedding-001, qwen/qwen3-embedding-8b). Wire this from a flow input to swap models externally.",
+      "default": "openai/text-embedding-3-small"
+    },
+    {
+      "name": "dimensions",
+      "display_name": "Dimensions",
+      "type": "number",
+      "description": "Optional: reduce the output vector size. Only some models support this (e.g. OpenAI text-embedding-3-*, Gemini, Qwen3). Leave null for the model default.",
+      "default": null
+    },
+    {
+      "name": "encoding_format",
+      "display_name": "Encoding Format",
+      "type": "string",
+      "description": "Optional: \"float\" (default) or \"base64\"",
+      "default": null
+    }
+  ],
+  "outputs": [
+    {
+      "name": "embedding",
+      "display_name": "Embedding",
+      "type": "array",
+      "description": "The embedding vector for the first (or only) input"
+    },
+    {
+      "name": "embeddings",
+      "display_name": "Embeddings",
+      "type": "array",
+      "description": "Array of embedding vectors, one per input (in input order)"
+    },
+    {
+      "name": "dimensions",
+      "display_name": "Dimensions",
+      "type": "number",
+      "description": "Length of each embedding vector"
+    },
+    {
+      "name": "model",
+      "display_name": "Model Used",
+      "type": "string",
+      "description": "The embedding model that actually produced the vectors"
+    },
+    {
+      "name": "usage",
+      "display_name": "Token Usage",
+      "type": "object",
+      "description": "Token usage statistics"
+    },
+    {
+      "name": "cost_total",
+      "display_name": "Total Cost",
+      "type": "number",
+      "description": "Total cost (USD), reported by OpenRouter usage accounting for the chosen model."
+    },
+    {
+      "name": "cost_itemized",
+      "display_name": "Itemized Cost",
+      "type": "array",
+      "description": "Detailed cost breakdown (input/output line items)"
+    }
+  ]
+}

package/nodes/embedding/embedding.process.js

@@ -0,0 +1,44 @@
+export default async ({inputs, settings, config, nodeConfig}) => {
+    try {
+        // Get OpenRouter integration from engine
+        const openrouter = config.integrations?.openrouter;
+        if (!openrouter) {
+            throw new Error("OpenRouter integration not found");
+        }
+
+        // Model is dynamic — read from input (or settings override), fall back to a default
+        const model = inputs.model || settings?.model || "openai/text-embedding-3-small";
+
+        if (inputs.input === null || inputs.input === undefined) {
+            throw new Error("input is required");
+        }
+
+        // Build optional parameters (only sent when provided)
+        const params = {};
+        if (inputs.dimensions !== null && inputs.dimensions !== undefined) {
+            params.dimensions = inputs.dimensions;
+        }
+        if (inputs.encoding_format !== null && inputs.encoding_format !== undefined) {
+            params.encoding_format = inputs.encoding_format;
+        }
+
+        const response = await openrouter.createEmbedding({
+            model: model,
+            input: inputs.input,
+            ...params
+        }, nodeConfig, config);
+
+        return {
+            embedding: response.embedding,
+            embeddings: response.embeddings,
+            dimensions: response.dimensions,
+            model: response.model,
+            usage: response.usage,
+            cost_total: response.cost_total ?? null,
+            cost_itemized: response.cost_itemized ?? null
+        };
+    } catch (error) {
+        console.log('error', error);
+        throw new Error(`Embedding node error: ${error.message}`);
+    }
+};

package/nodes/embedding/embedding.tests.json

@@ -0,0 +1,26 @@
+[
+  {
+    "description": "Embed a single string with the default model",
+    "inputs": {
+      "input": "The quick brown fox jumps over the lazy dog."
+    },
+    "expectedSchema": {
+      "embedding": { "type": "array" },
+      "dimensions": { "type": "number", "minimum": 1 },
+      "model": { "type": "string" },
+      "usage": { "type": "object" }
+    }
+  },
+  {
+    "description": "Swap the model via input and embed an array",
+    "inputs": {
+      "model": "openai/text-embedding-3-large",
+      "input": ["first text", "second text"]
+    },
+    "expectedSchema": {
+      "embeddings": { "type": "array" },
+      "dimensions": { "type": "number", "minimum": 1 },
+      "model": { "type": "string" }
+    }
+  }
+]

package/nodes/equals/equals.config.json

@@ -0,0 +1,32 @@
+{
+  "display_name": "Equals",
+  "tagline": "Check equality",
+  "description": "Checks if two values are equal, with deep comparison for objects and arrays",
+  "icon": "equals",
+  "category": "logic",
+  "inputs": [
+    {
+      "name": "a",
+      "display_name": "Value A",
+      "type": "any",
+      "description": "First value to compare",
+      "required": true
+    },
+    {
+      "name": "b",
+      "display_name": "Value B",
+      "type": "any",
+      "description": "Second value to compare",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "result",
+      "display_name": "Result",
+      "type": "boolean",
+      "description": "True if values are equal, false otherwise"
+    }
+  ],
+  "settings": []
+} 

package/nodes/equals/equals.process.js

@@ -0,0 +1,29 @@
+export default async ({inputs, settings, config}) => {
+
+  const a = inputs.a;
+  const b = inputs.b;
+  
+  // Simple deep equality check
+  const result = deepEquals(a, b);
+  
+  return { result };
+};
+
+// Helper function for deep equality comparison
+function deepEquals(a, b) {
+  // If the values are strictly equal, return true
+  if (a === b) return true;
+  
+  // If either value is null or not an object, they're not equal
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  
+  // Get the keys of both objects
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  
+  // If they have different number of keys, they're not equal
+  if (keysA.length !== keysB.length) return false;
+  
+  // Check if all keys in A exist in B and have equal values
+  return keysA.every(key => keysB.includes(key) && deepEquals(a[key], b[key]));
+} 

package/nodes/equals/equals.tests.json

@@ -0,0 +1,111 @@
+[
+  {
+    "description": "Compare equal numbers",
+    "inputs": {"a": 5, "b": 5},
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare unequal numbers",
+    "inputs": {"a": 5, "b": 10},
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare equal strings",
+    "inputs": {"a": "hello", "b": "hello"},
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare unequal strings",
+    "inputs": {"a": "hello", "b": "world"},
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare equal booleans",
+    "inputs": {"a": true, "b": true},
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare unequal booleans",
+    "inputs": {"a": true, "b": false},
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare different types",
+    "inputs": {"a": "5", "b": 5},
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare equal objects",
+    "inputs": {
+      "a": {"name": "John", "age": 30},
+      "b": {"name": "John", "age": 30}
+    },
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare equal objects with different key order",
+    "inputs": {
+      "a": {"name": "John", "age": 30},
+      "b": {"age": 30, "name": "John"}
+    },
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare unequal objects",
+    "inputs": {
+      "a": {"name": "John", "age": 30},
+      "b": {"name": "John", "age": 31}
+    },
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare equal arrays",
+    "inputs": {
+      "a": [1, 2, 3],
+      "b": [1, 2, 3]
+    },
+    "expected": {
+      "result": true
+    }
+  },
+  {
+    "description": "Compare unequal arrays",
+    "inputs": {
+      "a": [1, 2, 3],
+      "b": [1, 2, 4]
+    },
+    "expected": {
+      "result": false
+    }
+  },
+  {
+    "description": "Compare nested objects",
+    "inputs": {
+      "a": {"user": {"name": "John", "details": {"age": 30}}},
+      "b": {"user": {"name": "John", "details": {"age": 30}}}
+    },
+    "expected": {
+      "result": true
+    }
+  }
+]