@zerowidth/workbench-sdk 2.0.0-alpha.0

package/nodes/null-bomb/null-bomb.tests.json

@@ -0,0 +1,83 @@
+[
+  {
+    "description": "Always pass through value (0% probability)",
+    "inputs": {
+      "value": "test string",
+      "nullProbability": 0.0
+    },
+    "expected": {
+      "result": "test string"
+    }
+  },
+  {
+    "description": "Always return null (100% probability)",
+    "inputs": {
+      "value": 42,
+      "nullProbability": 1.0
+    },
+    "expected": {
+      "result": null
+    }
+  },
+  {
+    "description": "50% chance of null - schema validation",
+    "inputs": {
+      "value": {"key": "value"},
+      "nullProbability": 0.5
+    },
+    "expectedSchema": {
+      "result": {
+        "type": ["object", "null"]
+      }
+    }
+  },
+  {
+    "description": "Default probability (10%) - schema validation",
+    "inputs": {
+      "value": [1, 2, 3]
+    },
+    "expectedSchema": {
+      "result": {
+        "type": ["array", "null"]
+      }
+    }
+  },
+  {
+    "description": "Handle edge case probability values (clamped to 1.0)",
+    "inputs": {
+      "value": "edge case",
+      "nullProbability": 1.5
+    },
+    "expected": {
+      "result": null
+    }
+  },
+  {
+    "description": "Handle negative probability (clamped to 0.0)",
+    "inputs": {
+      "value": "negative test",
+      "nullProbability": -0.5
+    },
+    "expected": {
+      "result": "negative test"
+    }
+  },
+  {
+    "description": "Test with complex data structure - schema validation",
+    "inputs": {
+      "value": {
+        "nested": {
+          "array": [1, 2, 3],
+          "string": "hello",
+          "number": 123.45
+        }
+      },
+      "nullProbability": 0.3
+    },
+    "expectedSchema": {
+      "result": {
+        "type": ["object", "null"]
+      }
+    }
+  }
+]

package/nodes/number/number.config.json

@@ -0,0 +1,59 @@
+{
+  "display_name": "Number",
+  "tagline": "Set a number value",
+  "description": "A simple number node that outputs a constant numeric value",
+  "icon": "calculator",
+  "category": "math",
+  "custom_render_height": 42,
+  "is_constant": true,
+  "inputs": [
+    {
+      "name": "value",
+      "display_name": "Value",
+      "type": "number",
+      "description": "Optional value to override the default value.",
+      "required": false
+    }
+  ],
+  "outputs": [
+    {
+      "name": "value",
+      "primary": true,
+      "display_name": "Value",
+      "type": "number",
+      "description": "The numeric value."
+    }
+  ],
+  "settings": [
+    {
+      "name": "value",
+      "display_name": "Value",
+      "type": "number",
+      "description": "The numeric value to output.",
+      "default": 0
+    },
+    {
+      "name": "min",
+      "display_name": "Minimum",
+      "type": "number",
+      "description": "The minimum allowed value for the slider.",
+      "default": 0
+    },
+    {
+      "name": "max",
+      "display_name": "Maximum",
+      "type": "number",
+      "description": "The maximum allowed value for the slider.",
+      "default": 100
+    },
+    {
+      "name": "step",
+      "display_name": "Step",
+      "type": "number",
+      "description": "The step size for the slider.",
+      "default": 1
+    }
+  ],
+  "timeout": 3000,
+  "retry_limit": 3
+} 

package/nodes/number/number.process.js

@@ -0,0 +1,16 @@
+export default async ({inputs, settings, config}) => {
+
+  
+  // Use input value if provided, otherwise use the setting value
+  let value = (inputs.value !== undefined && inputs.value !== null) ? Number(inputs.value) : Number(settings.value);
+  
+  // Ensure the value is within min and max bounds
+  const min = Number(settings.min);
+  const max = Number(settings.max);
+  
+  if (!isNaN(min) && !isNaN(max)) {
+    value = Math.max(min, Math.min(max, value));
+  }
+
+  return { value };
+}; 

package/nodes/number/number.tests.json

