@zerowidth/workbench-sdk 2.0.0-alpha.0

package/nodes/truncate-text/truncate-text.process.js

@@ -0,0 +1,77 @@
+export default async ({ inputs, settings, config }) => {
+  const text = inputs.text;
+  const maxLength = inputs.max_length;
+  const position = inputs.position ?? "end";
+  const suffix = inputs.suffix ?? "...";
+  const wordBoundary = inputs.word_boundary ?? false;
+
+  if (typeof text !== "string") {
+    return { text: "", was_truncated: false, original_length: 0 };
+  }
+
+  const originalLength = text.length;
+
+  if (originalLength <= maxLength) {
+    return { text, was_truncated: false, original_length: originalLength };
+  }
+
+  const suffixLength = suffix.length;
+  const availableLength = maxLength - suffixLength;
+
+  if (availableLength <= 0) {
+    return { text: suffix.slice(0, maxLength), was_truncated: true, original_length: originalLength };
+  }
+
+  let result;
+
+  if (position === "end") {
+    let truncated = text.slice(0, availableLength);
+
+    if (wordBoundary) {
+      const lastSpace = truncated.lastIndexOf(" ");
+      if (lastSpace > availableLength * 0.5) {
+        truncated = truncated.slice(0, lastSpace);
+      }
+    }
+
+    result = truncated + suffix;
+  } else if (position === "start") {
+    let truncated = text.slice(-availableLength);
+
+    if (wordBoundary) {
+      const firstSpace = truncated.indexOf(" ");
+      if (firstSpace > 0 && firstSpace < availableLength * 0.5) {
+        truncated = truncated.slice(firstSpace + 1);
+      }
+    }
+
+    result = suffix + truncated;
+  } else if (position === "middle") {
+    const halfLength = Math.floor((availableLength - suffixLength) / 2);
+    let startPart = text.slice(0, halfLength);
+    let endPart = text.slice(-halfLength);
+
+    if (wordBoundary) {
+      const startLastSpace = startPart.lastIndexOf(" ");
+      if (startLastSpace > halfLength * 0.5) {
+        startPart = startPart.slice(0, startLastSpace);
+      }
+
+      const endFirstSpace = endPart.indexOf(" ");
+      if (endFirstSpace > 0 && endFirstSpace < halfLength * 0.5) {
+        endPart = endPart.slice(endFirstSpace + 1);
+      }
+    }
+
+    result = startPart + suffix + endPart;
+  } else {
+    result = text.slice(0, availableLength) + suffix;
+  }
+
+  // Ensure we don't exceed max length
+  if (result.length > maxLength) {
+    result = result.slice(0, maxLength);
+  }
+
+  return { text: result, was_truncated: true, original_length: originalLength };
+};

package/nodes/truncate-text/truncate-text.tests.json

@@ -0,0 +1,115 @@
+[
+  {
+    "description": "Truncate at end",
+    "inputs": {
+      "text": "Hello world, this is a long text",
+      "max_length": 15
+    },
+    "expected": {
+      "text": "Hello world,...",
+      "was_truncated": true,
+      "original_length": 32
+    }
+  },
+  {
+    "description": "Truncate at start",
+    "inputs": {
+      "text": "Hello world, this is a long text",
+      "max_length": 15,
+      "position": "start"
+    },
+    "expected": {
+      "text": "... a long text",
+      "was_truncated": true,
+      "original_length": 32
+    }
+  },
+  {
+    "description": "Truncate in middle",
+    "inputs": {
+      "text": "Hello world, this is a long text that goes on",
+      "max_length": 20,
+      "position": "middle"
+    },
+    "expected": {
+      "text": "Hello w...goes on",
+      "was_truncated": true,
+      "original_length": 45
+    }
+  },
+  {
+    "description": "No truncation needed",
+    "inputs": {
+      "text": "Short text",
+      "max_length": 20
+    },
+    "expected": {
+      "text": "Short text",
+      "was_truncated": false,
+      "original_length": 10
+    }
+  },
+  {
+    "description": "Custom suffix",
+    "inputs": {
+      "text": "Hello world, this is a long text",
+      "max_length": 20,
+      "suffix": " [...]"
+    },
+    "expected": {
+      "text": "Hello world, t [...]",
+      "was_truncated": true,
+      "original_length": 32
+    }
+  },
+  {
+    "description": "Empty suffix",
+    "inputs": {
+      "text": "Hello world, this is a long text",
+      "max_length": 10,
+      "suffix": ""
+    },
+    "expected": {
+      "text": "Hello worl",
+      "was_truncated": true,
+      "original_length": 32
+    }
+  },
+  {
+    "description": "Exact length match",
+    "inputs": {
+      "text": "Hello",
+      "max_length": 5
+    },
+    "expected": {
+      "text": "Hello",
+      "was_truncated": false,
+      "original_length": 5
+    }
+  },
+  {
+    "description": "Very short max length",
+    "inputs": {
+      "text": "Hello world",
+      "max_length": 5
+    },
+    "expected": {
+      "text": "He...",
+      "was_truncated": true,
+      "original_length": 11
+    }
+  },
+  {
+    "description": "Max length shorter than suffix",
+    "inputs": {
+      "text": "Hello world",
+      "max_length": 2,
+      "suffix": "..."
+    },
+    "expected": {
+      "text": "..",
+      "was_truncated": true,
+      "original_length": 11
+    }
+  }
+]

