@zerowidth/workbench-sdk 2.0.0-alpha.0

package/nodes/cohere-rerank-v3-5/cohere-rerank-v3-5.config.json

@@ -0,0 +1,95 @@
+{
+  "display_name": "Cohere: Rerank v3.5",
+  "tagline": "Rerank documents by relevance",
+  "description": "Rerank v3.5 is designed to reorder search results for improved relevance. It supports multi-aspect and semi-structured data reranking over 100+ languages. Ideal for refining results from semantic or keyword search...",
+  "category": "rerank",
+  "provider": "cohere",
+  "model_id": "cohere/rerank-v3.5",
+  "context_length": 4096,
+  "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/cohere-rerank-v3-5/cohere-rerank-v3-5.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: "cohere/rerank-v3.5",
+            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(`Cohere: Rerank v3.5 node error: ${error.message}`);
+    }
+};

package/nodes/cohere-rerank-v3-5/cohere-rerank-v3-5.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/combine-document-chunks/combine-document-chunks.config.json

@@ -0,0 +1,58 @@
+{
+  "display_name": "Combine Document Chunks",
+  "tagline": "Combine document chunks",
+  "description": "Retrieve all chunks for a document and combine them into a single markdown content string",
+  "category": "knowledge",
+  "is_plugin": true,
+  "inputs": [
+    {
+      "name": "document_id",
+      "display_name": "Document ID",
+      "type": "string",
+      "description": "The ID of the document to combine chunks for",
+      "required": true
+    },
+    {
+      "name": "include_metadata",
+      "display_name": "Include Metadata",
+      "type": "boolean",
+      "description": "Whether to include chunk metadata in the output",
+      "default": false
+    },
+    {
+      "name": "separator",
+      "display_name": "Separator",
+      "type": "string",
+      "description": "String to use as separator between chunks",
+      "default": "\n\n---\n\n"
+    }
+  ],
+  "outputs": [
+    {
+      "name": "content",
+      "display_name": "Content",
+      "type": "string",
+      "description": "The combined markdown content of all chunks"
+    },
+    {
+      "name": "chunk_count",
+      "display_name": "Chunk Count",
+      "type": "number",
+      "description": "Number of chunks that were combined"
+    },
+    {
+      "name": "document_info",
+      "display_name": "Document Info",
+      "type": "object",
+      "description": "Information about the document (name, type, etc.)"
+    },
+    {
+      "name": "error",
+      "display_name": "Error",
+      "type": "string",
+      "description": "Error message if the operation failed"
+    }
+  ],
+  "settings": [],
+  "needs_key_from": ["openai"]
+}

package/nodes/combine-document-chunks/combine-document-chunks.process.js

@@ -0,0 +1,119 @@
+export default async ({inputs, settings, config, nodeConfig}) => {
+    try {
+        // Get knowledge base integration
+        const knowledgeBase = config.integrations?.knowledgeBase || config.integrations?.sqlite;
+        
+        if (!knowledgeBase) {
+            throw new Error("Knowledge base integration not found. Make sure a knowledge database is available.");
+        }
+
+        const { 
+            document_id,
+            include_metadata = false,
+            separator = "\n\n---\n\n"
+        } = inputs;
+
+        if (!document_id || typeof document_id !== 'string') {
+            throw new Error("Document ID is required and must be a string");
+        }
+
+        // First, get document information
+        const documentQuery = `
+            SELECT 
+                id,
+                display_name,
+                file_type,
+                file_size,
+                folder_path,
+                created_at,
+                updated_at
+            FROM documents
+            WHERE id = ?
+            LIMIT 1
+        `;
+
+        const documentResults = await knowledgeBase.select(documentQuery, [document_id]);
+        
+
+        if (!documentResults || (Array.isArray(documentResults) && documentResults.length === 0)) {
+            throw new Error(`Document with ID '${document_id}' not found`);
+        }
+
+        const documentInfo = Array.isArray(documentResults) ? documentResults[0] : documentResults;
+
+        // Get all chunks for the document, ordered by chunk_index
+        const chunksQuery = `
+            SELECT 
+                id,
+                chunk_index,
+                content,
+                token_count,
+                chunk_type,
+                metadata,
+                created_at
+            FROM chunks
+            WHERE document_id = ?
+            ORDER BY chunk_index ASC
+        `;
+
+        const chunks = await knowledgeBase.select(chunksQuery, [document_id]);
+
+        if (!chunks || chunks.length === 0) {
+            return {
+                content: "",
+                chunk_count: 0,
+                document_info: documentInfo,
+                error: null
+            };
+        }
+
+        // Combine chunks into markdown content
+        const combinedChunks = chunks.map((chunk, index) => {
+            let chunkContent = chunk.content;
+
+            // Add metadata if requested
+            if (include_metadata) {
+                let metadata = {};
+                if (chunk.metadata) {
+                    try {
+                        metadata = JSON.parse(chunk.metadata);
+                    } catch (error) {
+                        console.warn('[WARN] Failed to parse chunk metadata:', error.message);
+                    }
+                }
+
+                const metadataString = Object.keys(metadata).length > 0 
+                    ? `\n\n<!-- Metadata: ${JSON.stringify(metadata, null, 2)} -->`
+                    : '';
+
+                chunkContent = `## Chunk ${chunk.chunk_index}${metadataString}\n\n${chunkContent}`;
+            }
+
+            return chunkContent;
+        });
+
+        const combinedContent = combinedChunks.join(separator);
+        
+        // Add document header
+        const documentHeader = `# ${documentInfo.display_name}\n\n*Document ID: ${documentInfo.id}*\n*File Type: ${documentInfo.file_type}*\n*Chunks: ${chunks.length}*\n\n`;
+
+        const finalContent = documentHeader + combinedContent;
+
+        return {
+            content: finalContent,
+            chunk_count: chunks.length,
+            document_info: documentInfo,
+            error: null
+        };
+
+    } catch (error) {
+        console.error('Error in combine-document-chunks:', error);
+        // Return error information instead of throwing to prevent engine crash
+        return {
+            content: "",
+            chunk_count: 0,
+            document_info: null,
+            error: error.message
+        };
+    }
+};