@@ -0,0 +1,46 @@
+[
+  {
+    "description": "Default value when no input is provided",
+    "inputs": {},
+    "expected": { "value": 0 }
+  },
+  {
+    "description": "Override default value with input",
+    "inputs": { "value": 42 },
+    "expected": { "value": 42 }
+  },
+  {
+    "description": "String input is converted to number",
+    "inputs": { "value": "123" },
+    "expected": { "value": 100 }
+  },
+  {
+    "description": "Value is clamped to maximum",
+    "inputs": { "value": 200 },
+    "settings": { "min": 0, "max": 100, "step": 1 },
+    "expected": { "value": 100 }
+  },
+  {
+    "description": "Value is clamped to minimum",
+    "inputs": { "value": -50 },
+    "settings": { "min": 0, "max": 100, "step": 1 },
+    "expected": { "value": 0 }
+  },
+  {
+    "description": "Custom settings are respected",
+    "inputs": {},
+    "settings": { "value": 75, "min": 0, "max": 100, "step": 5 },
+    "expected": { "value": 75 }
+  },
+  {
+    "description": "Decimal values are supported",
+    "inputs": { "value": 3.14159 },
+    "expected": { "value": 3.14159 }
+  },
+  {
+    "description": "Negative values are supported when in range",
+    "inputs": { "value": -25 },
+    "settings": { "min": -50, "max": 50, "step": 1 },
+    "expected": { "value": -25 }
+  }
+] 

package/nodes/nvidia-llama-nemotron-embed-vl-1b-v2-free/nvidia-llama-nemotron-embed-vl-1b-v2-free.config.json

@@ -0,0 +1,91 @@
+{
+  "display_name": "NVIDIA: Llama Nemotron Embed VL 1B V2 (free)",
+  "tagline": "Generate embeddings",
+  "description": "The Llama Nemotron Embed VL 1B V2 embedding model is optimized for multimodal question-answering retrieval. The model can embed 'documents' in the form of image, text, or image and text...",
+  "category": "embedding",
+  "provider": "nvidia",
+  "model_id": "nvidia/llama-nemotron-embed-vl-1b-v2:free",
+  "context_length": 131072,
+  "input_modalities": [
+    "text",
+    "image"
+  ],
+  "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": "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": "usage",
+      "display_name": "Token Usage",
+      "type": "object",
+      "description": "Token usage statistics"
+    },
+    {
+      "name": "cost_total",
+      "display_name": "Total Cost",
+      "type": "number",
+      "description": "Total cost for processing this request (USD)"
+    },
+    {
+      "name": "cost_itemized",
+      "display_name": "Itemized Cost",
+      "type": "array",
+      "description": "Detailed breakdown of costs"
+    }
+  ],
+  "pricing": {
+    "reference": "https://openrouter.ai/models",
+    "items": [
+      {
+        "key": "input_cost_per_million",
+        "label": "Input Tokens (per 1M)",
+        "cost": 0,
+        "currency": "USD"
+      },
+      {
+        "key": "output_cost_per_million",
+        "label": "Output Tokens (per 1M)",
+        "cost": 0,
+        "currency": "USD"
+      }
+    ]
+  }
+}

package/nodes/nvidia-llama-nemotron-embed-vl-1b-v2-free/nvidia-llama-nemotron-embed-vl-1b-v2-free.process.js

@@ -0,0 +1,36 @@
+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");
+        }
+
+        // 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: "nvidia/llama-nemotron-embed-vl-1b-v2:free",
+            input: inputs.input,
+            ...params
+        }, nodeConfig, config);
+
+        return {
+            embedding: response.embedding,
+            embeddings: response.embeddings,
+            dimensions: response.dimensions,
+            usage: response.usage,
+            cost_total: response.cost_total,
+            cost_itemized: response.cost_itemized
+        };
+    } catch (error) {
+        console.log('error', error);
+        throw new Error(`NVIDIA: Llama Nemotron Embed VL 1B V2 (free) node error: ${error.message}`);
+    }
+};

package/nodes/nvidia-llama-nemotron-embed-vl-1b-v2-free/nvidia-llama-nemotron-embed-vl-1b-v2-free.tests.json

@@ -0,0 +1,48 @@
+[
+  {
+    "description": "Embed a single string",
+    "inputs": {
+      "input": "The quick brown fox jumps over the lazy dog."
+    },
+    "expectedSchema": {
+      "embedding": {
+        "type": "array"
+      },
+      "dimensions": {
+        "type": "number",
+        "minimum": 1
+      },
+      "usage": {
+        "type": "object"
+      },
+      "cost_total": {
+        "type": "number",
+        "minimum": 0
+      },
+      "cost_itemized": {
+        "type": "array"
+      }
+    }
+  },
+  {
+    "description": "Embed an array of strings",
+    "inputs": {
+      "input": [
+        "first piece of text",
+        "second piece of text"
+      ]
+    },
+    "expectedSchema": {
+      "embeddings": {
+        "type": "array"
+      },
+      "dimensions": {
+        "type": "number",
+        "minimum": 1
+      },
+      "usage": {
+        "type": "object"
+      }
+    }
+  }
+]

