overai 1.4.0

package/dist/integrations/slack.js

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Slack Integration
+ *
+ * Provides Slack bot adapters for building AI-powered Slack bots.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackBot = void 0;
+exports.createSlackBot = createSlackBot;
+exports.verifySlackSignature = verifySlackSignature;
+exports.parseSlackMessage = parseSlackMessage;
+/**
+ * Create a Slack bot adapter.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createSlackBot } from 'praisonai/integrations/slack';
+ * import { Agent } from 'praisonai';
+ *
+ * const agent = new Agent({ instructions: 'You are a helpful Slack bot' });
+ *
+ * const bot = createSlackBot({
+ *   botToken: process.env.SLACK_BOT_TOKEN!,
+ *   signingSecret: process.env.SLACK_SIGNING_SECRET!
+ * });
+ *
+ * bot.onMessage(async (message) => {
+ *   const response = await agent.chat(message.text);
+ *   return { text: response, threadTs: message.ts };
+ * });
+ *
+ * // Start webhook server
+ * bot.listen(3000);
+ * ```
+ *
+ * @example With Socket Mode
+ * ```typescript
+ * const bot = createSlackBot({
+ *   botToken: process.env.SLACK_BOT_TOKEN!,
+ *   appToken: process.env.SLACK_APP_TOKEN!,
+ *   socketMode: true
+ * });
+ *
+ * bot.onMessage(async (message) => {
+ *   return { text: 'Hello!' };
+ * });
+ *
+ * await bot.start();
+ * ```
+ */
+function createSlackBot(config) {
+    return new SlackBot(config);
+}
+class SlackBot {
+    constructor(config) {
+        this.boltApp = null;
+        this.config = config;
+    }
+    /**
+     * Set the message handler.
+     */
+    onMessage(handler) {
+        this.messageHandler = handler;
+        return this;
+    }
+    /**
+     * Set the app mention handler.
+     */
+    onAppMention(handler) {
+        this.mentionHandler = handler;
+        return this;
+    }
+    /**
+     * Set the reaction handler.
+     */
+    onReactionAdded(handler) {
+        this.reactionHandler = handler;
+        return this;
+    }
+    /**
+     * Initialize the Bolt app (lazy load).
+     */
+    async initBolt() {
+        if (this.boltApp)
+            return this.boltApp;
+        try {
+            // @ts-ignore - Optional dependency
+            const { App } = await Promise.resolve().then(() => __importStar(require('@slack/bolt')));
+            this.boltApp = new App({
+                token: this.config.botToken,
+                signingSecret: this.config.signingSecret,
+                appToken: this.config.appToken,
+                socketMode: this.config.socketMode,
+            });
+            // Register message handler
+            if (this.messageHandler) {
+                this.boltApp.message(async ({ message, say }) => {
+                    // Skip bot messages
+                    if (message.bot_id)
+                        return;
+                    const slackMessage = {
+                        channel: message.channel,
+                        user: message.user,
+                        text: message.text || '',
+                        threadTs: message.thread_ts,
+                        ts: message.ts,
+                    };
+                    const response = await this.messageHandler(slackMessage);
+                    if (response) {
+                        await say({
+                            text: response.text,
+                            blocks: response.blocks,
+                            thread_ts: response.threadTs || message.ts,
+                            unfurl_links: response.unfurlLinks,
+                            unfurl_media: response.unfurlMedia,
+                        });
+                    }
+                });
+            }
+            // Register app mention handler
+            if (this.mentionHandler) {
+                this.boltApp.event('app_mention', async ({ event, say }) => {
+                    const slackMessage = {
+                        channel: event.channel,
+                        user: event.user,
+                        text: event.text || '',
+                        threadTs: event.thread_ts,
+                        ts: event.ts,
+                    };
+                    const response = await this.mentionHandler(slackMessage);
+                    if (response) {
+                        await say({
+                            text: response.text,
+                            blocks: response.blocks,
+                            thread_ts: response.threadTs || event.ts,
+                        });
+                    }
+                });
+            }
+            // Register reaction handler
+            if (this.reactionHandler) {
+                this.boltApp.event('reaction_added', async ({ event }) => {
+                    await this.reactionHandler(event);
+                });
+            }
+            return this.boltApp;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize Slack Bolt: ${error.message}. ` +
+                'Install with: npm install @slack/bolt');
+        }
+    }
+    /**
+     * Start the bot (Socket Mode).
+     */
+    async start() {
+        const app = await this.initBolt();
+        await app.start();
+        console.log('⚡️ Slack bot is running in Socket Mode');
+    }
+    /**
+     * Start webhook server.
+     */
+    async listen(port = 3000) {
+        const app = await this.initBolt();
+        await app.start(port);
+        console.log(`⚡️ Slack bot is running on port ${port}`);
+    }
+    /**
+     * Stop the bot.
+     */
+    async stop() {
+        if (this.boltApp) {
+            await this.boltApp.stop();
+        }
+    }
+    /**
+     * Send a message to a channel.
+     */
+    async sendMessage(channel, text, options) {
+        const app = await this.initBolt();
+        await app.client.chat.postMessage({
+            token: this.config.botToken,
+            channel,
+            text,
+            blocks: options?.blocks,
+            thread_ts: options?.threadTs,
+            unfurl_links: options?.unfurlLinks,
+            unfurl_media: options?.unfurlMedia,
+        });
+    }
+    /**
+     * Get an Express middleware for webhook handling.
+     */
+    getExpressMiddleware() {
+        return async (req, res, next) => {
+            const app = await this.initBolt();
+            return app.receiver.app(req, res, next);
+        };
+    }
+}
+exports.SlackBot = SlackBot;
+/**
+ * Verify Slack request signature.
+ */
+function verifySlackSignature(signingSecret, signature, timestamp, body) {
+    const crypto = require('crypto');
+    const baseString = `v0:${timestamp}:${body}`;
+    const hmac = crypto.createHmac('sha256', signingSecret);
+    hmac.update(baseString);
+    const computedSignature = `v0=${hmac.digest('hex')}`;
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(computedSignature));
+}
+/**
+ * Parse Slack message text to extract mentions and links.
+ */
+function parseSlackMessage(text) {
+    const mentions = [];
+    const links = [];
+    // Extract user mentions <@U123456>
+    const mentionRegex = /<@([A-Z0-9]+)>/g;
+    let match;
+    while ((match = mentionRegex.exec(text)) !== null) {
+        mentions.push(match[1]);
+    }
+    // Extract links <http://...|label>
+    const linkRegex = /<(https?:\/\/[^|>]+)(?:\|[^>]+)?>/g;
+    while ((match = linkRegex.exec(text)) !== null) {
+        links.push(match[1]);
+    }
+    // Clean text (remove mentions and format links)
+    const cleanText = text
+        .replace(/<@[A-Z0-9]+>/g, '')
+        .replace(/<(https?:\/\/[^|>]+)(?:\|([^>]+))?>/g, '$2 ($1)')
+        .trim();
+    return { mentions, links, cleanText };
+}

package/dist/integrations/vector/base.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Base Vector Store - Abstract class for vector database integrations
+ * Matches mastra's MastraVector pattern
+ */
+export interface VectorDocument {
+    id: string;
+    vector: number[];
+    metadata?: Record<string, any>;
+    content?: string;
+}
+export interface QueryResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+    content?: string;
+    vector?: number[];
+}
+export interface IndexStats {
+    dimension: number;
+    count: number;
+    metric: 'cosine' | 'euclidean' | 'dotProduct';
+}
+export interface CreateIndexParams {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotProduct';
+}
+export interface UpsertParams {
+    indexName: string;
+    vectors: VectorDocument[];
+}
+export interface QueryParams {
+    indexName: string;
+    vector: number[];
+    topK?: number;
+    filter?: Record<string, any>;
+    includeMetadata?: boolean;
+    includeVectors?: boolean;
+}
+export interface DeleteParams {
+    indexName: string;
+    ids?: string[];
+    filter?: Record<string, any>;
+}
+/**
+ * Abstract base class for vector store implementations
+ */
+export declare abstract class BaseVectorStore {
+    readonly id: string;
+    readonly name: string;
+    constructor(config: {
+        id: string;
+        name?: string;
+    });
+    /**
+     * Create a new index
+     */
+    abstract createIndex(params: CreateIndexParams): Promise<void>;
+    /**
+     * List all indexes
+     */
+    abstract listIndexes(): Promise<string[]>;
+    /**
+     * Get index statistics
+     */
+    abstract describeIndex(indexName: string): Promise<IndexStats>;
+    /**
+     * Delete an index
+     */
+    abstract deleteIndex(indexName: string): Promise<void>;
+    /**
+     * Upsert vectors into an index
+     */
+    abstract upsert(params: UpsertParams): Promise<string[]>;
+    /**
+     * Query vectors by similarity
+     */
+    abstract query(params: QueryParams): Promise<QueryResult[]>;
+    /**
+     * Delete vectors by ID or filter
+     */
+    abstract delete(params: DeleteParams): Promise<void>;
+    /**
+     * Update vector metadata
+     */
+    abstract update(indexName: string, id: string, metadata: Record<string, any>): Promise<void>;
+}
+/**
+ * In-memory vector store for testing and development
+ */
+export declare class MemoryVectorStore extends BaseVectorStore {
+    private indexes;
+    constructor(config?: {
+        id: string;
+    });
+    createIndex(params: CreateIndexParams): Promise<void>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+    upsert(params: UpsertParams): Promise<string[]>;
+    query(params: QueryParams): Promise<QueryResult[]>;
+    delete(params: DeleteParams): Promise<void>;
+    update(indexName: string, id: string, metadata: Record<string, any>): Promise<void>;
+    private calculateSimilarity;
+    private cosineSimilarity;
+    private euclideanDistance;
+    private dotProduct;
+    private matchesFilter;
+}
+export declare function createMemoryVectorStore(id?: string): MemoryVectorStore;

package/dist/integrations/vector/base.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Base Vector Store - Abstract class for vector database integrations
+ * Matches mastra's MastraVector pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryVectorStore = exports.BaseVectorStore = void 0;
+exports.createMemoryVectorStore = createMemoryVectorStore;
+/**
+ * Abstract base class for vector store implementations
+ */
+class BaseVectorStore {
+    constructor(config) {
+        this.id = config.id;
+        this.name = config.name || 'VectorStore';
+    }
+}
+exports.BaseVectorStore = BaseVectorStore;
+/**
+ * In-memory vector store for testing and development
+ */
+class MemoryVectorStore extends BaseVectorStore {
+    constructor(config = { id: 'memory' }) {
+        super({ ...config, name: 'MemoryVectorStore' });
+        this.indexes = new Map();
+    }
+    async createIndex(params) {
+        if (this.indexes.has(params.indexName)) {
+            return; // Index already exists
+        }
+        this.indexes.set(params.indexName, {
+            dimension: params.dimension,
+            metric: params.metric || 'cosine',
+            vectors: new Map()
+        });
+    }
+    async listIndexes() {
+        return Array.from(this.indexes.keys());
+    }
+    async describeIndex(indexName) {
+        const index = this.indexes.get(indexName);
+        if (!index) {
+            throw new Error(`Index ${indexName} not found`);
+        }
+        return {
+            dimension: index.dimension,
+            count: index.vectors.size,
+            metric: index.metric
+        };
+    }
+    async deleteIndex(indexName) {
+        this.indexes.delete(indexName);
+    }
+    async upsert(params) {
+        const index = this.indexes.get(params.indexName);
+        if (!index) {
+            throw new Error(`Index ${params.indexName} not found`);
+        }
+        const ids = [];
+        for (const doc of params.vectors) {
+            index.vectors.set(doc.id, doc);
+            ids.push(doc.id);
+        }
+        return ids;
+    }
+    async query(params) {
+        const index = this.indexes.get(params.indexName);
+        if (!index) {
+            throw new Error(`Index ${params.indexName} not found`);
+        }
+        const results = [];
+        for (const [id, doc] of index.vectors) {
+            // Apply filter if provided
+            if (params.filter && !this.matchesFilter(doc.metadata || {}, params.filter)) {
+                continue;
+            }
+            const score = this.calculateSimilarity(params.vector, doc.vector, index.metric);
+            results.push({
+                id,
+                score,
+                metadata: params.includeMetadata ? doc.metadata : undefined,
+                content: doc.content,
+                vector: params.includeVectors ? doc.vector : undefined
+            });
+        }
+        // Sort by score descending and limit
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, params.topK || 10);
+    }
+    async delete(params) {
+        const index = this.indexes.get(params.indexName);
+        if (!index) {
+            throw new Error(`Index ${params.indexName} not found`);
+        }
+        if (params.ids) {
+            for (const id of params.ids) {
+                index.vectors.delete(id);
+            }
+        }
+        else if (params.filter) {
+            for (const [id, doc] of index.vectors) {
+                if (this.matchesFilter(doc.metadata || {}, params.filter)) {
+                    index.vectors.delete(id);
+                }
+            }
+        }
+    }
+    async update(indexName, id, metadata) {
+        const index = this.indexes.get(indexName);
+        if (!index) {
+            throw new Error(`Index ${indexName} not found`);
+        }
+        const doc = index.vectors.get(id);
+        if (doc) {
+            doc.metadata = { ...doc.metadata, ...metadata };
+        }
+    }
+    calculateSimilarity(a, b, metric) {
+        if (a.length !== b.length) {
+            throw new Error('Vector dimensions must match');
+        }
+        switch (metric) {
+            case 'cosine':
+                return this.cosineSimilarity(a, b);
+            case 'euclidean':
+                return 1 / (1 + this.euclideanDistance(a, b));
+            case 'dotProduct':
+                return this.dotProduct(a, b);
+            default:
+                return this.cosineSimilarity(a, b);
+        }
+    }
+    cosineSimilarity(a, b) {
+        const dot = this.dotProduct(a, b);
+        const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
+        const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
+        return dot / (normA * normB);
+    }
+    euclideanDistance(a, b) {
+        return Math.sqrt(a.reduce((sum, x, i) => sum + Math.pow(x - b[i], 2), 0));
+    }
+    dotProduct(a, b) {
+        return a.reduce((sum, x, i) => sum + x * b[i], 0);
+    }
+    matchesFilter(metadata, filter) {
+        for (const [key, value] of Object.entries(filter)) {
+            if (metadata[key] !== value) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.MemoryVectorStore = MemoryVectorStore;
+// Factory function
+function createMemoryVectorStore(id) {
+    return new MemoryVectorStore({ id: id || 'memory' });
+}

package/dist/integrations/vector/chroma.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Chroma Vector Store Integration
+ */
+import { BaseVectorStore, CreateIndexParams, UpsertParams, QueryParams, DeleteParams, QueryResult, IndexStats } from './base';
+export interface ChromaConfig {
+    host?: string;
+    port?: number;
+    path?: string;
+}
+export declare class ChromaVectorStore extends BaseVectorStore {
+    private baseUrl;
+    constructor(config?: ChromaConfig & {
+        id?: string;
+    });
+    private request;
+    createIndex(params: CreateIndexParams): Promise<void>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+    upsert(params: UpsertParams): Promise<string[]>;
+    query(params: QueryParams): Promise<QueryResult[]>;
+    delete(params: DeleteParams): Promise<void>;
+    update(indexName: string, id: string, metadata: Record<string, any>): Promise<void>;
+}
+export declare function createChromaStore(config?: ChromaConfig): ChromaVectorStore;

package/dist/integrations/vector/chroma.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Chroma Vector Store Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChromaVectorStore = void 0;
+exports.createChromaStore = createChromaStore;
+const base_1 = require("./base");
+class ChromaVectorStore extends base_1.BaseVectorStore {
+    constructor(config = {}) {
+        super({ id: config.id || 'chroma', name: 'ChromaVectorStore' });
+        const host = config.host || 'localhost';
+        const port = config.port || 8000;
+        this.baseUrl = config.path || `http://${host}:${port}`;
+    }
+    async request(path, options = {}) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Chroma API error: ${response.status} - ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+    }
+    async createIndex(params) {
+        const metadataMap = {
+            cosine: 'cosine',
+            euclidean: 'l2',
+            dotProduct: 'ip'
+        };
+        await this.request('/api/v1/collections', {
+            method: 'POST',
+            body: JSON.stringify({
+                name: params.indexName,
+                metadata: {
+                    'hnsw:space': metadataMap[params.metric || 'cosine'],
+                    dimension: params.dimension
+                }
+            })
+        });
+    }
+    async listIndexes() {
+        const response = await this.request('/api/v1/collections');
+        return (response || []).map((c) => c.name);
+    }
+    async describeIndex(indexName) {
+        const response = await this.request(`/api/v1/collections/${indexName}`);
+        const spaceMap = {
+            'cosine': 'cosine',
+            'l2': 'euclidean',
+            'ip': 'dotProduct'
+        };
+        return {
+            dimension: response.metadata?.dimension || 0,
+            count: response.count || 0,
+            metric: spaceMap[response.metadata?.['hnsw:space']] || 'cosine'
+        };
+    }
+    async deleteIndex(indexName) {
+        await this.request(`/api/v1/collections/${indexName}`, { method: 'DELETE' });
+    }
+    async upsert(params) {
+        const ids = params.vectors.map(v => v.id);
+        const embeddings = params.vectors.map(v => v.vector);
+        const metadatas = params.vectors.map(v => v.metadata || {});
+        const documents = params.vectors.map(v => v.content || '');
+        await this.request(`/api/v1/collections/${params.indexName}/upsert`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ids,
+                embeddings,
+                metadatas,
+                documents
+            })
+        });
+        return ids;
+    }
+    async query(params) {
+        let where = undefined;
+        if (params.filter) {
+            where = params.filter;
+        }
+        const response = await this.request(`/api/v1/collections/${params.indexName}/query`, {
+            method: 'POST',
+            body: JSON.stringify({
+                query_embeddings: [params.vector],
+                n_results: params.topK || 10,
+                where,
+                include: [
+                    'documents',
+                    'metadatas',
+                    'distances',
+                    ...(params.includeVectors ? ['embeddings'] : [])
+                ]
+            })
+        });
+        const ids = response.ids?.[0] || [];
+        const distances = response.distances?.[0] || [];
+        const metadatas = response.metadatas?.[0] || [];
+        const documents = response.documents?.[0] || [];
+        const embeddings = response.embeddings?.[0] || [];
+        return ids.map((id, i) => ({
+            id,
+            score: 1 - (distances[i] || 0), // Convert distance to similarity
+            metadata: metadatas[i],
+            content: documents[i],
+            vector: embeddings[i]
+        }));
+    }
+    async delete(params) {
+        if (params.ids) {
+            await this.request(`/api/v1/collections/${params.indexName}/delete`, {
+                method: 'POST',
+                body: JSON.stringify({ ids: params.ids })
+            });
+        }
+        else if (params.filter) {
+            await this.request(`/api/v1/collections/${params.indexName}/delete`, {
+                method: 'POST',
+                body: JSON.stringify({ where: params.filter })
+            });
+        }
+    }
+    async update(indexName, id, metadata) {
+        await this.request(`/api/v1/collections/${indexName}/update`, {
+            method: 'POST',
+            body: JSON.stringify({
+                ids: [id],
+                metadatas: [metadata]
+            })
+        });
+    }
+}
+exports.ChromaVectorStore = ChromaVectorStore;
+function createChromaStore(config) {
+    return new ChromaVectorStore(config);
+}