@zerowidth/workbench-sdk 2.0.0-alpha.0

package/src/integrations/newsdata_io.js

@@ -0,0 +1,201 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class NewsDataIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://newsdata.io/api/1',
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    /**
+     * Make a request to any NewsData.io endpoint
+     * @param {string} endpoint - The endpoint path (e.g., 'latest', 'archive', 'crypto', 'news', 'sources')
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} API response
+     */
+    async request(endpoint, params = {}) {
+        try {
+            const url = `${this.options.baseURL}/${endpoint}`;
+
+            // remove any params that are just empty strings
+            Object.keys(params).forEach(key => {
+              if (params[key] === '') {
+                delete params[key];
+              }
+              if (params[key] === null) {
+                delete params[key];
+              }
+              if (params[key] === undefined) {
+                delete params[key];
+              }
+              if (params[key] === false) {
+                delete params[key];
+              }
+              if (Array.isArray(params[key]) && params[key].length === 0) {
+                delete params[key];
+              }
+
+              // change any params that are true to 1
+              if (params[key] === true) {
+                params[key] = 1;
+              }
+
+            });
+
+
+            const queryParams = { apikey: this.apiKey, ...params };
+            const startTime = Date.now();
+            const fullUrl = `${url}?${new URLSearchParams(queryParams).toString()}`;
+
+            const response = await axios({
+                url: url,
+                method: 'GET',
+                params: queryParams,
+                timeout: this.options.timeout
+            });
+
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'newsdata_io', nodeId: null, nodeType: null,
+                request: { method: 'GET', url: fullUrl, headers: {}, body: null },
+                response: { status: response.status, statusText: response.statusText },
+                duration: Date.now() - startTime, error: null
+            });
+
+            if (response.status >= 400) {
+                throw new Error(`NewsData API error: ${response.status} - ${response.data?.message || response.statusText}`);
+            }
+
+            return response.data;
+
+        } catch (error) {
+            if (error.response) {
+                const status = error.response.status;
+                const statusText = error.response.statusText;
+                const responseData = error.response.data;
+                
+                let errorMessage = `NewsData API Error (${status} ${statusText})`;
+                if (responseData?.message) {
+                    errorMessage += `: ${responseData.message}`;
+                }
+                
+                throw new Error(errorMessage);
+            } else if (error.request) {
+                throw new Error('NewsData API Error: No response received');
+            } else {
+                throw new Error(`NewsData API Error: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Get latest news from the last 48 hours
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} Latest news response
+     */
+    async getLatest(params = {}) {
+        return await this.request('latest', params);
+    }
+
+    /**
+     * Get historical news from archive
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} Archive news response
+     */
+    async getArchive(params = {}) {
+        return await this.request('archive', params);
+    }
+
+    /**
+     * Get breaking/real-time news
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} Breaking news response
+     */
+    async getBreaking(params = {}) {
+        return await this.request('news', params);
+    }
+
+    /**
+     * Get crypto-specific news
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} Crypto news response
+     */
+    async getCrypto(params = {}) {
+        return await this.request('crypto', params);
+    }
+
+    /**
+     * Get list of source domains
+     * @param {Object} params - Query parameters
+     * @returns {Promise<Object>} Sources response
+     */
+    async getSources(params = {}) {
+        return await this.request('sources', params);
+    }
+
+    /**
+     * Helper function to convert comma-separated string to array
+     * @param {string|Array} input - String or array input
+     * @returns {Array} Array of strings
+     */
+    static stringToArray(input) {
+        if (Array.isArray(input)) {
+            return input;
+        }
+        if (typeof input === 'string') {
+            return input.split(',').map(item => item.trim()).filter(item => item.length > 0);
+        }
+        return [];
+    }
+
+    /**
+     * Helper function to build query parameters with array handling
+     * @param {Object} params - Raw parameters
+     * @returns {Object} Processed parameters
+     */
+    static processParams(params) {
+        const processed = { ...params };
+        
+        // Handle parameter name mappings (snake_case input names to API parameter names)
+        const paramMappings = {
+            'categories': 'category',
+            'exclude_categories': 'excludecategory',
+            'countries': 'country',
+            'regions': 'region',
+            'languages': 'language',
+            'domains': 'domain',
+            'exclude_domains': 'excludedomain',
+            'exclude_fields': 'excludefield',
+            'coins': 'coin'
+        };
+        
+        // Apply parameter name mappings
+        Object.entries(paramMappings).forEach(([inputKey, apiKey]) => {
+            if (processed[inputKey] !== undefined) {
+                processed[apiKey] = processed[inputKey];
+                delete processed[inputKey]; // Remove the old key
+            }
+        });
+        
+        // Fields that should be converted from comma-separated strings to arrays
+        const arrayFields = [
+            'country', 'region', 'category', 'excludecategory',
+            'language', 'domain', 'excludedomain', 'excludefield',
+            'coin'
+        ];
+
+        arrayFields.forEach(field => {
+            if (processed[field] !== undefined) {
+                const arrayValue = this.stringToArray(processed[field]);
+                if (arrayValue.length > 0) {
+                    processed[field] = arrayValue.join(',');
+                }
+            }
+        });
+
+        return processed;
+    }
+}

package/src/integrations/notion.js

@@ -0,0 +1,208 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+// Current Notion API version
+const NOTION_VERSION = '2022-06-28';
+
+export default class NotionIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://api.notion.com/v1',
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    /**
+     * Make an API request with error handling
+     * @param {Object} config - Axios request config
+     * @returns {Promise<Object>} Response data
+     */
+    async _request(config) {
+        const requestHeaders = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'Notion-Version': NOTION_VERSION,
+            ...config.headers
+        };
+        const startTime = Date.now();
+
+        try {
+            const response = await axios({
+                ...config,
+                headers: requestHeaders,
+                timeout: this.options.timeout
+            });
+
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'notion', nodeId: null, nodeType: null,
+                request: { method: config.method, url: config.url, headers: requestHeaders, body: config.data || null },
+                response: { status: response.status, statusText: response.statusText },
+                duration: Date.now() - startTime, error: null
+            });
+
+            return response.data;
+        } catch (error) {
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'notion', nodeId: null, nodeType: null,
+                request: { method: config.method, url: config.url, headers: requestHeaders, body: config.data || null },
+                response: { status: error.response?.status || 0, statusText: error.response?.statusText || 'Error' },
+                duration: Date.now() - startTime, error: error.message
+            });
+
+            if (error.response) {
+                const errorBody = JSON.stringify(error.response.data);
+                throw new Error(`Notion API error (${error.response.status}): ${errorBody}`);
+            }
+            throw new Error(`Notion request error: ${error.message}`);
+        }
+    }
+
+    /**
+     * Query a database
+     * @param {string} databaseId - The database ID
+     * @param {Object} options - Query options
+     * @returns {Promise<Object>} Query results
+     */
+    async queryDatabase(databaseId, options = {}) {
+        const body = {};
+        if (options.filter) body.filter = options.filter;
+        if (options.sorts) body.sorts = options.sorts;
+        if (options.startCursor) body.start_cursor = options.startCursor;
+        if (options.pageSize) body.page_size = Math.min(options.pageSize, 100);
+
+        return this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/databases/${databaseId}/query`,
+            data: body
+        });
+    }
+
+    /**
+     * Retrieve a page by ID
+     * @param {string} pageId - The page ID
+     * @returns {Promise<Object>} Page object
+     */
+    async getPage(pageId) {
+        return this._request({
+            method: 'GET',
+            url: `${this.options.baseURL}/pages/${pageId}`
+        });
+    }
+
+    /**
+     * Create a new page
+     * @param {Object} parent - Parent object (database_id or page_id)
+     * @param {Object} properties - Page properties
+     * @param {Object} options - Additional options
+     * @returns {Promise<Object>} Created page
+     */
+    async createPage(parent, properties, options = {}) {
+        const body = {
+            parent,
+            properties
+        };
+        if (options.children) body.children = options.children;
+        if (options.icon) body.icon = options.icon;
+        if (options.cover) body.cover = options.cover;
+
+        return this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/pages`,
+            data: body
+        });
+    }
+
+    /**
+     * Update a page's properties
+     * @param {string} pageId - The page ID
+     * @param {Object} properties - Properties to update
+     * @param {Object} options - Additional options
+     * @returns {Promise<Object>} Updated page
+     */
+    async updatePage(pageId, properties, options = {}) {
+        const body = {};
+        if (properties) body.properties = properties;
+        if (options.icon) body.icon = options.icon;
+        if (options.cover) body.cover = options.cover;
+
+        return this._request({
+            method: 'PATCH',
+            url: `${this.options.baseURL}/pages/${pageId}`,
+            data: body
+        });
+    }
+
+    /**
+     * Archive or restore a page
+     * @param {string} pageId - The page ID
+     * @param {boolean} archived - True to archive, false to restore
+     * @returns {Promise<Object>} Updated page
+     */
+    async archivePage(pageId, archived = true) {
+        return this._request({
+            method: 'PATCH',
+            url: `${this.options.baseURL}/pages/${pageId}`,
+            data: { archived }
+        });
+    }
+
+    /**
+     * Get children blocks of a block or page
+     * @param {string} blockId - The block or page ID
+     * @param {Object} options - Pagination options
+     * @returns {Promise<Object>} Block children
+     */
+    async getBlockChildren(blockId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.startCursor) params.append('start_cursor', options.startCursor);
+        if (options.pageSize) params.append('page_size', Math.min(options.pageSize, 100));
+
+        const queryString = params.toString();
+        const url = `${this.options.baseURL}/blocks/${blockId}/children${queryString ? '?' + queryString : ''}`;
+
+        return this._request({
+            method: 'GET',
+            url
+        });
+    }
+
+    /**
+     * Append children blocks to a block or page
+     * @param {string} blockId - The block or page ID
+     * @param {Array} children - Block objects to append
+     * @param {Object} options - Additional options
+     * @returns {Promise<Object>} Appended blocks
+     */
+    async appendBlockChildren(blockId, children, options = {}) {
+        const body = { children };
+        if (options.after) body.after = options.after;
+
+        return this._request({
+            method: 'PATCH',
+            url: `${this.options.baseURL}/blocks/${blockId}/children`,
+            data: body
+        });
+    }
+
+    /**
+     * Search pages and databases
+     * @param {Object} options - Search options
+     * @returns {Promise<Object>} Search results
+     */
+    async search(options = {}) {
+        const body = {};
+        if (options.query) body.query = options.query;
+        if (options.filter) body.filter = options.filter;
+        if (options.sort) body.sort = options.sort;
+        if (options.startCursor) body.start_cursor = options.startCursor;
+        if (options.pageSize) body.page_size = Math.min(options.pageSize, 100);
+
+        return this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/search`,
+            data: body
+        });
+    }
+}