package/nodes/nvidia-llama-nemotron-rerank-vl-1b-v2-free/nvidia-llama-nemotron-rerank-vl-1b-v2-free.config.json

@@ -0,0 +1,95 @@
+{
+  "display_name": "NVIDIA: Llama Nemotron Rerank VL 1B V2 (free)",
+  "tagline": "Rerank documents by relevance",
+  "description": "Llama Nemotron Rerank VL 1B V2 is a 1.7B multimodal reranking model from NVIDIA. It evaluates the relevance of document images and text against user queries, designed for vision RAG...",
+  "category": "rerank",
+  "provider": "nvidia",
+  "model_id": "nvidia/llama-nemotron-rerank-vl-1b-v2:free",
+  "context_length": 10240,
+  "inputs": [
+    {
+      "name": "query",
+      "display_name": "Query",
+      "type": "string",
+      "description": "The search query to rank documents against",
+      "required": true
+    },
+    {
+      "name": "documents",
+      "display_name": "Documents",
+      "type": "array",
+      "description": "Candidate documents to rerank. Accepts an array of strings, or an array of objects (e.g. search results) — for objects, text is read from text_field or common fields like content/text.",
+      "required": true
+    },
+    {
+      "name": "top_n",
+      "display_name": "Top N",
+      "type": "number",
+      "description": "Optional: return only the top N most relevant documents",
+      "default": null
+    },
+    {
+      "name": "text_field",
+      "display_name": "Text Field",
+      "type": "string",
+      "description": "Optional: when documents are objects, which field holds the text to rank (defaults to trying content, text, document, page_content, chunk, body)",
+      "default": null
+    }
+  ],
+  "outputs": [
+    {
+      "name": "results",
+      "display_name": "Results",
+      "type": "array",
+      "description": "Reranked results, highest relevance first: { index, relevance_score, document } where document is the original input item"
+    },
+    {
+      "name": "ranked_documents",
+      "display_name": "Ranked Documents",
+      "type": "array",
+      "description": "The original documents reordered by relevance (highest first)"
+    },
+    {
+      "name": "top_document",
+      "display_name": "Top Document",
+      "type": "any",
+      "description": "The single most relevant document"
+    },
+    {
+      "name": "usage",
+      "display_name": "Usage",
+      "type": "object",
+      "description": "Usage / billed units reported by the provider (if any)"
+    },
+    {
+      "name": "cost_total",
+      "display_name": "Total Cost",
+      "type": "number",
+      "description": "Total cost for this request (USD), when token usage is reported"
+    },
+    {
+      "name": "cost_itemized",
+      "display_name": "Itemized Cost",
+      "type": "array",
+      "description": "Detailed breakdown of costs"
+    }
+  ],
+  "pricing": {
+    "reference": "https://openrouter.ai/models",
+    "note": "Rerank is typically billed per search (1 query + up to ~100 docs), not per token. OpenRouter does not expose a per-token rerank price.",
+    "items": [
+      {
+        "key": "input_cost_per_million",
+        "label": "Input Tokens (per 1M)",
+        "cost": 0,
+        "currency": "USD"
+      },
+      {
+        "key": "output_cost_per_million",
+        "label": "Output Tokens (per 1M)",
+        "cost": 0,
+        "currency": "USD"
+      }
+    ]
+  }
+}

package/nodes/nvidia-llama-nemotron-rerank-vl-1b-v2-free/nvidia-llama-nemotron-rerank-vl-1b-v2-free.process.js

@@ -0,0 +1,60 @@
+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");
+        }
+
+        const documents = inputs.documents;
+        if (!Array.isArray(documents)) {
+            throw new Error("documents must be an array");
+        }
+
+        // Extract the text to rank for each document, preserving the original item
+        const textField = inputs.text_field;
+        const toText = (doc) => {
+            if (typeof doc === 'string') return doc;
+            if (doc && typeof doc === 'object') {
+                if (textField && doc[textField] != null) return String(doc[textField]);
+                for (const f of ['content', 'text', 'document', 'page_content', 'chunk', 'body']) {
+                    if (doc[f] != null) return String(doc[f]);
+                }
+                return JSON.stringify(doc);
+            }
+            return String(doc);
+        };
+        const texts = documents.map(toText);
+
+        const params = {};
+        if (inputs.top_n !== null && inputs.top_n !== undefined) {
+            params.top_n = inputs.top_n;
+        }
+
+        const response = await openrouter.rerank({
+            model: "nvidia/llama-nemotron-rerank-vl-1b-v2:free",
+            query: inputs.query,
+            documents: texts,
+            ...params
+        }, nodeConfig, config);
+
+        // Reattach original documents by index, preserving the API's relevance order
+        const results = (response.results || []).map(r => ({
+            index: r.index,
+            relevance_score: r.relevance_score,
+            document: documents[r.index]
+        }));
+
+        return {
+            results,
+            ranked_documents: results.map(r => r.document),
+            top_document: results.length > 0 ? results[0].document : null,
+            usage: response.usage,
+            cost_total: response.cost_total,
+            cost_itemized: response.cost_itemized
+        };
+    } catch (error) {
+        console.log('error', error);
+        throw new Error(`NVIDIA: Llama Nemotron Rerank VL 1B V2 (free) node error: ${error.message}`);
+    }
+};

