overai 1.4.0

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

@@ -0,0 +1,76 @@
+/**
+ * Base Voice - Abstract class for voice/TTS integrations
+ * Matches mastra's MastraVoice pattern
+ */
+export interface VoiceConfig {
+    apiKey?: string;
+    model?: string;
+    voice?: string;
+}
+export interface SpeakOptions {
+    voice?: string;
+    speed?: number;
+    pitch?: number;
+    format?: 'mp3' | 'wav' | 'ogg' | 'opus';
+}
+export interface ListenOptions {
+    language?: string;
+    model?: string;
+}
+export interface Speaker {
+    id: string;
+    name: string;
+    language?: string;
+    gender?: 'male' | 'female' | 'neutral';
+}
+/**
+ * Abstract base class for voice providers
+ */
+export declare abstract class BaseVoiceProvider {
+    readonly name: string;
+    protected apiKey?: string;
+    protected defaultVoice?: string;
+    constructor(config: VoiceConfig & {
+        name?: string;
+    });
+    /**
+     * Convert text to speech
+     */
+    abstract speak(text: string, options?: SpeakOptions): Promise<Buffer | ReadableStream>;
+    /**
+     * Convert speech to text
+     */
+    abstract listen(audio: Buffer | ReadableStream, options?: ListenOptions): Promise<string>;
+    /**
+     * Get available voices/speakers
+     */
+    abstract getSpeakers(): Promise<Speaker[]>;
+    /**
+     * Check if provider is available
+     */
+    abstract isAvailable(): Promise<boolean>;
+}
+/**
+ * OpenAI Voice Provider (TTS and Whisper)
+ */
+export declare class OpenAIVoiceProvider extends BaseVoiceProvider {
+    private baseUrl;
+    constructor(config?: VoiceConfig);
+    speak(text: string, options?: SpeakOptions): Promise<Buffer>;
+    listen(audio: Buffer | ReadableStream, options?: ListenOptions): Promise<string>;
+    getSpeakers(): Promise<Speaker[]>;
+    isAvailable(): Promise<boolean>;
+}
+/**
+ * ElevenLabs Voice Provider
+ */
+export declare class ElevenLabsVoiceProvider extends BaseVoiceProvider {
+    private baseUrl;
+    constructor(config?: VoiceConfig);
+    speak(text: string, options?: SpeakOptions): Promise<Buffer>;
+    listen(_audio: Buffer | ReadableStream, _options?: ListenOptions): Promise<string>;
+    getSpeakers(): Promise<Speaker[]>;
+    isAvailable(): Promise<boolean>;
+}
+export declare function createOpenAIVoice(config?: VoiceConfig): OpenAIVoiceProvider;
+export declare function createElevenLabsVoice(config?: VoiceConfig): ElevenLabsVoiceProvider;

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/chunking.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Chunking - Text chunking utilities for RAG
+ */
+export type ChunkStrategy = 'size' | 'sentence' | 'paragraph' | 'semantic';
+export interface ChunkingConfig {
+    chunkSize?: number;
+    overlap?: number;
+    strategy?: ChunkStrategy;
+    separator?: string;
+}
+export interface Chunk {
+    content: string;
+    index: number;
+    startOffset: number;
+    endOffset: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Chunking class for splitting text into chunks
+ */
+export declare class Chunking {
+    private chunkSize;
+    private overlap;
+    private strategy;
+    private separator;
+    constructor(config?: ChunkingConfig);
+    /**
+     * Chunk text based on configured strategy
+     */
+    chunk(text: string): Chunk[];
+    /**
+     * Chunk by fixed size with overlap
+     */
+    chunkBySize(text: string): Chunk[];
+    /**
+     * Chunk by sentences
+     */
+    chunkBySentence(text: string): Chunk[];
+    /**
+     * Chunk by paragraphs
+     */
+    chunkByParagraph(text: string): Chunk[];
+    /**
+     * Chunk by semantic boundaries (simplified)
+     */
+    chunkBySemantic(text: string): Chunk[];
+    /**
+     * Merge small chunks
+     */
+    mergeSmallChunks(chunks: Chunk[], minSize?: number): Chunk[];
+}
+/**
+ * Create a Chunking instance
+ */
+export declare function createChunking(config?: ChunkingConfig): Chunking;

package/dist/knowledge/chunking.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Chunking - Text chunking utilities for RAG
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chunking = void 0;
+exports.createChunking = createChunking;
+/**
+ * Chunking class for splitting text into chunks
+ */
+class Chunking {
+    constructor(config = {}) {
+        this.chunkSize = config.chunkSize ?? 500;
+        this.overlap = config.overlap ?? 50;
+        this.strategy = config.strategy ?? 'size';
+        this.separator = config.separator ?? ' ';
+    }
+    /**
+     * Chunk text based on configured strategy
+     */
+    chunk(text) {
+        switch (this.strategy) {
+            case 'sentence':
+                return this.chunkBySentence(text);
+            case 'paragraph':
+                return this.chunkByParagraph(text);
+            case 'semantic':
+                return this.chunkBySemantic(text);
+            default:
+                return this.chunkBySize(text);
+        }
+    }
+    /**
+     * Chunk by fixed size with overlap
+     */
+    chunkBySize(text) {
+        const chunks = [];
+        let startOffset = 0;
+        let index = 0;
+        while (startOffset < text.length) {
+            const endOffset = Math.min(startOffset + this.chunkSize, text.length);
+            const content = text.slice(startOffset, endOffset);
+            chunks.push({
+                content,
+                index,
+                startOffset,
+                endOffset
+            });
+            startOffset = endOffset - this.overlap;
+            if (startOffset >= text.length - this.overlap)
+                break;
+            index++;
+        }
+        return chunks;
+    }
+    /**
+     * Chunk by sentences
+     */
+    chunkBySentence(text) {
+        const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
+        return sentences.map((content, index) => {
+            const startOffset = text.indexOf(content);
+            return {
+                content: content.trim(),
+                index,
+                startOffset,
+                endOffset: startOffset + content.length
+            };
+        });
+    }
+    /**
+     * Chunk by paragraphs
+     */
+    chunkByParagraph(text) {
+        const paragraphs = text.split(/\n\n+/).filter(p => p.trim().length > 0);
+        let offset = 0;
+        return paragraphs.map((content, index) => {
+            const startOffset = text.indexOf(content, offset);
+            offset = startOffset + content.length;
+            return {
+                content: content.trim(),
+                index,
+                startOffset,
+                endOffset: offset
+            };
+        });
+    }
+    /**
+     * Chunk by semantic boundaries (simplified)
+     */
+    chunkBySemantic(text) {
+        // Simplified semantic chunking - split on headers, lists, etc.
+        const patterns = [
+            /^#{1,6}\s+.+$/gm, // Headers
+            /^\s*[-*]\s+/gm, // List items
+            /^\d+\.\s+/gm // Numbered lists
+        ];
+        let chunks = [];
+        let lastEnd = 0;
+        let index = 0;
+        // Find semantic boundaries
+        const boundaries = [0];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(text)) !== null) {
+                boundaries.push(match.index);
+            }
+        }
+        boundaries.push(text.length);
+        boundaries.sort((a, b) => a - b);
+        // Create chunks from boundaries
+        for (let i = 0; i < boundaries.length - 1; i++) {
+            const start = boundaries[i];
+            const end = boundaries[i + 1];
+            const content = text.slice(start, end).trim();
+            if (content.length > 0) {
+                chunks.push({
+                    content,
+                    index: index++,
+                    startOffset: start,
+                    endOffset: end
+                });
+            }
+        }
+        return chunks.length > 0 ? chunks : this.chunkBySize(text);
+    }
+    /**
+     * Merge small chunks
+     */
+    mergeSmallChunks(chunks, minSize = 100) {
+        const merged = [];
+        let current = null;
+        for (const chunk of chunks) {
+            if (!current) {
+                current = { ...chunk };
+            }
+            else if (current.content.length < minSize) {
+                current.content += '\n' + chunk.content;
+                current.endOffset = chunk.endOffset;
+            }
+            else {
+                merged.push(current);
+                current = { ...chunk };
+            }
+        }
+        if (current) {
+            merged.push(current);
+        }
+        return merged.map((c, i) => ({ ...c, index: i }));
+    }
+}
+exports.Chunking = Chunking;
+/**
+ * Create a Chunking instance
+ */
+function createChunking(config) {
+    return new Chunking(config);
+}

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;