package/nodes/twilio-send-sms/twilio-send-sms.config.json

@@ -0,0 +1,45 @@
+{
+  "display_name": "Twilio Send SMS",
+  "tagline": "Send SMS via Twilio",
+  "description": "Send an SMS message using the Twilio Programmable Messaging API.",
+  "icon": "smartphone",
+  "category": "third-party",
+  "is_plugin": true,
+  "inputs": [
+    {
+      "name": "to",
+      "display_name": "To",
+      "type": "string",
+      "description": "Recipient phone number in E.164 format (e.g. +15551234567)",
+      "required": true
+    },
+    {
+      "name": "from",
+      "display_name": "From",
+      "type": "string",
+      "description": "Twilio phone number to send from in E.164 format",
+      "required": true
+    },
+    {
+      "name": "body",
+      "display_name": "Body",
+      "type": "string",
+      "description": "SMS message body (max 1600 characters)",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "sid",
+      "display_name": "Message SID",
+      "type": "string",
+      "description": "Twilio message SID"
+    },
+    {
+      "name": "status",
+      "display_name": "Status",
+      "type": "string",
+      "description": "Message status (queued, sent, delivered, etc.)"
+    }
+  ]
+}

package/nodes/twilio-send-sms/twilio-send-sms.process.js

@@ -0,0 +1,17 @@
+export default async ({ inputs, settings, config }) => {
+  const twilio = config.integrations?.twilio;
+  if (!twilio) {
+    throw new Error("Twilio integration not configured. Add your Twilio config to config.keys.twilio ({account_sid, auth_token})");
+  }
+
+  if (!inputs.to) throw new Error("to is required");
+  if (!inputs.from) throw new Error("from is required");
+  if (!inputs.body) throw new Error("body is required");
+
+  const result = await twilio.sendSMS(inputs.to, inputs.from, inputs.body);
+
+  return {
+    sid: result.sid,
+    status: result.status,
+  };
+};

package/nodes/twilio-send-sms/twilio-send-sms.tests.json

@@ -0,0 +1,14 @@
+[
+  {
+    "description": "Send SMS",
+    "inputs": {
+      "to": "${TWILIO_TEST_TO}",
+      "from": "${TWILIO_TEST_FROM}",
+      "body": "Test SMS from zv1"
+    },
+    "expected": {
+      "sid": "string",
+      "status": "string"
+    }
+  }
+]

package/nodes/untokenizer/untokenizer.config.json

@@ -0,0 +1,38 @@
+{
+  "display_name": "Untokenizer",
+  "tagline": "Detokenize text",
+  "description": "Convert arrays of token numbers back into text strings using cl200k_base or cl100k_base tokenizers.",
+  "icon": "hash",
+  "category": "text",
+  "inputs": [
+    {
+      "name": "tokens",
+      "display_name": "Tokens",
+      "type": "array",
+      "description": "Array of token numbers to convert back to text.",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "text",
+      "display_name": "Text",
+      "type": "string",
+      "description": "The decoded text string from the token array"
+    }
+  ],
+  "settings": [
+    {
+      "name": "tokenizer",
+      "display_name": "Tokenizer",
+      "type": "string",
+      "description": "The tokenizer to use for untokenization",
+      "default": "cl200k_base",
+      "options": [
+        "cl200k_base",
+        "cl100k_base"
+      ],
+      "required": true
+    }
+  ]
+}

package/nodes/untokenizer/untokenizer.process.js

