@zerowidth/workbench-sdk 2.0.0-alpha.0

package/src/integrations/pinecone.js

@@ -0,0 +1,80 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class PineconeIntegration {
+    constructor(config, options = {}) {
+        if (typeof config === 'object') {
+            this.apiKey = config.api_key || config.key;
+            this.host = config.host; // e.g. https://my-index-abc123.svc.environment.pinecone.io
+        } else {
+            this.apiKey = config;
+            this.host = options.host;
+        }
+        this.options = {
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    async _request(config) {
+        const requestHeaders = { 'Api-Key': this.apiKey, 'Content-Type': 'application/json', ...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: 'pinecone', 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: 'pinecone', 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 msg = error.response.data?.message || error.response.statusText;
+                throw new Error(`Pinecone API error (${error.response.status}): ${msg}`);
+            }
+            throw new Error(`Pinecone API error: ${error.message}`);
+        }
+    }
+
+    async query(vector, options = {}) {
+        const data = {
+            vector,
+            topK: options.top_k || 10,
+            includeMetadata: options.include_metadata !== false,
+            includeValues: options.include_values || false
+        };
+        if (options.namespace) data.namespace = options.namespace;
+        if (options.filter) data.filter = options.filter;
+
+        return await this._request({
+            method: 'POST',
+            url: `${this.host}/query`,
+            data
+        });
+    }
+
+    async upsert(vectors, namespace = null) {
+        const data = { vectors };
+        if (namespace) data.namespace = namespace;
+
+        return await this._request({
+            method: 'POST',
+            url: `${this.host}/vectors/upsert`,
+            data
+        });
+    }
+}

package/src/integrations/resend.js

@@ -0,0 +1,76 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class ResendIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://api.resend.com',
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    async _request(config) {
+        const requestHeaders = { 'Authorization': `Bearer ${this.apiKey}`, 'Content-Type': 'application/json', ...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: 'resend', 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: 'resend', 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 msg = error.response.data?.message || error.response.statusText;
+                throw new Error(`Resend API error (${error.response.status}): ${msg}`);
+            }
+            throw new Error(`Resend API error: ${error.message}`);
+        }
+    }
+
+    async sendEmail(params) {
+        const { to, from, subject, text, html, replyTo, cc, bcc } = params;
+
+        const data = { from, subject };
+
+        // to can be string or array
+        data.to = typeof to === 'string' ? to.split(',').map(e => e.trim()) : to;
+
+        if (cc) {
+            data.cc = typeof cc === 'string' ? cc.split(',').map(e => e.trim()) : cc;
+        }
+        if (bcc) {
+            data.bcc = typeof bcc === 'string' ? bcc.split(',').map(e => e.trim()) : bcc;
+        }
+        if (text) data.text = text;
+        if (html) data.html = html;
+        if (replyTo) data.reply_to = replyTo;
+
+        if (!text && !html) {
+            throw new Error('Either text or html content is required');
+        }
+
+        return await this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/emails`,
+            data
+        });
+    }
+}

package/src/integrations/sendgrid.js

@@ -0,0 +1,118 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class SendGridIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://api.sendgrid.com/v3',
+            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', ...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: 'sendgrid', 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: 'sendgrid', 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 status = error.response.status;
+                const errors = error.response.data?.errors;
+                const errorMessage = errors && errors.length > 0
+                    ? errors.map(e => e.message).join('; ')
+                    : error.response.statusText;
+                throw new Error(`SendGrid API error (${status}): ${errorMessage}`);
+            } else if (error.request) {
+                throw new Error('SendGrid API error: No response received');
+            } else {
+                throw new Error(`SendGrid API error: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Send an email using the SendGrid Mail Send API
+     * @param {Object} params - Email parameters
+     * @param {string} params.to - Recipient email address(es), comma-separated for multiple
+     * @param {string} params.from - Sender email address
+     * @param {string} [params.fromName] - Sender display name
+     * @param {string} params.subject - Email subject
+     * @param {string} [params.text] - Plain text body
+     * @param {string} [params.html] - HTML body
+     * @param {string} [params.replyTo] - Reply-to email address
+     * @param {Array} [params.cc] - CC email addresses
+     * @param {Array} [params.bcc] - BCC email addresses
+     * @returns {Promise<Object>} Response with status
+     */
+    async sendEmail(params) {
+        const { to, from, fromName, subject, text, html, replyTo, cc, bcc } = params;
+
+        // Build personalizations
+        const toAddresses = (typeof to === 'string' ? to.split(',') : to).map(email => ({ email: email.trim() }));
+        const personalization = { to: toAddresses };
+
+        if (cc && cc.length > 0) {
+            personalization.cc = (typeof cc === 'string' ? cc.split(',') : cc).map(email => ({ email: email.trim() }));
+        }
+        if (bcc && bcc.length > 0) {
+            personalization.bcc = (typeof bcc === 'string' ? bcc.split(',') : bcc).map(email => ({ email: email.trim() }));
+        }
+
+        // Build content
+        const content = [];
+        if (text) {
+            content.push({ type: 'text/plain', value: text });
+        }
+        if (html) {
+            content.push({ type: 'text/html', value: html });
+        }
+        if (content.length === 0) {
+            throw new Error('Either text or html content is required');
+        }
+
+        // Build request body
+        const data = {
+            personalizations: [personalization],
+            from: fromName ? { email: from, name: fromName } : { email: from },
+            subject,
+            content
+        };
+
+        if (replyTo) {
+            data.reply_to = { email: replyTo };
+        }
+
+        return await this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/mail/send`,
+            data
+        });
+    }
+}

package/src/integrations/slack.js

@@ -0,0 +1,70 @@
+import axios from 'axios';
+import { emitAPICallEvent } from '../utilities/sanitizeAPICall.js';
+
+export default class SlackIntegration {
+    constructor(apiKey, options = {}) {
+        this.apiKey = apiKey;
+        this.options = {
+            baseURL: 'https://slack.com/api',
+            timeout: 30000,
+            ...options
+        };
+    }
+
+    async _request(config) {
+        const requestHeaders = { 'Authorization': `Bearer ${this.apiKey}`, 'Content-Type': 'application/json', ...config.headers };
+        const startTime = Date.now();
+
+        try {
+            const response = await axios({
+                ...config,
+                headers: requestHeaders,
+                timeout: this.options.timeout
+            });
+
+            // Slack returns 200 even on errors, check ok field
+            const slackError = response.data && response.data.ok === false ? response.data.error : null;
+
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'slack', 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: slackError
+            });
+
+            if (slackError) {
+                throw new Error(`Slack API error: ${slackError}`);
+            }
+
+            return response.data;
+        } catch (error) {
+            if (error.message?.startsWith('Slack API error')) {
+                throw error;
+            }
+            await emitAPICallEvent(this._engineConfig, {
+                timestamp: startTime, integration: 'slack', 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) {
+                throw new Error(`Slack API error (${error.response.status}): ${error.response.statusText}`);
+            }
+            throw new Error(`Slack API error: ${error.message}`);
+        }
+    }
+
+    async postMessage(channel, text, options = {}) {
+        const data = { channel, text };
+        if (options.thread_ts) data.thread_ts = options.thread_ts;
+        if (options.blocks) data.blocks = options.blocks;
+        if (options.unfurl_links !== undefined) data.unfurl_links = options.unfurl_links;
+        if (options.unfurl_media !== undefined) data.unfurl_media = options.unfurl_media;
+
+        return await this._request({
+            method: 'POST',
+            url: `${this.options.baseURL}/chat.postMessage`,
+            data
+        });
+    }
+}