praisonai 1.0.19 → 1.2.0

package/dist/knowledge/chunking.js

@@ -1 +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/rag.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Knowledge Base (RAG) - Retrieval Augmented Generation
+ */
+export interface Document {
+    id: string;
+    content: string;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+}
+export interface SearchResult {
+    document: Document;
+    score: number;
+}
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+export interface KnowledgeBaseConfig {
+    embeddingProvider?: EmbeddingProvider;
+    similarityThreshold?: number;
+    maxResults?: number;
+}
+/**
+ * Simple in-memory vector store for RAG
+ */
+export declare class KnowledgeBase {
+    private documents;
+    private embeddingProvider?;
+    private similarityThreshold;
+    private maxResults;
+    constructor(config?: KnowledgeBaseConfig);
+    /**
+     * Add a document to the knowledge base
+     */
+    add(doc: Omit<Document, 'embedding'>): Promise<Document>;
+    /**
+     * Add multiple documents
+     */
+    addBatch(docs: Array<Omit<Document, 'embedding'>>): Promise<Document[]>;
+    /**
+     * Get a document by ID
+     */
+    get(id: string): Document | undefined;
+    /**
+     * Delete a document
+     */
+    delete(id: string): boolean;
+    /**
+     * Search for similar documents
+     */
+    search(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Simple text-based search fallback
+     */
+    private textSearch;
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    private cosineSimilarity;
+    /**
+     * Get all documents
+     */
+    list(): Document[];
+    /**
+     * Clear all documents
+     */
+    clear(): void;
+    /**
+     * Get document count
+     */
+    get size(): number;
+    /**
+     * Build context from search results for RAG
+     */
+    buildContext(results: SearchResult[]): string;
+}
+/**
+ * Create a knowledge base
+ */
+export declare function createKnowledgeBase(config?: KnowledgeBaseConfig): KnowledgeBase;

package/dist/knowledge/rag.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Knowledge Base (RAG) - Retrieval Augmented Generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnowledgeBase = void 0;
+exports.createKnowledgeBase = createKnowledgeBase;
+/**
+ * Simple in-memory vector store for RAG
+ */
+class KnowledgeBase {
+    constructor(config = {}) {
+        this.documents = new Map();
+        this.embeddingProvider = config.embeddingProvider;
+        this.similarityThreshold = config.similarityThreshold ?? 0.7;
+        this.maxResults = config.maxResults ?? 5;
+    }
+    /**
+     * Add a document to the knowledge base
+     */
+    async add(doc) {
+        const document = { ...doc };
+        if (this.embeddingProvider) {
+            document.embedding = await this.embeddingProvider.embed(doc.content);
+        }
+        this.documents.set(doc.id, document);
+        return document;
+    }
+    /**
+     * Add multiple documents
+     */
+    async addBatch(docs) {
+        if (this.embeddingProvider && docs.length > 0) {
+            const embeddings = await this.embeddingProvider.embedBatch(docs.map(d => d.content));
+            return Promise.all(docs.map(async (doc, i) => {
+                const document = { ...doc, embedding: embeddings[i] };
+                this.documents.set(doc.id, document);
+                return document;
+            }));
+        }
+        return Promise.all(docs.map(doc => this.add(doc)));
+    }
+    /**
+     * Get a document by ID
+     */
+    get(id) {
+        return this.documents.get(id);
+    }
+    /**
+     * Delete a document
+     */
+    delete(id) {
+        return this.documents.delete(id);
+    }
+    /**
+     * Search for similar documents
+     */
+    async search(query, limit) {
+        const maxResults = limit ?? this.maxResults;
+        if (!this.embeddingProvider) {
+            // Fallback to simple text matching
+            return this.textSearch(query, maxResults);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const doc of this.documents.values()) {
+            if (doc.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, doc.embedding);
+                if (score >= this.similarityThreshold) {
+                    results.push({ document: doc, score });
+                }
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, maxResults);
+    }
+    /**
+     * Simple text-based search fallback
+     */
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const doc of this.documents.values()) {
+            const contentLower = doc.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ document: doc, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Calculate cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Get all documents
+     */
+    list() {
+        return Array.from(this.documents.values());
+    }
+    /**
+     * Clear all documents
+     */
+    clear() {
+        this.documents.clear();
+    }
+    /**
+     * Get document count
+     */
+    get size() {
+        return this.documents.size;
+    }
+    /**
+     * Build context from search results for RAG
+     */
+    buildContext(results) {
+        if (results.length === 0)
+            return '';
+        return results
+            .map((r, i) => `[${i + 1}] ${r.document.content}`)
+            .join('\n\n');
+    }
+}
+exports.KnowledgeBase = KnowledgeBase;
+/**
+ * Create a knowledge base
+ */
+function createKnowledgeBase(config) {
+    return new KnowledgeBase(config);
+}

package/dist/llm/openai.js

@@ -73,7 +73,7 @@ async function getOpenAIClient() {
     return openAIInstance;
 }
 class OpenAIService {
-    constructor(model = 'gpt-4o-mini') {
+    constructor(model = 'gpt-5-nano') {
         this.client = null;
         this.model = model;
         logger_1.Logger.debug(`OpenAIService initialized with model: ${model}`);

package/dist/llm/providers/anthropic.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Anthropic Provider - Implementation for Anthropic Claude API
+ */
+import { BaseProvider } from './base';
+import type { ProviderConfig, GenerateTextOptions, GenerateTextResult, StreamTextOptions, StreamChunk, GenerateObjectOptions, GenerateObjectResult, Message, ToolDefinition } from './types';
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        tool_use_id?: string;
+        content?: string;
+    }>;
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, any>;
+}
+export declare class AnthropicProvider extends BaseProvider {
+    readonly providerId = "anthropic";
+    private apiKey;
+    private baseUrl;
+    constructor(modelId: string, config?: ProviderConfig);
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+    private extractSystemPrompt;
+    protected formatMessages(messages: Message[]): AnthropicMessage[];
+    protected formatTools(tools: ToolDefinition[]): AnthropicTool[];
+    private mapStopReason;
+}
+export {};