@@ -0,0 +1,46 @@
+import { encoding_for_model } from 'tiktoken';
+
+export default async ({inputs, settings, config}) => {
+    try {
+        const tokens = inputs.tokens;
+        if (!Array.isArray(tokens)) {
+            throw new Error("Tokens input must be an array of numbers");
+        }
+
+        // Get the tokenizer setting, default to cl200k_base
+        const tokenizer = settings.tokenizer || 'cl200k_base';
+
+        // Validate tokenizer option
+        if (!['cl200k_base', 'cl100k_base'].includes(tokenizer)) {
+            throw new Error(`Unsupported tokenizer: ${tokenizer}. Only cl200k_base and cl100k_base are supported.`);
+        }
+
+        // Get the encoding for the specified tokenizer
+        const encoding = encoding_for_model(tokenizer === 'cl200k_base' ? 'gpt-4o' : 'gpt-4');
+
+        // Convert to regular array if it's a Uint32Array or similar
+        const tokenArray = Array.isArray(tokens) ? tokens : Array.from(tokens);
+
+        // Validate that all tokens are numbers
+        for (let i = 0; i < tokenArray.length; i++) {
+            if (typeof tokenArray[i] !== 'number' || !Number.isInteger(tokenArray[i])) {
+                throw new Error(`Token at index ${i} is not a valid integer: ${tokenArray[i]}`);
+            }
+        }
+
+        // Decode the tokens back to text
+        const decodedBytes = encoding.decode(tokenArray);
+        const text = typeof decodedBytes === 'string' ? decodedBytes : new TextDecoder().decode(decodedBytes);
+
+        // Free the encoding to prevent memory leaks
+        encoding.free();
+
+        return {
+            text: text
+        };
+
+    } catch (error) {
+        console.log('Untokenizer error:', error);
+        throw new Error(`Untokenizer error: ${error.message}`);
+    }
+};

package/nodes/untokenizer/untokenizer.tests.json

@@ -0,0 +1,83 @@
+[
+  {
+    "description": "Untokenize simple tokens with cl200k_base (default)",
+    "inputs": {
+      "tokens": [13225, 11, 2375, 0]
+    },
+    "expected": {
+      "text": "Hello, world!"
+    }
+  },
+  {
+    "description": "Untokenize with cl100k_base tokenizer",
+    "inputs": {
+      "tokens": [9906, 11, 1917, 0]
+    },
+    "settings": {
+      "tokenizer": "cl100k_base"
+    },
+    "expected": {
+      "text": "Hello, world!"
+    }
+  },
+  {
+    "description": "Untokenize Message object tokens with cl200k_base",
+    "inputs": {
+      "tokens": [2500, 382, 261, 1746, 3176]
+    },
+    "settings": {
+      "tokenizer": "cl200k_base"
+    },
+    "expected": {
+      "text": "This is a test message"
+    }
+  },
+  {
+    "description": "Untokenize array of message tokens with cl100k_base",
+    "inputs": {
+      "tokens": [5451, 1984, 16041, 1984]
+    },
+    "settings": {
+      "tokenizer": "cl100k_base"
+    },
+    "expected": {
+      "text": "First messageSecond message"
+    }
+  },
+  {
+    "description": "Untokenize conversation tokens",
+    "inputs": {
+      "tokens": [13225, 12194, 1354, 0]
+    },
+    "expected": {
+      "text": "HelloHi there!"
+    }
+  },
+  {
+    "description": "Handle empty token array",
+    "inputs": {
+      "tokens": []
+    },
+    "expected": {
+      "text": ""
+    }
+  },
+  {
+    "description": "Handle single token",
+    "inputs": {
+      "tokens": [13225]
+    },
+    "expected": {
+      "text": "Hello"
+    }
+  },
+  {
+    "description": "Handle multi-modal text tokens",
+    "inputs": {
+      "tokens": [13225, 11, 2375, 0]
+    },
+    "expected": {
+      "text": "Hello, world!"
+    }
+  }
+]

package/nodes/word-count/word-count.config.json