package/nodes/combine-document-chunks/combine-document-chunks.tests.json

@@ -0,0 +1,51 @@
+[
+  {
+    "description": "Combine chunks for valid document",
+    "inputs": {
+      "document_id": "test-doc-1",
+      "include_metadata": false,
+      "separator": "\n\n---\n\n"
+    },
+    "expected": {
+      "chunk_count": 3,
+      "content": "# Test Document\n\n*Document ID: test-doc-1*\n*File Type: markdown*\n*Chunks: 3*\n\nThis is the first chunk.\n\n---\n\nThis is the second chunk.\n\n---\n\nThis is the third chunk."
+    }
+  },
+  {
+    "description": "Combine chunks with metadata",
+    "inputs": {
+      "document_id": "test-doc-1",
+      "include_metadata": true,
+      "separator": "\n\n---\n\n"
+    },
+    "expected": {
+      "chunk_count": 3,
+      "content": "# Test Document\n\n*Document ID: test-doc-1*\n*File Type: markdown*\n*Chunks: 3*\n\n## Chunk 0\n\nThis is the first chunk.\n\n---\n\n## Chunk 1\n\nThis is the second chunk.\n\n---\n\n## Chunk 2\n\nThis is the third chunk."
+    }
+  },
+  {
+    "description": "Combine chunks for non-existent document",
+    "inputs": {
+      "document_id": "non-existent-doc",
+      "include_metadata": false,
+      "separator": "\n\n---\n\n"
+    },
+    "expected": {
+      "chunk_count": 0,
+      "content": "",
+      "error": "Document with ID 'non-existent-doc' not found"
+    }
+  },
+  {
+    "description": "Combine chunks with custom separator",
+    "inputs": {
+      "document_id": "test-doc-1",
+      "include_metadata": false,
+      "separator": "\n\n***\n\n"
+    },
+    "expected": {
+      "chunk_count": 3,
+      "content": "# Test Document\n\n*Document ID: test-doc-1*\n*File Type: markdown*\n*Chunks: 3*\n\nThis is the first chunk.\n\n***\n\nThis is the second chunk.\n\n***\n\nThis is the third chunk."
+    }
+  }
+]

package/nodes/condition-check/condition-check.config.json

@@ -0,0 +1,38 @@
+{
+  "display_name": "Condition Check",
+  "tagline": "Check a condition",
+  "description": "Conditional pass-through that routes data to passed or blocked based on a condition",
+  "category": "logic",
+  "is_plugin": false,
+  "inputs": [
+    {
+      "name": "value",
+      "display_name": "Value",
+      "description": "The value to conditionally pass through",
+      "type": "any",
+      "required": true
+    },
+    {
+      "name": "condition",
+      "display_name": "Condition",
+      "description": "Boolean condition that determines if value passes through",
+      "type": "boolean",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "passed",
+      "display_name": "Passed",
+      "description": "Value when condition is true (null when false)",
+      "type": "any"
+    },
+    {
+      "name": "blocked",
+      "display_name": "Blocked",
+      "description": "Value when condition is false (null when true)",
+      "type": "any"
+    }
+  ],
+  "settings": []
+}

package/nodes/condition-check/condition-check.process.js

@@ -0,0 +1,16 @@
+export default async ({inputs, settings, config, nodeConfig}) => {
+  const value = inputs.value;
+  const condition = inputs.condition;
+  
+  if (condition) {
+    return {
+      passed: value,
+      blocked: null
+    };
+  } else {
+    return {
+      passed: null,
+      blocked: value
+    };
+  }
+};

