praisonai 1.1.0 → 1.2.1

package/dist/auto/index.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * AutoAgents - Automatic agent generation from task descriptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAgents = void 0;
+exports.createAutoAgents = createAutoAgents;
+const providers_1 = require("../llm/providers");
+/**
+ * AutoAgents - Generate agent configurations from task descriptions
+ */
+class AutoAgents {
+    constructor(config = {}) {
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.pattern = config.pattern || 'sequential';
+        this.singleAgent = config.singleAgent ?? false;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Generate agent configuration from task description
+     */
+    async generate(taskDescription) {
+        const prompt = this.buildPrompt(taskDescription);
+        const result = await this.provider.generateText({
+            messages: [
+                { role: 'system', content: this.getSystemPrompt() },
+                { role: 'user', content: prompt }
+            ]
+        });
+        return this.parseResponse(result.text);
+    }
+    /**
+     * Recommend a pattern for the task
+     */
+    recommendPattern(taskDescription) {
+        const lower = taskDescription.toLowerCase();
+        if (lower.includes('parallel') || lower.includes('concurrent') || lower.includes('simultaneously')) {
+            return 'parallel';
+        }
+        if (lower.includes('route') || lower.includes('classify') || lower.includes('categorize')) {
+            return 'routing';
+        }
+        if (lower.includes('orchestrat') || lower.includes('coordinat') || lower.includes('manage')) {
+            return 'orchestrator-workers';
+        }
+        if (lower.includes('evaluat') || lower.includes('optimi') || lower.includes('improv')) {
+            return 'evaluator-optimizer';
+        }
+        return 'sequential';
+    }
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(taskDescription) {
+        const words = taskDescription.split(/\s+/).length;
+        const hasMultipleSteps = /step|then|after|before|first|second|third|finally/i.test(taskDescription);
+        const hasMultipleAgents = /team|multiple|several|different|various/i.test(taskDescription);
+        if (words < 20 && !hasMultipleSteps && !hasMultipleAgents) {
+            return 'simple';
+        }
+        if (words > 100 || (hasMultipleSteps && hasMultipleAgents)) {
+            return 'complex';
+        }
+        return 'moderate';
+    }
+    getSystemPrompt() {
+        return `You are an AI agent architect. Your job is to analyze task descriptions and generate optimal agent configurations.
+
+Output a JSON object with the following structure:
+{
+  "agents": [
+    {
+      "name": "AgentName",
+      "role": "Role description",
+      "goal": "Agent's goal",
+      "backstory": "Optional backstory",
+      "instructions": "Specific instructions",
+      "tools": ["tool1", "tool2"]
+    }
+  ],
+  "tasks": [
+    {
+      "description": "Task description",
+      "expectedOutput": "What the task should produce",
+      "agent": "AgentName"
+    }
+  ],
+  "pattern": "sequential|parallel|hierarchical"
+}
+
+Guidelines:
+- For simple tasks, use 1 agent
+- For moderate tasks, use 2-3 agents
+- For complex tasks, use 3-5 agents
+- Match the pattern to the task requirements
+- Be specific about roles and goals`;
+    }
+    buildPrompt(taskDescription) {
+        const complexity = this.analyzeComplexity(taskDescription);
+        const recommendedPattern = this.recommendPattern(taskDescription);
+        return `Task Description: ${taskDescription}
+
+Complexity: ${complexity}
+Recommended Pattern: ${this.pattern || recommendedPattern}
+Single Agent Mode: ${this.singleAgent}
+
+Generate an optimal agent configuration for this task.`;
+    }
+    parseResponse(response) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch (error) {
+            // Fallback to default structure
+        }
+        // Default fallback
+        return {
+            agents: [{
+                    name: 'GeneralAgent',
+                    role: 'General purpose agent',
+                    goal: 'Complete the assigned task',
+                    instructions: 'Follow the task description carefully'
+                }],
+            tasks: [{
+                    description: 'Complete the task',
+                    agent: 'GeneralAgent'
+                }],
+            pattern: 'sequential'
+        };
+    }
+}
+exports.AutoAgents = AutoAgents;
+/**
+ * Create an AutoAgents instance
+ */
+function createAutoAgents(config) {
+    return new AutoAgents(config);
+}

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,7 +3,7 @@ export * from './knowledge';
 export * from './llm';
 export * from './memory';
 export * from './process';
-export { Tool, BaseTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
+export { BaseTool, ToolResult, ToolValidationError, validateTool, createTool, 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';
@@ -18,4 +18,14 @@ export { accuracyEval, performanceEval, reliabilityEval, EvalSuite, type EvalRes
 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,7 +14,8 @@ 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;
+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.createTool = exports.validateTool = exports.ToolValidationError = 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 = exports.Chunking = exports.createPromptExpanderAgent = exports.PromptExpanderAgent = void 0;
 // Export all public modules
 __exportStar(require("./agent"), exports);
 __exportStar(require("./knowledge"), exports);
@@ -24,6 +25,9 @@ __exportStar(require("./process"), 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, "ToolValidationError", { enumerable: true, get: function () { return tools_1.ToolValidationError; } });
+Object.defineProperty(exports, "validateTool", { enumerable: true, get: function () { return tools_1.validateTool; } });
+Object.defineProperty(exports, "createTool", { enumerable: true, get: function () { return tools_1.createTool; } });
 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; } });
@@ -81,6 +85,55 @@ Object.defineProperty(exports, "chat", { enumerable: true, get: function () { re
 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; } });

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;

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/memory/memory.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Memory System - Conversation and context memory management
+ */
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+    timestamp: number;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+}
+export interface MemoryConfig {
+    maxEntries?: number;
+    maxTokens?: number;
+    embeddingProvider?: EmbeddingProvider;
+}
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+export interface SearchResult {
+    entry: MemoryEntry;
+    score: number;
+}
+/**
+ * Memory class for managing conversation history and context
+ */
+export declare class Memory {
+    private entries;
+    private maxEntries;
+    private maxTokens;
+    private embeddingProvider?;
+    constructor(config?: MemoryConfig);
+    /**
+     * Add a memory entry
+     */
+    add(content: string, role: 'user' | 'assistant' | 'system', metadata?: Record<string, any>): Promise<MemoryEntry>;
+    /**
+     * Get a memory entry by ID
+     */
+    get(id: string): MemoryEntry | undefined;
+    /**
+     * Get all entries
+     */
+    getAll(): MemoryEntry[];
+    /**
+     * Get recent entries
+     */
+    getRecent(count: number): MemoryEntry[];
+    /**
+     * Search memory by text similarity
+     */
+    search(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Simple text search fallback
+     */
+    private textSearch;
+    /**
+     * Calculate cosine similarity
+     */
+    private cosineSimilarity;
+    /**
+     * Delete a memory entry
+     */
+    delete(id: string): boolean;
+    /**
+     * Clear all memory
+     */
+    clear(): void;
+    /**
+     * Get memory size
+     */
+    get size(): number;
+    /**
+     * Build context string from recent memory
+     */
+    buildContext(count?: number): string;
+    /**
+     * Export memory to JSON
+     */
+    toJSON(): MemoryEntry[];
+    /**
+     * Import memory from JSON
+     */
+    fromJSON(entries: MemoryEntry[]): void;
+    private generateId;
+    private enforceLimit;
+}
+/**
+ * Create a memory instance
+ */
+export declare function createMemory(config?: MemoryConfig): Memory;