praisonai 1.2.1 → 1.2.2

package/dist/integrations/vector/pinecone.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Pinecone Vector Store Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PineconeVectorStore = void 0;
+exports.createPineconeStore = createPineconeStore;
+const base_1 = require("./base");
+class PineconeVectorStore extends base_1.BaseVectorStore {
+    constructor(config) {
+        super({ id: config.id || 'pinecone', name: 'PineconeVectorStore' });
+        this.indexHosts = new Map();
+        this.apiKey = config.apiKey;
+        this.baseUrl = 'https://api.pinecone.io';
+    }
+    async request(path, options = {}) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            headers: {
+                'Api-Key': this.apiKey,
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Pinecone API error: ${response.status} - ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+    }
+    async indexRequest(indexName, path, options = {}) {
+        let host = this.indexHosts.get(indexName);
+        if (!host) {
+            const info = await this.request(`/indexes/${indexName}`);
+            host = info.host;
+            this.indexHosts.set(indexName, host);
+        }
+        const response = await fetch(`https://${host}${path}`, {
+            ...options,
+            headers: {
+                'Api-Key': this.apiKey,
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Pinecone Index API error: ${response.status} - ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+    }
+    async createIndex(params) {
+        const metricMap = {
+            cosine: 'cosine',
+            euclidean: 'euclidean',
+            dotProduct: 'dotproduct'
+        };
+        await this.request('/indexes', {
+            method: 'POST',
+            body: JSON.stringify({
+                name: params.indexName,
+                dimension: params.dimension,
+                metric: metricMap[params.metric || 'cosine'],
+                spec: {
+                    serverless: {
+                        cloud: 'aws',
+                        region: 'us-east-1'
+                    }
+                }
+            })
+        });
+        // Wait for index to be ready
+        let ready = false;
+        let attempts = 0;
+        while (!ready && attempts < 60) {
+            await new Promise(r => setTimeout(r, 2000));
+            try {
+                const info = await this.request(`/indexes/${params.indexName}`);
+                ready = info.status?.ready === true;
+            }
+            catch {
+                // Index not ready yet
+            }
+            attempts++;
+        }
+    }
+    async listIndexes() {
+        const response = await this.request('/indexes');
+        return (response.indexes || []).map((idx) => idx.name);
+    }
+    async describeIndex(indexName) {
+        const info = await this.request(`/indexes/${indexName}`);
+        const stats = await this.indexRequest(indexName, '/describe_index_stats', { method: 'POST', body: '{}' });
+        const metricMap = {
+            cosine: 'cosine',
+            euclidean: 'euclidean',
+            dotproduct: 'dotProduct'
+        };
+        return {
+            dimension: info.dimension,
+            count: stats.totalVectorCount || 0,
+            metric: metricMap[info.metric] || 'cosine'
+        };
+    }
+    async deleteIndex(indexName) {
+        await this.request(`/indexes/${indexName}`, { method: 'DELETE' });
+        this.indexHosts.delete(indexName);
+    }
+    async upsert(params) {
+        const vectors = params.vectors.map(v => ({
+            id: v.id,
+            values: v.vector,
+            metadata: v.metadata
+        }));
+        // Batch upsert in chunks of 100
+        const batchSize = 100;
+        const ids = [];
+        for (let i = 0; i < vectors.length; i += batchSize) {
+            const batch = vectors.slice(i, i + batchSize);
+            await this.indexRequest(params.indexName, '/vectors/upsert', {
+                method: 'POST',
+                body: JSON.stringify({ vectors: batch })
+            });
+            ids.push(...batch.map(v => v.id));
+        }
+        return ids;
+    }
+    async query(params) {
+        const response = await this.indexRequest(params.indexName, '/query', {
+            method: 'POST',
+            body: JSON.stringify({
+                vector: params.vector,
+                topK: params.topK || 10,
+                filter: params.filter,
+                includeMetadata: params.includeMetadata !== false,
+                includeValues: params.includeVectors
+            })
+        });
+        return (response.matches || []).map((match) => ({
+            id: match.id,
+            score: match.score,
+            metadata: match.metadata,
+            vector: match.values
+        }));
+    }
+    async delete(params) {
+        if (params.ids) {
+            await this.indexRequest(params.indexName, '/vectors/delete', {
+                method: 'POST',
+                body: JSON.stringify({ ids: params.ids })
+            });
+        }
+        else if (params.filter) {
+            await this.indexRequest(params.indexName, '/vectors/delete', {
+                method: 'POST',
+                body: JSON.stringify({ filter: params.filter })
+            });
+        }
+    }
+    async update(indexName, id, metadata) {
+        await this.indexRequest(indexName, '/vectors/update', {
+            method: 'POST',
+            body: JSON.stringify({ id, setMetadata: metadata })
+        });
+    }
+}
+exports.PineconeVectorStore = PineconeVectorStore;
+function createPineconeStore(config) {
+    return new PineconeVectorStore(config);
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Qdrant Vector Store Integration
+ */
+import { BaseVectorStore, CreateIndexParams, UpsertParams, QueryParams, DeleteParams, QueryResult, IndexStats } from './base';
+export interface QdrantConfig {
+    url: string;
+    apiKey?: string;
+}
+export declare class QdrantVectorStore extends BaseVectorStore {
+    private url;
+    private apiKey?;
+    constructor(config: QdrantConfig & {
+        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 createQdrantStore(config: QdrantConfig): QdrantVectorStore;

package/dist/integrations/vector/qdrant.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Qdrant Vector Store Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QdrantVectorStore = void 0;
+exports.createQdrantStore = createQdrantStore;
+const base_1 = require("./base");
+class QdrantVectorStore extends base_1.BaseVectorStore {
+    constructor(config) {
+        super({ id: config.id || 'qdrant', name: 'QdrantVectorStore' });
+        this.url = config.url.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+    }
+    async request(path, options = {}) {
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (this.apiKey) {
+            headers['api-key'] = this.apiKey;
+        }
+        const response = await fetch(`${this.url}${path}`, {
+            ...options,
+            headers: { ...headers, ...options.headers }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Qdrant API error: ${response.status} - ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+    }
+    async createIndex(params) {
+        const distanceMap = {
+            cosine: 'Cosine',
+            euclidean: 'Euclid',
+            dotProduct: 'Dot'
+        };
+        await this.request(`/collections/${params.indexName}`, {
+            method: 'PUT',
+            body: JSON.stringify({
+                vectors: {
+                    size: params.dimension,
+                    distance: distanceMap[params.metric || 'cosine']
+                }
+            })
+        });
+    }
+    async listIndexes() {
+        const response = await this.request('/collections');
+        return (response.result?.collections || []).map((c) => c.name);
+    }
+    async describeIndex(indexName) {
+        const response = await this.request(`/collections/${indexName}`);
+        const config = response.result?.config?.params?.vectors;
+        const distanceMap = {
+            'Cosine': 'cosine',
+            'Euclid': 'euclidean',
+            'Dot': 'dotProduct'
+        };
+        return {
+            dimension: config?.size || 0,
+            count: response.result?.points_count || 0,
+            metric: distanceMap[config?.distance] || 'cosine'
+        };
+    }
+    async deleteIndex(indexName) {
+        await this.request(`/collections/${indexName}`, { method: 'DELETE' });
+    }
+    async upsert(params) {
+        const points = params.vectors.map(v => ({
+            id: v.id,
+            vector: v.vector,
+            payload: {
+                ...v.metadata,
+                _content: v.content
+            }
+        }));
+        await this.request(`/collections/${params.indexName}/points`, {
+            method: 'PUT',
+            body: JSON.stringify({ points })
+        });
+        return params.vectors.map(v => v.id);
+    }
+    async query(params) {
+        let filter = undefined;
+        if (params.filter) {
+            filter = {
+                must: Object.entries(params.filter).map(([key, value]) => ({
+                    key,
+                    match: { value }
+                }))
+            };
+        }
+        const response = await this.request(`/collections/${params.indexName}/points/search`, {
+            method: 'POST',
+            body: JSON.stringify({
+                vector: params.vector,
+                limit: params.topK || 10,
+                filter,
+                with_payload: params.includeMetadata !== false,
+                with_vector: params.includeVectors
+            })
+        });
+        return (response.result || []).map((r) => ({
+            id: r.id,
+            score: r.score,
+            metadata: r.payload ? { ...r.payload, _content: undefined } : undefined,
+            content: r.payload?._content,
+            vector: r.vector
+        }));
+    }
+    async delete(params) {
+        if (params.ids) {
+            await this.request(`/collections/${params.indexName}/points/delete`, {
+                method: 'POST',
+                body: JSON.stringify({ points: params.ids })
+            });
+        }
+        else if (params.filter) {
+            const filter = {
+                must: Object.entries(params.filter).map(([key, value]) => ({
+                    key,
+                    match: { value }
+                }))
+            };
+            await this.request(`/collections/${params.indexName}/points/delete`, {
+                method: 'POST',
+                body: JSON.stringify({ filter })
+            });
+        }
+    }
+    async update(indexName, id, metadata) {
+        await this.request(`/collections/${indexName}/points/payload`, {
+            method: 'POST',
+            body: JSON.stringify({
+                points: [id],
+                payload: metadata
+            })
+        });
+    }
+}
+exports.QdrantVectorStore = QdrantVectorStore;
+function createQdrantStore(config) {
+    return new QdrantVectorStore(config);
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Weaviate Vector Store Integration
+ */
+import { BaseVectorStore, CreateIndexParams, UpsertParams, QueryParams, DeleteParams, QueryResult, IndexStats } from './base';
+export interface WeaviateConfig {
+    host: string;
+    apiKey?: string;
+    scheme?: 'http' | 'https';
+}
+export declare class WeaviateVectorStore extends BaseVectorStore {
+    private host;
+    private apiKey?;
+    private scheme;
+    constructor(config: WeaviateConfig & {
+        id?: string;
+    });
+    private get baseUrl();
+    private request;
+    private graphql;
+    private toClassName;
+    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 createWeaviateStore(config: WeaviateConfig): WeaviateVectorStore;

package/dist/integrations/vector/weaviate.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * Weaviate Vector Store Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeaviateVectorStore = void 0;
+exports.createWeaviateStore = createWeaviateStore;
+const base_1 = require("./base");
+class WeaviateVectorStore extends base_1.BaseVectorStore {
+    constructor(config) {
+        super({ id: config.id || 'weaviate', name: 'WeaviateVectorStore' });
+        this.host = config.host;
+        this.apiKey = config.apiKey;
+        this.scheme = config.scheme || 'https';
+    }
+    get baseUrl() {
+        return `${this.scheme}://${this.host}`;
+    }
+    async request(path, options = {}) {
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            headers: { ...headers, ...options.headers }
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Weaviate API error: ${response.status} - ${error}`);
+        }
+        const text = await response.text();
+        return text ? JSON.parse(text) : {};
+    }
+    async graphql(query, variables) {
+        const response = await this.request('/v1/graphql', {
+            method: 'POST',
+            body: JSON.stringify({ query, variables })
+        });
+        return response;
+    }
+    toClassName(indexName) {
+        // Weaviate class names must start with uppercase
+        return indexName.charAt(0).toUpperCase() + indexName.slice(1);
+    }
+    async createIndex(params) {
+        const className = this.toClassName(params.indexName);
+        const vectorIndexConfig = {
+            distance: params.metric === 'euclidean' ? 'l2-squared' :
+                params.metric === 'dotProduct' ? 'dot' : 'cosine'
+        };
+        await this.request('/v1/schema', {
+            method: 'POST',
+            body: JSON.stringify({
+                class: className,
+                vectorIndexConfig,
+                properties: [
+                    {
+                        name: 'content',
+                        dataType: ['text']
+                    },
+                    {
+                        name: 'metadata',
+                        dataType: ['object']
+                    }
+                ]
+            })
+        });
+    }
+    async listIndexes() {
+        const response = await this.request('/v1/schema');
+        return (response.classes || []).map((c) => c.class.toLowerCase());
+    }
+    async describeIndex(indexName) {
+        const className = this.toClassName(indexName);
+        const response = await this.request(`/v1/schema/${className}`);
+        // Get count via aggregate
+        const countQuery = `{
+      Aggregate {
+        ${className} {
+          meta { count }
+        }
+      }
+    }`;
+        const countResponse = await this.graphql(countQuery);
+        const count = countResponse.data?.Aggregate?.[className]?.[0]?.meta?.count || 0;
+        const distanceMap = {
+            'cosine': 'cosine',
+            'l2-squared': 'euclidean',
+            'dot': 'dotProduct'
+        };
+        return {
+            dimension: response.vectorIndexConfig?.dimensions || 0,
+            count,
+            metric: distanceMap[response.vectorIndexConfig?.distance] || 'cosine'
+        };
+    }
+    async deleteIndex(indexName) {
+        const className = this.toClassName(indexName);
+        await this.request(`/v1/schema/${className}`, { method: 'DELETE' });
+    }
+    async upsert(params) {
+        const className = this.toClassName(params.indexName);
+        const ids = [];
+        // Batch upsert
+        const objects = params.vectors.map(v => ({
+            class: className,
+            id: v.id,
+            vector: v.vector,
+            properties: {
+                content: v.content || '',
+                metadata: v.metadata || {}
+            }
+        }));
+        // Batch in chunks of 100
+        const batchSize = 100;
+        for (let i = 0; i < objects.length; i += batchSize) {
+            const batch = objects.slice(i, i + batchSize);
+            await this.request('/v1/batch/objects', {
+                method: 'POST',
+                body: JSON.stringify({ objects: batch })
+            });
+            ids.push(...batch.map(o => o.id));
+        }
+        return ids;
+    }
+    async query(params) {
+        const className = this.toClassName(params.indexName);
+        const topK = params.topK || 10;
+        let whereClause = '';
+        if (params.filter) {
+            const conditions = Object.entries(params.filter).map(([key, value]) => {
+                return `{ path: ["metadata", "${key}"], operator: Equal, valueString: "${value}" }`;
+            });
+            if (conditions.length > 0) {
+                whereClause = `where: { operator: And, operands: [${conditions.join(', ')}] }`;
+            }
+        }
+        const query = `{
+      Get {
+        ${className}(
+          nearVector: { vector: [${params.vector.join(',')}] }
+          limit: ${topK}
+          ${whereClause}
+        ) {
+          _additional {
+            id
+            distance
+            ${params.includeVectors ? 'vector' : ''}
+          }
+          content
+          metadata
+        }
+      }
+    }`;
+        const response = await this.graphql(query);
+        const results = response.data?.Get?.[className] || [];
+        return results.map((r) => ({
+            id: r._additional.id,
+            score: 1 - (r._additional.distance || 0), // Convert distance to similarity
+            metadata: r.metadata,
+            content: r.content,
+            vector: r._additional.vector
+        }));
+    }
+    async delete(params) {
+        const className = this.toClassName(params.indexName);
+        if (params.ids) {
+            for (const id of params.ids) {
+                await this.request(`/v1/objects/${className}/${id}`, { method: 'DELETE' });
+            }
+        }
+        else if (params.filter) {
+            // Delete by filter using batch delete
+            const conditions = Object.entries(params.filter).map(([key, value]) => ({
+                path: ['metadata', key],
+                operator: 'Equal',
+                valueString: String(value)
+            }));
+            await this.request('/v1/batch/objects', {
+                method: 'DELETE',
+                body: JSON.stringify({
+                    match: {
+                        class: className,
+                        where: { operator: 'And', operands: conditions }
+                    }
+                })
+            });
+        }
+    }
+    async update(indexName, id, metadata) {
+        const className = this.toClassName(indexName);
+        await this.request(`/v1/objects/${className}/${id}`, {
+            method: 'PATCH',
+            body: JSON.stringify({
+                properties: { metadata }
+            })
+        });
+    }
+}
+exports.WeaviateVectorStore = WeaviateVectorStore;
+function createWeaviateStore(config) {
+    return new WeaviateVectorStore(config);
+}

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;