package/nodes/condition-check/condition-check.tests.json

@@ -0,0 +1,112 @@
+[
+  {
+    "description": "True condition passes value through",
+    "inputs": {
+      "value": "test data",
+      "condition": true
+    },
+    "expected": {
+      "passed": "test data",
+      "blocked": null
+    }
+  },
+  {
+    "description": "False condition blocks value",
+    "inputs": {
+      "value": "test data",
+      "condition": false
+    },
+    "expected": {
+      "passed": null,
+      "blocked": "test data"
+    }
+  },
+  {
+    "description": "Object value passes through on true",
+    "inputs": {
+      "value": {"name": "Alice", "score": 95},
+      "condition": true
+    },
+    "expected": {
+      "passed": {"name": "Alice", "score": 95},
+      "blocked": null
+    }
+  },
+  {
+    "description": "Array value gets blocked on false",
+    "inputs": {
+      "value": ["item1", "item2", "item3"],
+      "condition": false
+    },
+    "expected": {
+      "passed": null,
+      "blocked": ["item1", "item2", "item3"]
+    }
+  },
+  {
+    "description": "Number value passes with truthy condition",
+    "inputs": {
+      "value": 100,
+      "condition": 1
+    },
+    "expected": {
+      "passed": 100,
+      "blocked": null
+    }
+  },
+  {
+    "description": "String value gets blocked with falsy condition",
+    "inputs": {
+      "value": "important message",
+      "condition": 0
+    },
+    "expected": {
+      "passed": null,
+      "blocked": "important message"
+    }
+  },
+  {
+    "description": "Null value passes through on true",
+    "inputs": {
+      "value": null,
+      "condition": true
+    },
+    "expected": {
+      "passed": null,
+      "blocked": null
+    }
+  },
+  {
+    "description": "Empty string gets blocked on false",
+    "inputs": {
+      "value": "",
+      "condition": false
+    },
+    "expected": {
+      "passed": null,
+      "blocked": ""
+    }
+  },
+  {
+    "description": "Boolean false value passes through on true",
+    "inputs": {
+      "value": false,
+      "condition": true
+    },
+    "expected": {
+      "passed": false,
+      "blocked": null
+    }
+  },
+  {
+    "description": "Zero value gets blocked on false",
+    "inputs": {
+      "value": 0,
+      "condition": false
+    },
+    "expected": {
+      "passed": null,
+      "blocked": 0
+    }
+  }
+]

package/nodes/confluence-get-page/confluence-get-page.config.json

@@ -0,0 +1,45 @@
+{
+  "display_name": "Confluence Get Page",
+  "tagline": "Get Confluence page by ID",
+  "description": "Retrieve a Confluence page by its ID, including content body.",
+  "icon": "file-text",
+  "category": "third-party",
+  "is_plugin": true,
+  "inputs": [
+    {
+      "name": "page_id",
+      "display_name": "Page ID",
+      "type": "string",
+      "description": "Confluence page ID",
+      "required": true
+    },
+    {
+      "name": "body_format",
+      "display_name": "Body Format",
+      "type": "string",
+      "description": "Format for page body: storage, atlas_doc_format, or view",
+      "required": false,
+      "default": "storage"
+    }
+  ],
+  "outputs": [
+    {
+      "name": "page",
+      "display_name": "Page",
+      "type": "object",
+      "description": "The page object"
+    },
+    {
+      "name": "title",
+      "display_name": "Title",
+      "type": "string",
+      "description": "Page title"
+    },
+    {
+      "name": "body",
+      "display_name": "Body",
+      "type": "string",
+      "description": "Page body content in the requested format"
+    }
+  ]
+}

package/nodes/confluence-get-page/confluence-get-page.process.js

@@ -0,0 +1,22 @@
+export default async ({ inputs, settings, config }) => {
+  const confluence = config.integrations?.confluence;
+  if (!confluence) {
+    throw new Error("Confluence integration not configured. Add your Confluence config to config.keys.confluence ({email, api_token, domain})");
+  }
+
+  if (!inputs.page_id) throw new Error("page_id is required");
+
+  const page = await confluence.getPage(inputs.page_id, {
+    bodyFormat: inputs.body_format || 'storage',
+  });
+
+  // Extract body from the format-specific key
+  const format = inputs.body_format || 'storage';
+  const bodyContent = page.body?.[format]?.value || page.body?.[format]?.representation || '';
+
+  return {
+    page,
+    title: page.title || '',
+    body: bodyContent,
+  };
+};

package/nodes/confluence-get-page/confluence-get-page.tests.json

@@ -0,0 +1,12 @@
+[
+  {
+    "description": "Get page by ID",
+    "inputs": {
+      "page_id": "${CONFLUENCE_TEST_PAGE_ID}"
+    },
+    "expected": {
+      "title": "string",
+      "body": "string"
+    }
+  }
+]