package/src/integrations/openai.js

@@ -0,0 +1,185 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class OpenAIIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://api.openai.com/v1',
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    /**
+     * Create embeddings for text using OpenAI's embedding models
+     * @param {string|Array} input - Text or array of texts to embed
+     * @param {string} model - Embedding model to use (default: text-embedding-3-small)
+     * @returns {Promise<Object>} Embedding response
+     */
+    async createEmbedding(input, model = 'text-embedding-3-small') {
+        const requestUrl = `${this.options.baseURL}/embeddings`;
+        const requestHeaders = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` };
+        const requestBody = { model, input };
+        const startTime = Date.now();
+
+        try {
+            const response = await axios({
+                url: requestUrl,
+                method: 'POST',
+                headers: requestHeaders,
+                data: requestBody,
+                timeout: this.options.timeout,
+                signal: this._engineConfig?.signal
+            });
+
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'openai', nodeId: null, nodeType: null,
+                request: { method: 'POST', url: requestUrl, headers: requestHeaders, body: requestBody },
+                response: { status: response.status, statusText: response.statusText },
+                duration: Date.now() - startTime, error: null
+            });
+
+            if (response.status >= 400) {
+                throw new Error(`OpenAI API error: ${response.status} - ${response.data?.error?.message || response.statusText}`);
+            }
+
+            return {
+                data: response.data.data,
+                model: response.data.model,
+                usage: response.data.usage
+            };
+
+        } catch (error) {
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'openai', nodeId: null, nodeType: null,
+                request: { method: 'POST', url: requestUrl, headers: requestHeaders, body: requestBody },
+                response: { status: error.response?.status || 0, statusText: error.response?.statusText || 'Error' },
+                duration: Date.now() - startTime, error: error.message
+            });
+            if (error.response) {
+                const status = error.response.status;
+                const statusText = error.response.statusText;
+                const responseData = error.response.data;
+                
+                let errorMessage = `OpenAI Embeddings API Error (${status} ${statusText})`;
+                if (responseData?.error?.message) {
+                    errorMessage += `: ${responseData.error.message}`;
+                }
+                
+                throw new Error(errorMessage);
+            } else if (error.request) {
+                throw new Error('OpenAI Embeddings API Error: No response received');
+            } else {
+                throw new Error(`OpenAI Embeddings API Error: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Moderate content using OpenAI's moderation API
+     * @param {string|Array|Object} input - Content to moderate
+     * @returns {Promise<Object>} Moderation results
+     */
+    async moderateContent(input) {
+        try {
+            // Extract content from Message object or use input directly
+            let moderationInput = input;
+            
+            // Handle Message object with {role, content} structure
+            if (input && typeof input === 'object' && !Array.isArray(input) && input.content !== undefined) {
+                moderationInput = input.content;
+            }
+            
+            // If it's a string, use it directly
+            // If it's an array, use it as-is (should be multi-modal format)
+            if (typeof moderationInput === 'string') {
+                moderationInput = moderationInput;
+            } else if (Array.isArray(moderationInput)) {
+                moderationInput = moderationInput;
+            } else {
+                // Convert single object to array
+                moderationInput = [moderationInput];
+            }
+
+            const modRequestUrl = `${this.options.baseURL}/moderations`;
+            const modRequestHeaders = { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` };
+            const modRequestBody = { model: 'omni-moderation-latest', input: moderationInput };
+            const modStartTime = Date.now();
+
+            const response = await axios({
+                url: modRequestUrl,
+                method: 'POST',
+                headers: modRequestHeaders,
+                data: modRequestBody,
+                timeout: this.options.timeout,
+                signal: this._engineConfig?.signal,
+                validateStatus: () => true // Always resolve, never throw for HTTP errors
+            });
+
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: modStartTime, integration: 'openai', nodeId: null, nodeType: null,
+                request: { method: 'POST', url: modRequestUrl, headers: modRequestHeaders, body: modRequestBody },
+                response: { status: response.status, statusText: response.statusText },
+                duration: Date.now() - modStartTime, error: null
+            });
+
+            if (response.status >= 400) {
+                throw new Error(`OpenAI Moderation API error: ${response.status} - ${response.data?.error?.message || response.statusText}`);
+            }
+
+            // Extract the first result (API returns array of results)
+            const result = response.data.results && response.data.results[0] ? response.data.results[0] : {};
+            const categories = result.categories || {};
+            const categoryScores = result.category_scores || {};
+
+            return {
+                flagged: result.flagged || false,
+                sexual: categories.sexual || false,
+                sexual_score: categoryScores.sexual || 0,
+                sexual_minors: categories['sexual/minors'] || false,
+                sexual_minors_score: categoryScores['sexual/minors'] || 0,
+                harassment: categories.harassment || false,
+                harassment_score: categoryScores.harassment || 0,
+                harassment_threatening: categories['harassment/threatening'] || false,
+                harassment_threatening_score: categoryScores['harassment/threatening'] || 0,
+                hate: categories.hate || false,
+                hate_score: categoryScores.hate || 0,
+                hate_threatening: categories['hate/threatening'] || false,
+                hate_threatening_score: categoryScores['hate/threatening'] || 0,
+                illicit: categories.illicit || false,
+                illicit_score: categoryScores.illicit || 0,
+                illicit_violent: categories['illicit/violent'] || false,
+                illicit_violent_score: categoryScores['illicit/violent'] || 0,
+                self_harm: categories['self-harm'] || false,
+                self_harm_score: categoryScores['self-harm'] || 0,
+                self_harm_intent: categories['self-harm/intent'] || false,
+                self_harm_intent_score: categoryScores['self-harm/intent'] || 0,
+                self_harm_instructions: categories['self-harm/instructions'] || false,
+                self_harm_instructions_score: categoryScores['self-harm/instructions'] || 0,
+                violence: categories.violence || false,
+                violence_score: categoryScores.violence || 0,
+                violence_graphic: categories['violence/graphic'] || false,
+                violence_graphic_score: categoryScores['violence/graphic'] || 0
+            };
+
+        } catch (error) {
+            if (error.response) {
+                const status = error.response.status;
+                const statusText = error.response.statusText;
+                const responseData = error.response.data;
+                
+                let errorMessage = `OpenAI Moderation API Error (${status} ${statusText})`;
+                if (responseData?.error?.message) {
+                    errorMessage += `: ${responseData.error.message}`;
+                }
+                
+                throw new Error(errorMessage);
+            } else if (error.request) {
+                throw new Error('OpenAI Moderation API Error: No response received');
+            } else {
+                throw new Error(`OpenAI Moderation API Error: ${error.message}`);
+            }
+        }
+    }
+}