@@ -0,0 +1,54 @@
+{
+  "display_name": "Word Count",
+  "tagline": "Count words in text",
+  "description": "Counts words, characters, sentences, and paragraphs in text.",
+  "icon": "text-size",
+  "category": "data",
+  "inputs": [
+    {
+      "name": "text",
+      "display_name": "Text",
+      "type": "string",
+      "description": "The text to analyze",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "characters",
+      "display_name": "Characters",
+      "type": "number",
+      "description": "Total number of characters (including spaces)"
+    },
+    {
+      "name": "characters_no_spaces",
+      "display_name": "Characters (No Spaces)",
+      "type": "number",
+      "description": "Number of characters excluding spaces"
+    },
+    {
+      "name": "words",
+      "display_name": "Words",
+      "type": "number",
+      "description": "Number of words"
+    },
+    {
+      "name": "sentences",
+      "display_name": "Sentences",
+      "type": "number",
+      "description": "Number of sentences"
+    },
+    {
+      "name": "paragraphs",
+      "display_name": "Paragraphs",
+      "type": "number",
+      "description": "Number of paragraphs"
+    },
+    {
+      "name": "lines",
+      "display_name": "Lines",
+      "type": "number",
+      "description": "Number of lines"
+    }
+  ]
+}

package/nodes/word-count/word-count.process.js

@@ -0,0 +1,40 @@
+export default async ({ inputs, settings, config }) => {
+  const text = inputs.text;
+
+  if (typeof text !== "string" || text === "") {
+    return {
+      characters: 0,
+      characters_no_spaces: 0,
+      words: 0,
+      sentences: 0,
+      paragraphs: 0,
+      lines: 0,
+    };
+  }
+
+  // Character counts
+  const characters = text.length;
+  const charactersNoSpaces = text.replace(/\s/g, "").length;
+
+  // Word count - split on whitespace and filter empty
+  const words = text.trim().split(/\s+/).filter((w) => w.length > 0).length;
+
+  // Sentence count - split on sentence-ending punctuation
+  const sentenceMatches = text.match(/[.!?]+(?:\s|$)/g);
+  const sentences = sentenceMatches ? sentenceMatches.length : (text.trim() ? 1 : 0);
+
+  // Paragraph count - split on double newlines
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0).length;
+
+  // Line count
+  const lines = text.split("\n").length;
+
+  return {
+    characters,
+    characters_no_spaces: charactersNoSpaces,
+    words,
+    sentences,
+    paragraphs,
+    lines,
+  };
+};

package/nodes/word-count/word-count.tests.json

@@ -0,0 +1,100 @@
+[
+  {
+    "description": "Count basic text",
+    "inputs": {
+      "text": "Hello world"
+    },
+    "expected": {
+      "characters": 11,
+      "characters_no_spaces": 10,
+      "words": 2,
+      "sentences": 1,
+      "paragraphs": 1,
+      "lines": 1
+    }
+  },
+  {
+    "description": "Count multiple sentences",
+    "inputs": {
+      "text": "Hello world. How are you? I am fine!"
+    },
+    "expected": {
+      "characters": 36,
+      "characters_no_spaces": 29,
+      "words": 8,
+      "sentences": 3,
+      "paragraphs": 1,
+      "lines": 1
+    }
+  },
+  {
+    "description": "Count multiple paragraphs",
+    "inputs": {
+      "text": "First paragraph.\n\nSecond paragraph.\n\nThird paragraph."
+    },
+    "expected": {
+      "characters": 53,
+      "characters_no_spaces": 46,
+      "words": 6,
+      "sentences": 3,
+      "paragraphs": 3,
+      "lines": 5
+    }
+  },
+  {
+    "description": "Count multiple lines",
+    "inputs": {
+      "text": "Line 1\nLine 2\nLine 3"
+    },
+    "expected": {
+      "characters": 20,
+      "characters_no_spaces": 15,
+      "words": 6,
+      "sentences": 1,
+      "paragraphs": 1,
+      "lines": 3
+    }
+  },
+  {
+    "description": "Handle empty string",
+    "inputs": {
+      "text": ""
+    },
+    "expected": {
+      "characters": 0,
+      "characters_no_spaces": 0,
+      "words": 0,
+      "sentences": 0,
+      "paragraphs": 0,
+      "lines": 0
+    }
+  },
+  {
+    "description": "Handle whitespace only",
+    "inputs": {
+      "text": "   \n\n   "
+    },
+    "expected": {
+      "characters": 8,
+      "characters_no_spaces": 0,
+      "words": 0,
+      "sentences": 0,
+      "paragraphs": 0,
+      "lines": 3
+    }
+  },
+  {
+    "description": "Count long text",
+    "inputs": {
+      "text": "The quick brown fox jumps over the lazy dog. This is a sample sentence with multiple words."
+    },
+    "expected": {
+      "characters": 91,
+      "characters_no_spaces": 75,
+      "words": 17,
+      "sentences": 2,
+      "paragraphs": 1,
+      "lines": 1
+    }
+  }
+]