praisonai 1.0.19 → 1.1.0

package/dist/guardrails/index.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Guardrails - Input/output validation and safety checks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtinGuardrails = exports.GuardrailManager = exports.Guardrail = void 0;
+exports.guardrail = guardrail;
+/**
+ * Guardrail class
+ */
+class Guardrail {
+    constructor(config) {
+        this.name = config.name;
+        this.description = config.description || `Guardrail: ${config.name}`;
+        this.check = config.check;
+        this.onFail = config.onFail || 'block';
+    }
+    async run(content, context) {
+        try {
+            return await this.check(content, context);
+        }
+        catch (error) {
+            return {
+                status: 'failed',
+                message: `Guardrail error: ${error.message}`,
+                details: { error: error.message },
+            };
+        }
+    }
+}
+exports.Guardrail = Guardrail;
+/**
+ * Create a guardrail
+ */
+function guardrail(config) {
+    return new Guardrail(config);
+}
+/**
+ * Guardrail Manager - Run multiple guardrails
+ */
+class GuardrailManager {
+    constructor() {
+        this.guardrails = [];
+    }
+    add(g) {
+        this.guardrails.push(g);
+        return this;
+    }
+    async runAll(content, context) {
+        const results = [];
+        let passed = true;
+        for (const g of this.guardrails) {
+            const result = await g.run(content, context);
+            results.push({ name: g.name, result });
+            if (result.status === 'failed') {
+                passed = false;
+                if (g.onFail === 'block') {
+                    break;
+                }
+            }
+        }
+        return { passed, results };
+    }
+    get count() {
+        return this.guardrails.length;
+    }
+}
+exports.GuardrailManager = GuardrailManager;
+/**
+ * Built-in guardrails
+ */
+exports.builtinGuardrails = {
+    /**
+     * Check for maximum length
+     */
+    maxLength: (maxChars) => {
+        return guardrail({
+            name: 'max_length',
+            description: `Ensure content is under ${maxChars} characters`,
+            check: (content) => {
+                if (content.length > maxChars) {
+                    return {
+                        status: 'failed',
+                        message: `Content exceeds maximum length of ${maxChars} characters`,
+                        details: { length: content.length, max: maxChars },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for minimum length
+     */
+    minLength: (minChars) => {
+        return guardrail({
+            name: 'min_length',
+            description: `Ensure content is at least ${minChars} characters`,
+            check: (content) => {
+                if (content.length < minChars) {
+                    return {
+                        status: 'failed',
+                        message: `Content is below minimum length of ${minChars} characters`,
+                        details: { length: content.length, min: minChars },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for blocked words
+     */
+    blockedWords: (words) => {
+        return guardrail({
+            name: 'blocked_words',
+            description: 'Check for blocked words',
+            check: (content) => {
+                const lowerContent = content.toLowerCase();
+                const found = words.filter(w => lowerContent.includes(w.toLowerCase()));
+                if (found.length > 0) {
+                    return {
+                        status: 'failed',
+                        message: `Content contains blocked words`,
+                        details: { blockedWords: found },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Check for required words
+     */
+    requiredWords: (words) => {
+        return guardrail({
+            name: 'required_words',
+            description: 'Check for required words',
+            check: (content) => {
+                const lowerContent = content.toLowerCase();
+                const missing = words.filter(w => !lowerContent.includes(w.toLowerCase()));
+                if (missing.length > 0) {
+                    return {
+                        status: 'failed',
+                        message: `Content missing required words`,
+                        details: { missingWords: missing },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * Regex pattern check
+     */
+    pattern: (regex, mustMatch = true) => {
+        return guardrail({
+            name: 'pattern',
+            description: `Check content against pattern: ${regex}`,
+            check: (content) => {
+                const matches = regex.test(content);
+                if (mustMatch && !matches) {
+                    return {
+                        status: 'failed',
+                        message: `Content does not match required pattern`,
+                        details: { pattern: regex.toString() },
+                    };
+                }
+                if (!mustMatch && matches) {
+                    return {
+                        status: 'failed',
+                        message: `Content matches forbidden pattern`,
+                        details: { pattern: regex.toString() },
+                    };
+                }
+                return { status: 'passed' };
+            },
+        });
+    },
+    /**
+     * JSON validity check
+     */
+    validJson: () => {
+        return guardrail({
+            name: 'valid_json',
+            description: 'Ensure content is valid JSON',
+            check: (content) => {
+                try {
+                    JSON.parse(content);
+                    return { status: 'passed' };
+                }
+                catch (e) {
+                    return {
+                        status: 'failed',
+                        message: 'Content is not valid JSON',
+                        details: { error: e.message },
+                    };
+                }
+            },
+        });
+    },
+};

package/dist/index.d.ts

@@ -3,4 +3,19 @@ export * from './knowledge';
 export * from './llm';
 export * from './memory';
 export * from './process';
-export * from './tools';
+export { Tool, BaseTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
+export * from './tools/arxivTools';
+export * from './tools/mcpSse';
+export * from './session';
+export * from './db';
+export * from './workflows';
+export * from './guardrails';
+export { Handoff, handoff, handoffFilters, type HandoffConfig, type HandoffContext, type HandoffResult } from './agent/handoff';
+export { RouterAgent, createRouter, routeConditions, type RouterConfig, type RouteConfig, type RouteContext } from './agent/router';
+export { ContextAgent, createContextAgent, type ContextAgentConfig, type ContextMessage } from './agent/context';
+export { KnowledgeBase, createKnowledgeBase, type Document, type SearchResult, type EmbeddingProvider, type KnowledgeBaseConfig } from './knowledge/rag';
+export { accuracyEval, performanceEval, reliabilityEval, EvalSuite, type EvalResult, type PerformanceResult, type AccuracyEvalConfig, type PerformanceEvalConfig, type ReliabilityEvalConfig } from './eval';
+export { MemoryObservabilityAdapter, ConsoleObservabilityAdapter, setObservabilityAdapter, getObservabilityAdapter, type ObservabilityAdapter, type TraceContext, type SpanContext, type SpanData, type TraceData } from './observability';
+export { SkillManager, createSkillManager, parseSkillFile, type Skill, type SkillMetadata, type SkillDiscoveryOptions } from './skills';
+export { chat, listProviders, version, help } from './cli';
+export { createProvider, getDefaultProvider, parseModelString, isProviderAvailable, getAvailableProviders, OpenAIProvider, AnthropicProvider, GoogleProvider, BaseProvider, type LLMProvider, type ProviderConfig, type ProviderFactory, type GenerateTextOptions, type GenerateTextResult, type StreamTextOptions, type StreamChunk, type GenerateObjectOptions, type GenerateObjectResult, type TokenUsage, type Message as ProviderMessage, type ToolCall, type ToolDefinition as ProviderToolDefinition, } from './llm/providers';

package/dist/index.js

@@ -14,10 +14,81 @@ 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.BaseProvider = exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.getAvailableProviders = exports.isProviderAvailable = exports.parseModelString = exports.getDefaultProvider = exports.createProvider = exports.help = exports.version = exports.listProviders = exports.chat = exports.parseSkillFile = exports.createSkillManager = exports.SkillManager = exports.getObservabilityAdapter = exports.setObservabilityAdapter = exports.ConsoleObservabilityAdapter = exports.MemoryObservabilityAdapter = exports.EvalSuite = exports.reliabilityEval = exports.performanceEval = exports.accuracyEval = exports.createKnowledgeBase = exports.KnowledgeBase = exports.createContextAgent = exports.ContextAgent = exports.routeConditions = exports.createRouter = exports.RouterAgent = exports.handoffFilters = exports.handoff = exports.Handoff = exports.getTool = exports.registerTool = exports.getRegistry = exports.ToolRegistry = exports.tool = exports.FunctionTool = exports.BaseTool = void 0;
 // Export all public modules
 __exportStar(require("./agent"), exports);
 __exportStar(require("./knowledge"), exports);
 __exportStar(require("./llm"), exports);
 __exportStar(require("./memory"), exports);
 __exportStar(require("./process"), exports);
-__exportStar(require("./tools"), exports);
+// Export tools (excluding conflicting types)
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return tools_1.BaseTool; } });
+Object.defineProperty(exports, "FunctionTool", { enumerable: true, get: function () { return tools_1.FunctionTool; } });
+Object.defineProperty(exports, "tool", { enumerable: true, get: function () { return tools_1.tool; } });
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return tools_1.ToolRegistry; } });
+Object.defineProperty(exports, "getRegistry", { enumerable: true, get: function () { return tools_1.getRegistry; } });
+Object.defineProperty(exports, "registerTool", { enumerable: true, get: function () { return tools_1.registerTool; } });
+Object.defineProperty(exports, "getTool", { enumerable: true, get: function () { return tools_1.getTool; } });
+__exportStar(require("./tools/arxivTools"), exports);
+__exportStar(require("./tools/mcpSse"), exports);
+// Export session management
+__exportStar(require("./session"), exports);
+// Export database adapters
+__exportStar(require("./db"), exports);
+// Export workflows
+__exportStar(require("./workflows"), exports);
+// Export guardrails
+__exportStar(require("./guardrails"), exports);
+// Export handoff
+var handoff_1 = require("./agent/handoff");
+Object.defineProperty(exports, "Handoff", { enumerable: true, get: function () { return handoff_1.Handoff; } });
+Object.defineProperty(exports, "handoff", { enumerable: true, get: function () { return handoff_1.handoff; } });
+Object.defineProperty(exports, "handoffFilters", { enumerable: true, get: function () { return handoff_1.handoffFilters; } });
+// Export router agent
+var router_1 = require("./agent/router");
+Object.defineProperty(exports, "RouterAgent", { enumerable: true, get: function () { return router_1.RouterAgent; } });
+Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return router_1.createRouter; } });
+Object.defineProperty(exports, "routeConditions", { enumerable: true, get: function () { return router_1.routeConditions; } });
+// Export context agent
+var context_1 = require("./agent/context");
+Object.defineProperty(exports, "ContextAgent", { enumerable: true, get: function () { return context_1.ContextAgent; } });
+Object.defineProperty(exports, "createContextAgent", { enumerable: true, get: function () { return context_1.createContextAgent; } });
+// Export knowledge base (RAG)
+var rag_1 = require("./knowledge/rag");
+Object.defineProperty(exports, "KnowledgeBase", { enumerable: true, get: function () { return rag_1.KnowledgeBase; } });
+Object.defineProperty(exports, "createKnowledgeBase", { enumerable: true, get: function () { return rag_1.createKnowledgeBase; } });
+// Export evaluation framework
+var eval_1 = require("./eval");
+Object.defineProperty(exports, "accuracyEval", { enumerable: true, get: function () { return eval_1.accuracyEval; } });
+Object.defineProperty(exports, "performanceEval", { enumerable: true, get: function () { return eval_1.performanceEval; } });
+Object.defineProperty(exports, "reliabilityEval", { enumerable: true, get: function () { return eval_1.reliabilityEval; } });
+Object.defineProperty(exports, "EvalSuite", { enumerable: true, get: function () { return eval_1.EvalSuite; } });
+// Export observability
+var observability_1 = require("./observability");
+Object.defineProperty(exports, "MemoryObservabilityAdapter", { enumerable: true, get: function () { return observability_1.MemoryObservabilityAdapter; } });
+Object.defineProperty(exports, "ConsoleObservabilityAdapter", { enumerable: true, get: function () { return observability_1.ConsoleObservabilityAdapter; } });
+Object.defineProperty(exports, "setObservabilityAdapter", { enumerable: true, get: function () { return observability_1.setObservabilityAdapter; } });
+Object.defineProperty(exports, "getObservabilityAdapter", { enumerable: true, get: function () { return observability_1.getObservabilityAdapter; } });
+// Export skills
+var skills_1 = require("./skills");
+Object.defineProperty(exports, "SkillManager", { enumerable: true, get: function () { return skills_1.SkillManager; } });
+Object.defineProperty(exports, "createSkillManager", { enumerable: true, get: function () { return skills_1.createSkillManager; } });
+Object.defineProperty(exports, "parseSkillFile", { enumerable: true, get: function () { return skills_1.parseSkillFile; } });
+// Export CLI
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "chat", { enumerable: true, get: function () { return cli_1.chat; } });
+Object.defineProperty(exports, "listProviders", { enumerable: true, get: function () { return cli_1.listProviders; } });
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return cli_1.version; } });
+Object.defineProperty(exports, "help", { enumerable: true, get: function () { return cli_1.help; } });
+// Export providers with explicit names to avoid conflicts
+var providers_1 = require("./llm/providers");
+Object.defineProperty(exports, "createProvider", { enumerable: true, get: function () { return providers_1.createProvider; } });
+Object.defineProperty(exports, "getDefaultProvider", { enumerable: true, get: function () { return providers_1.getDefaultProvider; } });
+Object.defineProperty(exports, "parseModelString", { enumerable: true, get: function () { return providers_1.parseModelString; } });
+Object.defineProperty(exports, "isProviderAvailable", { enumerable: true, get: function () { return providers_1.isProviderAvailable; } });
+Object.defineProperty(exports, "getAvailableProviders", { enumerable: true, get: function () { return providers_1.getAvailableProviders; } });
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return providers_1.OpenAIProvider; } });
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return providers_1.AnthropicProvider; } });
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return providers_1.GoogleProvider; } });
+Object.defineProperty(exports, "BaseProvider", { enumerable: true, get: function () { return providers_1.BaseProvider; } });

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 {};