praisonai 1.2.1 → 1.2.2

package/dist/integrations/observability/langfuse.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Langfuse Observability Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LangfuseObservabilityProvider = void 0;
+exports.createLangfuseObservability = createLangfuseObservability;
+const base_1 = require("./base");
+class LangfuseObservabilityProvider extends base_1.BaseObservabilityProvider {
+    constructor(config) {
+        super('LangfuseObservability');
+        this.queue = [];
+        this.publicKey = config.publicKey;
+        this.secretKey = config.secretKey;
+        this.baseUrl = config.baseUrl || 'https://cloud.langfuse.com';
+        this.flushAt = config.flushAt || 20;
+        this.flushInterval = config.flushInterval || 10000;
+        this.startFlushTimer();
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => {
+            if (this.queue.length > 0) {
+                this.flush();
+            }
+        }, this.flushInterval);
+    }
+    async request(path, body) {
+        const auth = Buffer.from(`${this.publicKey}:${this.secretKey}`).toString('base64');
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Basic ${auth}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Langfuse API error: ${response.status} - ${error}`);
+        }
+        return response.json();
+    }
+    enqueue(event) {
+        this.queue.push(event);
+        if (this.queue.length >= this.flushAt) {
+            this.flush();
+        }
+    }
+    startSpan(name, attributes, parentContext) {
+        const span = {
+            id: this.generateId(),
+            traceId: parentContext?.traceId || this.generateId(),
+            parentId: parentContext?.spanId,
+            name,
+            startTime: Date.now(),
+            status: 'unset',
+            attributes: attributes || {},
+            events: []
+        };
+        // Create trace if this is root span
+        if (!parentContext) {
+            this.enqueue({
+                type: 'trace-create',
+                body: {
+                    id: span.traceId,
+                    name,
+                    metadata: attributes,
+                    timestamp: new Date(span.startTime).toISOString()
+                }
+            });
+        }
+        // Create span/generation
+        this.enqueue({
+            type: 'span-create',
+            body: {
+                id: span.id,
+                traceId: span.traceId,
+                parentObservationId: span.parentId,
+                name,
+                startTime: new Date(span.startTime).toISOString(),
+                metadata: attributes
+            }
+        });
+        return span;
+    }
+    endSpan(span, status = 'ok', error) {
+        span.endTime = Date.now();
+        span.status = status;
+        const updateBody = {
+            spanId: span.id,
+            endTime: new Date(span.endTime).toISOString(),
+            level: status === 'error' ? 'ERROR' : 'DEFAULT'
+        };
+        if (error) {
+            updateBody.statusMessage = error.message;
+        }
+        this.enqueue({
+            type: 'span-update',
+            body: updateBody
+        });
+    }
+    addSpanEvent(span, name, attributes) {
+        span.events.push({
+            name,
+            timestamp: Date.now(),
+            attributes
+        });
+        this.enqueue({
+            type: 'event-create',
+            body: {
+                traceId: span.traceId,
+                observationId: span.id,
+                name,
+                metadata: attributes,
+                timestamp: new Date().toISOString()
+            }
+        });
+    }
+    log(entry) {
+        // Langfuse doesn't have direct log support, use events instead
+        if (entry.traceId) {
+            this.enqueue({
+                type: 'event-create',
+                body: {
+                    traceId: entry.traceId,
+                    observationId: entry.spanId,
+                    name: `log:${entry.level}`,
+                    metadata: {
+                        message: entry.message,
+                        ...entry.attributes
+                    },
+                    timestamp: new Date(entry.timestamp).toISOString()
+                }
+            });
+        }
+    }
+    recordMetric(metric) {
+        // Langfuse uses scores for metrics
+        this.enqueue({
+            type: 'score-create',
+            body: {
+                name: metric.name,
+                value: metric.value,
+                timestamp: new Date(metric.timestamp).toISOString(),
+                comment: JSON.stringify(metric.tags)
+            }
+        });
+    }
+    async flush() {
+        if (this.queue.length === 0)
+            return;
+        const batch = this.queue.splice(0, this.queue.length);
+        try {
+            await this.request('/api/public/ingestion', {
+                batch
+            });
+        }
+        catch (error) {
+            // Re-add failed items to queue
+            this.queue.unshift(...batch);
+            console.error('Langfuse flush error:', error);
+        }
+    }
+    async shutdown() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        await this.flush();
+    }
+}
+exports.LangfuseObservabilityProvider = LangfuseObservabilityProvider;
+function createLangfuseObservability(config) {
+    return new LangfuseObservabilityProvider(config);
+}

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);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Vector Store Integrations
+ * Provides adapters for various vector databases
+ */
+export * from './base';
+export * from './pinecone';
+export * from './weaviate';
+export * from './qdrant';
+export * from './chroma';
+export { createMemoryVectorStore } from './base';
+export { createPineconeStore } from './pinecone';
+export { createWeaviateStore } from './weaviate';
+export { createQdrantStore } from './qdrant';
+export { createChromaStore } from './chroma';

package/dist/integrations/vector/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Vector Store Integrations
+ * Provides adapters for various vector databases
+ */
+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.createChromaStore = exports.createQdrantStore = exports.createWeaviateStore = exports.createPineconeStore = exports.createMemoryVectorStore = void 0;
+__exportStar(require("./base"), exports);
+__exportStar(require("./pinecone"), exports);
+__exportStar(require("./weaviate"), exports);
+__exportStar(require("./qdrant"), exports);
+__exportStar(require("./chroma"), exports);
+// Re-export factory functions for convenience
+var base_1 = require("./base");
+Object.defineProperty(exports, "createMemoryVectorStore", { enumerable: true, get: function () { return base_1.createMemoryVectorStore; } });
+var pinecone_1 = require("./pinecone");
+Object.defineProperty(exports, "createPineconeStore", { enumerable: true, get: function () { return pinecone_1.createPineconeStore; } });
+var weaviate_1 = require("./weaviate");
+Object.defineProperty(exports, "createWeaviateStore", { enumerable: true, get: function () { return weaviate_1.createWeaviateStore; } });
+var qdrant_1 = require("./qdrant");
+Object.defineProperty(exports, "createQdrantStore", { enumerable: true, get: function () { return qdrant_1.createQdrantStore; } });
+var chroma_1 = require("./chroma");
+Object.defineProperty(exports, "createChromaStore", { enumerable: true, get: function () { return chroma_1.createChromaStore; } });

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

@@ -0,0 +1,28 @@
+/**
+ * Pinecone Vector Store Integration
+ */
+import { BaseVectorStore, CreateIndexParams, UpsertParams, QueryParams, DeleteParams, QueryResult, IndexStats } from './base';
+export interface PineconeConfig {
+    apiKey: string;
+    environment?: string;
+    projectId?: string;
+}
+export declare class PineconeVectorStore extends BaseVectorStore {
+    private apiKey;
+    private baseUrl;
+    private indexHosts;
+    constructor(config: PineconeConfig & {
+        id?: string;
+    });
+    private request;
+    private indexRequest;
+    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 createPineconeStore(config: PineconeConfig): PineconeVectorStore;