package/nodes/nvidia-llama-nemotron-rerank-vl-1b-v2-free/nvidia-llama-nemotron-rerank-vl-1b-v2-free.tests.json

@@ -0,0 +1,47 @@
+[
+  {
+    "description": "Rerank an array of strings",
+    "inputs": {
+      "query": "What is the capital of France?",
+      "documents": [
+        "The Eiffel Tower is in Paris.",
+        "Paris is the capital of France.",
+        "Bananas are a good source of potassium."
+      ]
+    },
+    "expectedSchema": {
+      "results": {
+        "type": "array"
+      },
+      "ranked_documents": {
+        "type": "array"
+      },
+      "usage": {
+        "type": "object"
+      }
+    }
+  },
+  {
+    "description": "Rerank objects and keep top N",
+    "inputs": {
+      "query": "database indexing",
+      "documents": [
+        {
+          "content": "B-tree indexes speed up range queries."
+        },
+        {
+          "content": "The mitochondria is the powerhouse of the cell."
+        }
+      ],
+      "top_n": 1
+    },
+    "expectedSchema": {
+      "results": {
+        "type": "array"
+      },
+      "top_document": {
+        "type": "object"
+      }
+    }
+  }
+]

package/nodes/object-merge/object-merge.config.json

@@ -0,0 +1,34 @@
+{
+  "display_name": "Object Merge",
+  "tagline": "Merge objects together",
+  "description": "Deep merges multiple objects into one. Later objects override earlier ones. Nested objects are recursively merged.",
+  "icon": "object-group",
+  "category": "data",
+  "inputs": [
+    {
+      "name": "objects",
+      "display_name": "Objects",
+      "type": "object",
+      "description": "Objects to merge (later objects override earlier ones)",
+      "required": true,
+      "allow_multiple": true
+    },
+    {
+      "name": "array_mode",
+      "display_name": "Array Mode",
+      "type": "string",
+      "description": "How to handle array values",
+      "required": false,
+      "default": "replace",
+      "options": ["replace", "concat"]
+    }
+  ],
+  "outputs": [
+    {
+      "name": "merged",
+      "display_name": "Merged",
+      "type": "object",
+      "description": "The merged object"
+    }
+  ]
+}

package/nodes/object-merge/object-merge.process.js

@@ -0,0 +1,53 @@
+export default async ({ inputs, settings, config }) => {
+  const objects = inputs.objects;
+  const arrayMode = inputs.array_mode ?? "replace";
+
+  // Normalize to array
+  const objectList = Array.isArray(objects) ? objects : [objects];
+
+  // Filter out non-objects
+  const validObjects = objectList.filter(
+    (obj) => obj !== null && typeof obj === "object" && !Array.isArray(obj)
+  );
+
+  if (validObjects.length === 0) {
+    return { merged: {} };
+  }
+
+  const isPlainObject = (val) =>
+    val !== null && typeof val === "object" && !Array.isArray(val);
+
+  const deepMerge = (target, source) => {
+    const result = { ...target };
+
+    for (const key of Object.keys(source)) {
+      const targetVal = target[key];
+      const sourceVal = source[key];
+
+      if (Array.isArray(sourceVal)) {
+        if (arrayMode === "concat" && Array.isArray(targetVal)) {
+          result[key] = [...targetVal, ...sourceVal];
+        } else {
+          result[key] = [...sourceVal];
+        }
+      } else if (isPlainObject(sourceVal)) {
+        if (isPlainObject(targetVal)) {
+          result[key] = deepMerge(targetVal, sourceVal);
+        } else {
+          result[key] = deepMerge({}, sourceVal);
+        }
+      } else {
+        result[key] = sourceVal;
+      }
+    }
+
+    return result;
+  };
+
+  let merged = {};
+  for (const obj of validObjects) {
+    merged = deepMerge(merged, obj);
+  }
+
+  return { merged };
+};