praisonai 1.0.19 → 1.2.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/guardrails/llm-guardrail.d.ts

@@ -0,0 +1,40 @@
+/**
+ * LLMGuardrail - LLM-based content validation
+ */
+export interface LLMGuardrailConfig {
+    name: string;
+    criteria: string;
+    llm?: string;
+    threshold?: number;
+    verbose?: boolean;
+}
+export interface LLMGuardrailResult {
+    status: 'passed' | 'failed' | 'warning';
+    score: number;
+    message?: string;
+    reasoning?: string;
+}
+/**
+ * LLMGuardrail - Use LLM to validate content against criteria
+ */
+export declare class LLMGuardrail {
+    readonly name: string;
+    readonly criteria: string;
+    private provider;
+    private threshold;
+    private verbose;
+    constructor(config: LLMGuardrailConfig);
+    /**
+     * Check content against criteria
+     */
+    check(content: string): Promise<LLMGuardrailResult>;
+    /**
+     * Run guardrail (alias for check)
+     */
+    run(content: string): Promise<LLMGuardrailResult>;
+    private parseResponse;
+}
+/**
+ * Create an LLMGuardrail
+ */
+export declare function createLLMGuardrail(config: LLMGuardrailConfig): LLMGuardrail;

package/dist/guardrails/llm-guardrail.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * LLMGuardrail - LLM-based content validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMGuardrail = void 0;
+exports.createLLMGuardrail = createLLMGuardrail;
+const providers_1 = require("../llm/providers");
+/**
+ * LLMGuardrail - Use LLM to validate content against criteria
+ */
+class LLMGuardrail {
+    constructor(config) {
+        this.name = config.name;
+        this.criteria = config.criteria;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.threshold = config.threshold ?? 0.7;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Check content against criteria
+     */
+    async check(content) {
+        const prompt = `Evaluate the following content against this criteria:
+
+Criteria: ${this.criteria}
+
+Content: ${content}
+
+Respond with a JSON object containing:
+- score: number from 0 to 1 (1 = fully meets criteria)
+- passed: boolean
+- reasoning: brief explanation
+
+JSON response:`;
+        try {
+            const result = await this.provider.generateText({
+                messages: [{ role: 'user', content: prompt }]
+            });
+            const parsed = this.parseResponse(result.text);
+            if (this.verbose) {
+                console.log(`[LLMGuardrail:${this.name}] Score: ${parsed.score}, Passed: ${parsed.status}`);
+            }
+            return parsed;
+        }
+        catch (error) {
+            return {
+                status: 'warning',
+                score: 0.5,
+                message: `Guardrail check failed: ${error.message}`
+            };
+        }
+    }
+    /**
+     * Run guardrail (alias for check)
+     */
+    async run(content) {
+        return this.check(content);
+    }
+    parseResponse(response) {
+        try {
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                const parsed = JSON.parse(jsonMatch[0]);
+                const score = typeof parsed.score === 'number' ? parsed.score : 0.5;
+                return {
+                    status: score >= this.threshold ? 'passed' : 'failed',
+                    score,
+                    reasoning: parsed.reasoning
+                };
+            }
+        }
+        catch (e) {
+            // Parse failed
+        }
+        // Fallback parsing
+        const hasPositive = /pass|good|valid|accept|meets/i.test(response);
+        return {
+            status: hasPositive ? 'passed' : 'failed',
+            score: hasPositive ? 0.8 : 0.3,
+            reasoning: response.substring(0, 200)
+        };
+    }
+}
+exports.LLMGuardrail = LLMGuardrail;
+/**
+ * Create an LLMGuardrail
+ */
+function createLLMGuardrail(config) {
+    return new LLMGuardrail(config);
+}

package/dist/index.d.ts

