praisonai 1.2.0 → 1.2.2

package/dist/integrations/voice/base.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Base Voice - Abstract class for voice/TTS integrations
+ * Matches mastra's MastraVoice pattern
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElevenLabsVoiceProvider = exports.OpenAIVoiceProvider = exports.BaseVoiceProvider = void 0;
+exports.createOpenAIVoice = createOpenAIVoice;
+exports.createElevenLabsVoice = createElevenLabsVoice;
+/**
+ * Abstract base class for voice providers
+ */
+class BaseVoiceProvider {
+    constructor(config) {
+        this.name = config.name || 'VoiceProvider';
+        this.apiKey = config.apiKey;
+        this.defaultVoice = config.voice;
+    }
+}
+exports.BaseVoiceProvider = BaseVoiceProvider;
+/**
+ * OpenAI Voice Provider (TTS and Whisper)
+ */
+class OpenAIVoiceProvider extends BaseVoiceProvider {
+    constructor(config = {}) {
+        super({ ...config, name: 'OpenAIVoice' });
+        this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+        this.defaultVoice = config.voice || 'alloy';
+        this.baseUrl = 'https://api.openai.com/v1';
+    }
+    async speak(text, options) {
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key required for TTS');
+        }
+        const response = await fetch(`${this.baseUrl}/audio/speech`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                model: 'tts-1',
+                input: text,
+                voice: options?.voice || this.defaultVoice,
+                speed: options?.speed || 1.0,
+                response_format: options?.format || 'mp3'
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI TTS error: ${response.status} - ${error}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    async listen(audio, options) {
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key required for Whisper');
+        }
+        const formData = new FormData();
+        // Convert Buffer to Blob
+        const audioBlob = audio instanceof Buffer
+            ? new Blob([new Uint8Array(audio)], { type: 'audio/mp3' })
+            : audio;
+        formData.append('file', audioBlob, 'audio.mp3');
+        formData.append('model', options?.model || 'whisper-1');
+        if (options?.language) {
+            formData.append('language', options.language);
+        }
+        const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: formData
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI Whisper error: ${response.status} - ${error}`);
+        }
+        const result = await response.json();
+        return result.text;
+    }
+    async getSpeakers() {
+        return [
+            { id: 'alloy', name: 'Alloy', gender: 'neutral' },
+            { id: 'echo', name: 'Echo', gender: 'male' },
+            { id: 'fable', name: 'Fable', gender: 'neutral' },
+            { id: 'onyx', name: 'Onyx', gender: 'male' },
+            { id: 'nova', name: 'Nova', gender: 'female' },
+            { id: 'shimmer', name: 'Shimmer', gender: 'female' }
+        ];
+    }
+    async isAvailable() {
+        return !!this.apiKey;
+    }
+}
+exports.OpenAIVoiceProvider = OpenAIVoiceProvider;
+/**
+ * ElevenLabs Voice Provider
+ */
+class ElevenLabsVoiceProvider extends BaseVoiceProvider {
+    constructor(config = {}) {
+        super({ ...config, name: 'ElevenLabsVoice' });
+        this.apiKey = config.apiKey || process.env.ELEVENLABS_API_KEY;
+        this.baseUrl = 'https://api.elevenlabs.io/v1';
+    }
+    async speak(text, options) {
+        if (!this.apiKey) {
+            throw new Error('ElevenLabs API key required');
+        }
+        const voiceId = options?.voice || this.defaultVoice || '21m00Tcm4TlvDq8ikWAM'; // Rachel
+        const response = await fetch(`${this.baseUrl}/text-to-speech/${voiceId}`, {
+            method: 'POST',
+            headers: {
+                'xi-api-key': this.apiKey,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                text,
+                model_id: 'eleven_monolingual_v1',
+                voice_settings: {
+                    stability: 0.5,
+                    similarity_boost: 0.5
+                }
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`ElevenLabs error: ${response.status} - ${error}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    async listen(_audio, _options) {
+        throw new Error('ElevenLabs does not support speech-to-text');
+    }
+    async getSpeakers() {
+        if (!this.apiKey) {
+            return [];
+        }
+        const response = await fetch(`${this.baseUrl}/voices`, {
+            headers: {
+                'xi-api-key': this.apiKey
+            }
+        });
+        if (!response.ok) {
+            return [];
+        }
+        const data = await response.json();
+        return (data.voices || []).map((v) => ({
+            id: v.voice_id,
+            name: v.name,
+            gender: v.labels?.gender
+        }));
+    }
+    async isAvailable() {
+        return !!this.apiKey;
+    }
+}
+exports.ElevenLabsVoiceProvider = ElevenLabsVoiceProvider;
+// Factory functions
+function createOpenAIVoice(config) {
+    return new OpenAIVoiceProvider(config);
+}
+function createElevenLabsVoice(config) {
+    return new ElevenLabsVoiceProvider(config);
+}

package/dist/integrations/voice/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Voice Integrations
+ * Provides adapters for TTS and STT services
+ */
+export * from './base';
+export { createOpenAIVoice, createElevenLabsVoice } from './base';

package/dist/integrations/voice/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Voice Integrations
+ * Provides adapters for TTS and STT services
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElevenLabsVoice = exports.createOpenAIVoice = void 0;
+__exportStar(require("./base"), exports);
+// Re-export factory functions
+var base_1 = require("./base");
+Object.defineProperty(exports, "createOpenAIVoice", { enumerable: true, get: function () { return base_1.createOpenAIVoice; } });
+Object.defineProperty(exports, "createElevenLabsVoice", { enumerable: true, get: function () { return base_1.createElevenLabsVoice; } });

package/dist/knowledge/graph-rag.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Graph RAG - Graph-based Retrieval Augmented Generation
+ * Inspired by mastra's graph-rag module
+ */
+export interface GraphNode {
+    id: string;
+    type: string;
+    content: string;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+}
+export interface GraphEdge {
+    id: string;
+    source: string;
+    target: string;
+    type: string;
+    weight?: number;
+    metadata?: Record<string, any>;
+}
+export interface GraphQueryResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    paths: GraphNode[][];
+    score: number;
+}
+export interface GraphRAGConfig {
+    maxDepth?: number;
+    maxNodes?: number;
+    minScore?: number;
+    includeEdges?: boolean;
+}
+/**
+ * In-memory Graph Store for Graph RAG
+ */
+export declare class GraphStore {
+    private nodes;
+    private edges;
+    private adjacencyList;
+    private reverseAdjacencyList;
+    /**
+     * Add a node to the graph
+     */
+    addNode(node: GraphNode): void;
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge: GraphEdge): void;
+    /**
+     * Get a node by ID
+     */
+    getNode(id: string): GraphNode | undefined;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): GraphNode[];
+    /**
+     * Get neighbors of a node
+     */
+    getNeighbors(nodeId: string, direction?: 'outgoing' | 'incoming' | 'both'): GraphNode[];
+    /**
+     * Get edges between two nodes
+     */
+    getEdgesBetween(sourceId: string, targetId: string): GraphEdge[];
+    /**
+     * Find paths between two nodes using BFS
+     */
+    findPaths(startId: string, endId: string, maxDepth?: number): GraphNode[][];
+    /**
+     * Get subgraph around a node
+     */
+    getSubgraph(nodeId: string, depth?: number): {
+        nodes: GraphNode[];
+        edges: GraphEdge[];
+    };
+    /**
+     * Clear the graph
+     */
+    clear(): void;
+    /**
+     * Get graph statistics
+     */
+    getStats(): {
+        nodeCount: number;
+        edgeCount: number;
+    };
+}
+/**
+ * Graph RAG - Combines graph traversal with vector similarity
+ */
+export declare class GraphRAG {
+    private graphStore;
+    private embedFn?;
+    constructor(config?: {
+        embedFn?: (text: string) => Promise<number[]>;
+    });
+    /**
+     * Add a document as a node
+     */
+    addDocument(doc: {
+        id: string;
+        content: string;
+        type?: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /**
+     * Add a relationship between documents
+     */
+    addRelationship(sourceId: string, targetId: string, type: string, weight?: number): void;
+    /**
+     * Query the graph with a natural language query
+     */
+    query(query: string, config?: GraphRAGConfig): Promise<GraphQueryResult>;
+    /**
+     * Get context string from query results
+     */
+    getContext(result: GraphQueryResult): string;
+    /**
+     * Get the underlying graph store
+     */
+    getGraphStore(): GraphStore;
+    private cosineSimilarity;
+}
+export declare function createGraphRAG(config?: {
+    embedFn?: (text: string) => Promise<number[]>;
+}): GraphRAG;

package/dist/knowledge/graph-rag.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Graph RAG - Graph-based Retrieval Augmented Generation
+ * Inspired by mastra's graph-rag module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRAG = exports.GraphStore = void 0;
+exports.createGraphRAG = createGraphRAG;
+/**
+ * In-memory Graph Store for Graph RAG
+ */
+class GraphStore {
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.adjacencyList = new Map();
+        this.reverseAdjacencyList = new Map();
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        this.nodes.set(node.id, node);
+        if (!this.adjacencyList.has(node.id)) {
+            this.adjacencyList.set(node.id, new Set());
+        }
+        if (!this.reverseAdjacencyList.has(node.id)) {
+            this.reverseAdjacencyList.set(node.id, new Set());
+        }
+    }
+    /**
+     * Add an edge to the graph
+     */
+    addEdge(edge) {
+        this.edges.set(edge.id, edge);
+        // Update adjacency lists
+        if (!this.adjacencyList.has(edge.source)) {
+            this.adjacencyList.set(edge.source, new Set());
+        }
+        this.adjacencyList.get(edge.source).add(edge.target);
+        if (!this.reverseAdjacencyList.has(edge.target)) {
+            this.reverseAdjacencyList.set(edge.target, new Set());
+        }
+        this.reverseAdjacencyList.get(edge.target).add(edge.source);
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    /**
+     * Get all nodes
+     */
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    /**
+     * Get neighbors of a node
+     */
+    getNeighbors(nodeId, direction = 'both') {
+        const neighborIds = new Set();
+        if (direction === 'outgoing' || direction === 'both') {
+            const outgoing = this.adjacencyList.get(nodeId);
+            if (outgoing) {
+                outgoing.forEach(id => neighborIds.add(id));
+            }
+        }
+        if (direction === 'incoming' || direction === 'both') {
+            const incoming = this.reverseAdjacencyList.get(nodeId);
+            if (incoming) {
+                incoming.forEach(id => neighborIds.add(id));
+            }
+        }
+        return Array.from(neighborIds)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    /**
+     * Get edges between two nodes
+     */
+    getEdgesBetween(sourceId, targetId) {
+        return Array.from(this.edges.values()).filter(e => (e.source === sourceId && e.target === targetId) ||
+            (e.source === targetId && e.target === sourceId));
+    }
+    /**
+     * Find paths between two nodes using BFS
+     */
+    findPaths(startId, endId, maxDepth = 3) {
+        const paths = [];
+        const queue = [
+            { path: [startId], visited: new Set([startId]) }
+        ];
+        while (queue.length > 0) {
+            const { path, visited } = queue.shift();
+            const currentId = path[path.length - 1];
+            if (currentId === endId) {
+                paths.push(path.map(id => this.nodes.get(id)).filter(n => n));
+                continue;
+            }
+            if (path.length >= maxDepth) {
+                continue;
+            }
+            const neighbors = this.adjacencyList.get(currentId) || new Set();
+            for (const neighborId of neighbors) {
+                if (!visited.has(neighborId)) {
+                    const newVisited = new Set(visited);
+                    newVisited.add(neighborId);
+                    queue.push({ path: [...path, neighborId], visited: newVisited });
+                }
+            }
+        }
+        return paths;
+    }
+    /**
+     * Get subgraph around a node
+     */
+    getSubgraph(nodeId, depth = 2) {
+        const visitedNodes = new Set();
+        const resultEdges = [];
+        const queue = [{ id: nodeId, currentDepth: 0 }];
+        while (queue.length > 0) {
+            const { id, currentDepth } = queue.shift();
+            if (visitedNodes.has(id) || currentDepth > depth) {
+                continue;
+            }
+            visitedNodes.add(id);
+            if (currentDepth < depth) {
+                const neighbors = this.getNeighbors(id);
+                for (const neighbor of neighbors) {
+                    if (!visitedNodes.has(neighbor.id)) {
+                        queue.push({ id: neighbor.id, currentDepth: currentDepth + 1 });
+                        // Add edges
+                        const edges = this.getEdgesBetween(id, neighbor.id);
+                        resultEdges.push(...edges);
+                    }
+                }
+            }
+        }
+        const resultNodes = Array.from(visitedNodes)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+        return { nodes: resultNodes, edges: resultEdges };
+    }
+    /**
+     * Clear the graph
+     */
+    clear() {
+        this.nodes.clear();
+        this.edges.clear();
+        this.adjacencyList.clear();
+        this.reverseAdjacencyList.clear();
+    }
+    /**
+     * Get graph statistics
+     */
+    getStats() {
+        return {
+            nodeCount: this.nodes.size,
+            edgeCount: this.edges.size
+        };
+    }
+}
+exports.GraphStore = GraphStore;
+/**
+ * Graph RAG - Combines graph traversal with vector similarity
+ */
+class GraphRAG {
+    constructor(config = {}) {
+        this.graphStore = new GraphStore();
+        this.embedFn = config.embedFn;
+    }
+    /**
+     * Add a document as a node
+     */
+    async addDocument(doc) {
+        const embedding = this.embedFn ? await this.embedFn(doc.content) : undefined;
+        this.graphStore.addNode({
+            id: doc.id,
+            type: doc.type || 'document',
+            content: doc.content,
+            metadata: doc.metadata,
+            embedding
+        });
+    }
+    /**
+     * Add a relationship between documents
+     */
+    addRelationship(sourceId, targetId, type, weight) {
+        this.graphStore.addEdge({
+            id: `${sourceId}-${type}-${targetId}`,
+            source: sourceId,
+            target: targetId,
+            type,
+            weight
+        });
+    }
+    /**
+     * Query the graph with a natural language query
+     */
+    async query(query, config = {}) {
+        const { maxDepth = 2, maxNodes = 10, minScore = 0, includeEdges = true } = config;
+        // Get all nodes and score them
+        const allNodes = this.graphStore.getAllNodes();
+        let scoredNodes;
+        if (this.embedFn) {
+            // Use embedding similarity
+            const queryEmbedding = await this.embedFn(query);
+            scoredNodes = allNodes
+                .filter(n => n.embedding)
+                .map(node => ({
+                node,
+                score: this.cosineSimilarity(queryEmbedding, node.embedding)
+            }));
+        }
+        else {
+            // Use keyword matching
+            const queryTerms = query.toLowerCase().split(/\s+/);
+            scoredNodes = allNodes.map(node => {
+                const content = node.content.toLowerCase();
+                let score = 0;
+                for (const term of queryTerms) {
+                    if (content.includes(term))
+                        score += 1;
+                }
+                return { node, score: score / queryTerms.length };
+            });
+        }
+        // Filter and sort by score
+        scoredNodes = scoredNodes
+            .filter(s => s.score >= minScore)
+            .sort((a, b) => b.score - a.score);
+        // Get top nodes and expand graph
+        const topNodes = scoredNodes.slice(0, Math.min(3, maxNodes));
+        const resultNodes = [];
+        const resultEdges = [];
+        const seenNodeIds = new Set();
+        for (const { node } of topNodes) {
+            const subgraph = this.graphStore.getSubgraph(node.id, maxDepth);
+            for (const n of subgraph.nodes) {
+                if (!seenNodeIds.has(n.id) && resultNodes.length < maxNodes) {
+                    seenNodeIds.add(n.id);
+                    resultNodes.push(n);
+                }
+            }
+            if (includeEdges) {
+                resultEdges.push(...subgraph.edges);
+            }
+        }
+        // Find paths between top nodes
+        const paths = [];
+        if (topNodes.length >= 2) {
+            for (let i = 0; i < topNodes.length - 1; i++) {
+                const foundPaths = this.graphStore.findPaths(topNodes[i].node.id, topNodes[i + 1].node.id, maxDepth);
+                paths.push(...foundPaths.slice(0, 3));
+            }
+        }
+        return {
+            nodes: resultNodes,
+            edges: resultEdges,
+            paths,
+            score: topNodes.length > 0 ? topNodes[0].score : 0
+        };
+    }
+    /**
+     * Get context string from query results
+     */
+    getContext(result) {
+        const nodeContents = result.nodes.map(n => n.content);
+        return nodeContents.join('\n\n---\n\n');
+    }
+    /**
+     * Get the underlying graph store
+     */
+    getGraphStore() {
+        return this.graphStore;
+    }
+    cosineSimilarity(a, b) {
+        const dot = a.reduce((sum, x, i) => sum + x * b[i], 0);
+        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);
+    }
+}
+exports.GraphRAG = GraphRAG;
+// Factory function
+function createGraphRAG(config) {
+    return new GraphRAG(config);
+}

package/dist/knowledge/index.d.ts

@@ -20,3 +20,5 @@ export declare class BaseKnowledgeBase implements KnowledgeBase {
     updateKnowledge(id: string, update: Partial<Knowledge>): boolean;
     deleteKnowledge(id: string): boolean;
 }
+export * from './reranker';
+export * from './graph-rag';

package/dist/knowledge/index.js

@@ -1,4 +1,18 @@
 "use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseKnowledgeBase = void 0;
 class BaseKnowledgeBase {
@@ -27,3 +41,7 @@ class BaseKnowledgeBase {
     }
 }
 exports.BaseKnowledgeBase = BaseKnowledgeBase;
+// Export Reranker
+__exportStar(require("./reranker"), exports);
+// Export Graph RAG
+__exportStar(require("./graph-rag"), exports);