@@ -3,4 +3,29 @@ 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 { Memory, createMemory, type MemoryEntry, type MemoryConfig, type SearchResult as MemorySearchResult } from './memory/memory';
+export { TelemetryCollector, getTelemetry, enableTelemetry, disableTelemetry, cleanupTelemetry, type TelemetryEvent, type TelemetryConfig } from './telemetry';
+export { AutoAgents, createAutoAgents, type AgentConfig, type TaskConfig, type TeamStructure, type AutoAgentsConfig } from './auto';
+export { ImageAgent, createImageAgent, type ImageAgentConfig, type ImageGenerationConfig, type ImageAnalysisConfig } from './agent/image';
+export { DeepResearchAgent, createDeepResearchAgent, type DeepResearchConfig, type ResearchResponse, type Citation, type ReasoningStep } from './agent/research';
+export { QueryRewriterAgent, createQueryRewriterAgent, type QueryRewriterConfig, type RewriteResult, type RewriteStrategy } from './agent/query-rewriter';
+export { PromptExpanderAgent, createPromptExpanderAgent, type PromptExpanderConfig, type ExpandResult, type ExpandStrategy } from './agent/prompt-expander';
+export { Chunking, createChunking, type ChunkingConfig, type Chunk, type ChunkStrategy } from './knowledge/chunking';
+export { LLMGuardrail, createLLMGuardrail, type LLMGuardrailConfig, type LLMGuardrailResult } from './guardrails/llm-guardrail';
+export { Plan, PlanStep, TodoList, TodoItem, PlanStorage, createPlan, createTodoList, createPlanStorage, type PlanConfig, type PlanStepConfig, type TodoItemConfig, type PlanStatus, type TodoStatus } from './planning';
+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,131 @@ 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.Chunking = exports.createPromptExpanderAgent = exports.PromptExpanderAgent = exports.createQueryRewriterAgent = exports.QueryRewriterAgent = exports.createDeepResearchAgent = exports.DeepResearchAgent = exports.createImageAgent = exports.ImageAgent = exports.createAutoAgents = exports.AutoAgents = exports.cleanupTelemetry = exports.disableTelemetry = exports.enableTelemetry = exports.getTelemetry = exports.TelemetryCollector = exports.createMemory = exports.Memory = 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;
+exports.BaseProvider = exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.getAvailableProviders = exports.isProviderAvailable = exports.parseModelString = exports.getDefaultProvider = exports.createProvider = exports.createPlanStorage = exports.createTodoList = exports.createPlan = exports.PlanStorage = exports.TodoItem = exports.TodoList = exports.PlanStep = exports.Plan = exports.createLLMGuardrail = exports.LLMGuardrail = exports.createChunking = 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 Memory
+var memory_1 = require("./memory/memory");
+Object.defineProperty(exports, "Memory", { enumerable: true, get: function () { return memory_1.Memory; } });
+Object.defineProperty(exports, "createMemory", { enumerable: true, get: function () { return memory_1.createMemory; } });
+// Export Telemetry
+var telemetry_1 = require("./telemetry");
+Object.defineProperty(exports, "TelemetryCollector", { enumerable: true, get: function () { return telemetry_1.TelemetryCollector; } });
+Object.defineProperty(exports, "getTelemetry", { enumerable: true, get: function () { return telemetry_1.getTelemetry; } });
+Object.defineProperty(exports, "enableTelemetry", { enumerable: true, get: function () { return telemetry_1.enableTelemetry; } });
+Object.defineProperty(exports, "disableTelemetry", { enumerable: true, get: function () { return telemetry_1.disableTelemetry; } });
+Object.defineProperty(exports, "cleanupTelemetry", { enumerable: true, get: function () { return telemetry_1.cleanupTelemetry; } });
+// Export AutoAgents
+var auto_1 = require("./auto");
+Object.defineProperty(exports, "AutoAgents", { enumerable: true, get: function () { return auto_1.AutoAgents; } });
+Object.defineProperty(exports, "createAutoAgents", { enumerable: true, get: function () { return auto_1.createAutoAgents; } });
+// Export ImageAgent
+var image_1 = require("./agent/image");
+Object.defineProperty(exports, "ImageAgent", { enumerable: true, get: function () { return image_1.ImageAgent; } });
+Object.defineProperty(exports, "createImageAgent", { enumerable: true, get: function () { return image_1.createImageAgent; } });
+// Export DeepResearchAgent
+var research_1 = require("./agent/research");
+Object.defineProperty(exports, "DeepResearchAgent", { enumerable: true, get: function () { return research_1.DeepResearchAgent; } });
+Object.defineProperty(exports, "createDeepResearchAgent", { enumerable: true, get: function () { return research_1.createDeepResearchAgent; } });
+// Export QueryRewriterAgent
+var query_rewriter_1 = require("./agent/query-rewriter");
+Object.defineProperty(exports, "QueryRewriterAgent", { enumerable: true, get: function () { return query_rewriter_1.QueryRewriterAgent; } });
+Object.defineProperty(exports, "createQueryRewriterAgent", { enumerable: true, get: function () { return query_rewriter_1.createQueryRewriterAgent; } });
+// Export PromptExpanderAgent
+var prompt_expander_1 = require("./agent/prompt-expander");
+Object.defineProperty(exports, "PromptExpanderAgent", { enumerable: true, get: function () { return prompt_expander_1.PromptExpanderAgent; } });
+Object.defineProperty(exports, "createPromptExpanderAgent", { enumerable: true, get: function () { return prompt_expander_1.createPromptExpanderAgent; } });
+// Export Chunking
+var chunking_1 = require("./knowledge/chunking");
+Object.defineProperty(exports, "Chunking", { enumerable: true, get: function () { return chunking_1.Chunking; } });
+Object.defineProperty(exports, "createChunking", { enumerable: true, get: function () { return chunking_1.createChunking; } });
+// Export LLMGuardrail
+var llm_guardrail_1 = require("./guardrails/llm-guardrail");
+Object.defineProperty(exports, "LLMGuardrail", { enumerable: true, get: function () { return llm_guardrail_1.LLMGuardrail; } });
+Object.defineProperty(exports, "createLLMGuardrail", { enumerable: true, get: function () { return llm_guardrail_1.createLLMGuardrail; } });
+// Export Planning
+var planning_1 = require("./planning");
+Object.defineProperty(exports, "Plan", { enumerable: true, get: function () { return planning_1.Plan; } });
+Object.defineProperty(exports, "PlanStep", { enumerable: true, get: function () { return planning_1.PlanStep; } });
+Object.defineProperty(exports, "TodoList", { enumerable: true, get: function () { return planning_1.TodoList; } });
+Object.defineProperty(exports, "TodoItem", { enumerable: true, get: function () { return planning_1.TodoItem; } });
+Object.defineProperty(exports, "PlanStorage", { enumerable: true, get: function () { return planning_1.PlanStorage; } });
+Object.defineProperty(exports, "createPlan", { enumerable: true, get: function () { return planning_1.createPlan; } });
+Object.defineProperty(exports, "createTodoList", { enumerable: true, get: function () { return planning_1.createTodoList; } });
+Object.defineProperty(exports, "createPlanStorage", { enumerable: true, get: function () { return planning_1.createPlanStorage; } });
+// 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/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;