chat-agent-toolkit 1.2.1 → 1.2.3

package/dist/memory/mastra-integration.d.ts

@@ -0,0 +1,146 @@
+import { Mastra } from '@mastra/core';
+import { Agent } from '@mastra/core/agent';
+import { D1Database, KVNamespace } from '@cloudflare/workers-types';
+import { IMemoryStorage } from './storage/storage-interface';
+import { MemoryRecord, MemoryType, MemorySearchOptions, MemoryUpdate } from './types';
+/**
+ * Cloudflare Workers environment bindings
+ */
+export interface CloudflareEnv {
+    DB?: D1Database;
+    KV?: KVNamespace;
+    OPENAI_API_KEY?: string;
+    ANTHROPIC_API_KEY?: string;
+    GROQ_API_KEY?: string;
+}
+/**
+ * Storage backend types for Mastra memory
+ */
+export type MastraStorageBackend = 'memory' | 'd1' | 'kv';
+/**
+ * Configuration for Mastra memory integration
+ */
+export interface MastraMemoryConfig {
+    /** Storage backend (memory, d1, or kv) */
+    storage: MastraStorageBackend;
+    /** Cloudflare environment bindings */
+    env?: CloudflareEnv;
+    /** D1 table name (for d1 storage) */
+    tableName?: string;
+    /** KV key prefix (for kv storage) */
+    kvPrefix?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * D1-based storage adapter for Mastra Memory
+ * Implements IMemoryStorage using Cloudflare D1
+ */
+export declare class MastraD1MemoryStorage implements IMemoryStorage {
+    private db;
+    private tableName;
+    constructor(db: D1Database, tableName?: string);
+    /**
+     * Initialize D1 schema for Mastra memory
+     */
+    initSchema(): Promise<void>;
+    insertMemory(userId: string, memoryType: MemoryType, content: string, importance: number, metadata?: Record<string, any>): Promise<string>;
+    findMemories(userId: string, query?: string, limit?: number, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    findSimilarMemories(userId: string, content: string, limit?: number): Promise<MemoryRecord[]>;
+    updateMemory(id: string, updates: MemoryUpdate): Promise<void>;
+    deleteMemory(id: string): Promise<void>;
+    getMemoryById(id: string): Promise<MemoryRecord | null>;
+    batchUpdateMemories(updates: Array<{
+        id: string;
+        updates: MemoryUpdate;
+    }>): Promise<void>;
+}
+/**
+ * KV-based storage adapter for Mastra Memory
+ * Uses Cloudflare KV for simple key-value storage
+ */
+export declare class MastraKVMemoryStorage implements IMemoryStorage {
+    private kv;
+    private prefix;
+    constructor(kv: KVNamespace, prefix?: string);
+    private getUserKey;
+    private getMemoryKey;
+    insertMemory(userId: string, memoryType: MemoryType, content: string, importance: number, metadata?: Record<string, any>): Promise<string>;
+    findMemories(userId: string, query?: string, limit?: number, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    findSimilarMemories(userId: string, content: string, limit?: number): Promise<MemoryRecord[]>;
+    updateMemory(id: string, updates: MemoryUpdate): Promise<void>;
+    deleteMemory(id: string): Promise<void>;
+    getMemoryById(id: string): Promise<MemoryRecord | null>;
+    batchUpdateMemories(updates: Array<{
+        id: string;
+        updates: MemoryUpdate;
+    }>): Promise<void>;
+}
+/**
+ * Mastra Memory Manager for Cloudflare Workers
+ * Wraps Mastra's memory system with Cloudflare-compatible storage
+ */
+export declare class MastraMemoryManager {
+    private mastra;
+    private storage;
+    private config;
+    constructor(config: MastraMemoryConfig);
+    /**
+     * Initialize Mastra instance with memory
+     */
+    initialize(): Promise<Mastra>;
+    /**
+     * Get storage instance (for direct access)
+     */
+    getStorage(): IMemoryStorage;
+    /**
+     * Create an agent with memory
+     */
+    createAgent(config: {
+        id: string;
+        name: string;
+        instructions: string;
+        model: any;
+        tools?: Record<string, any>;
+        userId: string;
+        threadId?: string;
+        resourceId?: string;
+    }): Promise<Agent>;
+    /**
+     * Store a message in memory
+     */
+    storeMessage(userId: string, threadId: string, role: 'user' | 'assistant', content: string, metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Recall conversation history
+     */
+    recallConversation(userId: string, threadId: string, limit?: number): Promise<Array<{
+        role: 'user' | 'assistant';
+        content: string;
+        timestamp: Date;
+    }>>;
+    /**
+     * Get relevant context for a query
+     */
+    getRelevantContext(userId: string, query: string, limit?: number): Promise<string>;
+}
+/**
+ * Quick helper to create Mastra memory manager for Cloudflare Workers
+ *
+ * @example
+ * ```ts
+ * const memoryManager = createMastraMemory({
+ *   storage: 'd1',
+ *   env: env, // Cloudflare env bindings
+ * });
+ *
+ * const agent = await memoryManager.createAgent({
+ *   id: 'assistant',
+ *   name: 'AI Assistant',
+ *   instructions: 'Help users with their questions',
+ *   model: openai('gpt-4o'),
+ *   userId: 'user-123',
+ *   threadId: 'conversation-1',
+ * });
+ * ```
+ */
+export declare function createMastraMemory(config: MastraMemoryConfig): MastraMemoryManager;

package/dist/memory/storage/drizzle-storage.d.ts

@@ -0,0 +1,82 @@
+import { IMemoryStorage } from './storage-interface';
+import { MemoryRecord, MemoryType, MemorySearchOptions, MemoryUpdate } from '../types';
+/**
+ * The Drizzle table passed to {@link DrizzleMemoryStorage} must expose these
+ * columns (see {@link createMemorySchema} for the expected shape).
+ */
+export interface MemoryTable {
+    id: any;
+    user_id: any;
+    memory_type: any;
+    content: any;
+    importance: any;
+    access_count: any;
+    metadata: any;
+    created_at: any;
+    updated_at: any;
+}
+/**
+ * Drizzle-based storage adapter.
+ *
+ * Pass the Drizzle database instance and the memory table object defined in
+ * your schema (not a table-name string) so queries reference real columns:
+ *
+ * ```ts
+ * import { sqliteTable, text, integer, real } from "drizzle-orm/sqlite-core";
+ * const userMemories = sqliteTable("user_memories", { ... });
+ * const storage = new DrizzleMemoryStorage(db, userMemories);
+ * ```
+ */
+export declare class DrizzleMemoryStorage implements IMemoryStorage {
+    private db;
+    private table;
+    constructor(db: any, table: MemoryTable & Record<string, any>);
+    /**
+     * Insert a new memory record
+     */
+    insertMemory(userId: string, memoryType: MemoryType, content: string, importance: number, metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Find memories by user ID and optional filters
+     */
+    findMemories(userId: string, query?: string, limit?: number, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    /**
+     * Find similar memories based on content
+     */
+    findSimilarMemories(userId: string, content: string, limit?: number): Promise<MemoryRecord[]>;
+    /**
+     * Update a memory record
+     */
+    updateMemory(id: string, updates: MemoryUpdate): Promise<void>;
+    /**
+     * Delete a memory record
+     */
+    deleteMemory(id: string): Promise<void>;
+    /**
+     * Get memory by ID
+     */
+    getMemoryById(id: string): Promise<MemoryRecord | null>;
+    /**
+     * Batch update memories
+     */
+    batchUpdateMemories(updates: Array<{
+        id: string;
+        updates: MemoryUpdate;
+    }>): Promise<void>;
+}
+/**
+ * Database schema for memory system
+ * This is kept here for reference but should be managed by your migration system
+ */
+export declare function createMemorySchema(db: any): {
+    user_memories: {
+        id: string;
+        user_id: string;
+        memory_type: string;
+        content: string;
+        importance: string;
+        access_count: string;
+        metadata: string;
+        created_at: string;
+        updated_at: string;
+    };
+};

package/dist/memory/storage/in-memory-storage.d.ts

@@ -0,0 +1,75 @@
+import { IMemoryStorage } from './storage-interface';
+import { MemoryRecord, MemorySearchOptions, MemoryMetrics, MemoryOptions, MemoryContextOptions, MemoryType } from '../types';
+export declare class SimpleMemory {
+    private userId;
+    private storage;
+    private maxMemories;
+    private summaryThreshold;
+    private cacheExpiry;
+    private batchSize;
+    private relevanceThreshold;
+    private enableVectorSearch;
+    private enableAutoSummarization;
+    private recentMessages;
+    private memoryCache;
+    private isProcessing;
+    private processingQueue;
+    private summarizeTimeout?;
+    private metrics;
+    /**
+     * Initialize memory system for a user
+     */
+    constructor(userId: string, storage: IMemoryStorage, options?: MemoryOptions);
+    /**
+     * Add a message to current session with intelligent deduplication
+     */
+    addMessage(role: "user" | "assistant", content: string, metadata?: Record<string, any>): boolean;
+    /**
+     * Debounced summarization to prevent excessive processing
+     */
+    private debouncedSummarize;
+    /**
+     * Store important facts with validation and conflict resolution
+     */
+    storeFact(content: string, importance?: number, category?: MemoryType, metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Find similar facts using content similarity
+     */
+    private findSimilarFacts;
+    /**
+     * Enhanced memory recall with caching and vector search
+     */
+    recallRelevantMemories(query?: string, limit?: number, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    /**
+     * Apply vector search to memories
+     */
+    private applyVectorSearch;
+    /**
+     * Update relevance scores for memories
+     */
+    private updateRelevanceScores;
+    /**
+     * Improved summarization with error handling and batch processing
+     */
+    summarizeAndStore(): Promise<boolean>;
+    /**
+     * Extract facts from conversation using LLM
+     */
+    private extractFactsFromConversation;
+    /**
+     * Process facts in batches to avoid overwhelming the database
+     */
+    private processFactsInBatches;
+    /**
+     * Clear cache utility
+     */
+    clearCache(): void;
+    /**
+     * Get memory context with better formatting and relevance
+     */
+    getMemoryContext(query?: string, includeRecent?: boolean, options?: MemoryContextOptions): Promise<string>;
+    /**
+     * Get performance metrics
+     */
+    getMetrics(): MemoryMetrics;
+}

package/dist/memory/storage/storage-interface.d.ts

@@ -0,0 +1,37 @@
+import { MemoryRecord, MemoryType, MemorySearchOptions, MemoryUpdate } from '../types';
+/**
+ * Storage interface that any database adapter must implement
+ */
+export interface IMemoryStorage {
+    /**
+     * Insert a new memory record
+     */
+    insertMemory(userId: string, memoryType: MemoryType, content: string, importance: number, metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Find memories by user ID and optional filters
+     */
+    findMemories(userId: string, query?: string, limit?: number, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    /**
+     * Find similar memories based on content
+     */
+    findSimilarMemories(userId: string, content: string, limit?: number): Promise<MemoryRecord[]>;
+    /**
+     * Update a memory record
+     */
+    updateMemory(id: string, updates: MemoryUpdate): Promise<void>;
+    /**
+     * Delete a memory record
+     */
+    deleteMemory(id: string): Promise<void>;
+    /**
+     * Get memory by ID
+     */
+    getMemoryById(id: string): Promise<MemoryRecord | null>;
+    /**
+     * Batch update memories
+     */
+    batchUpdateMemories(updates: Array<{
+        id: string;
+        updates: MemoryUpdate;
+    }>): Promise<void>;
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Memory System Types and Constants
+ *
+ * Defines interfaces and configuration for the memory management system
+ */
+/**
+ * Memory types for categorization
+ */
+export declare const MEMORY_TYPES: {
+    readonly FACT: "fact";
+    readonly CONVERSATION: "conversation";
+    readonly PREFERENCE: "preference";
+    readonly PERSONAL: "personal";
+    readonly WORK: "work";
+    readonly MANUAL: "manual";
+};
+export type MemoryType = (typeof MEMORY_TYPES)[keyof typeof MEMORY_TYPES];
+/**
+ * Configuration constants for memory management
+ */
+export declare const MEMORY_CONFIG: {
+    readonly DEFAULT_MAX_MEMORIES: 100;
+    readonly DEFAULT_SUMMARY_THRESHOLD: 10;
+    readonly DEFAULT_CACHE_EXPIRY: number;
+    readonly DEFAULT_BATCH_SIZE: 5;
+    readonly DEFAULT_RELEVANCE_THRESHOLD: 0.3;
+    readonly DEFAULT_IMPORTANCE_RANGE: {
+        readonly min: 0;
+        readonly max: 10;
+    };
+    readonly DEFAULT_RATE_LIMIT: {
+        readonly requests: 10;
+        readonly windowMs: 60000;
+    };
+    readonly DEFAULT_TIMEOUT: 30000;
+    readonly VECTOR_SEARCH_ENABLED: true;
+    readonly AUTO_SUMMARIZATION_ENABLED: true;
+};
+/**
+ * Memory record structure
+ */
+export interface MemoryRecord {
+    id: string;
+    user_id: string;
+    memory_type: MemoryType;
+    content: string;
+    importance: number;
+    access_count: number;
+    metadata?: Record<string, any>;
+    created_at: Date;
+    updated_at: Date;
+    relevance_score?: number;
+}
+/**
+ * Message structure for conversation tracking
+ */
+export interface Message {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Memory search options
+ */
+export interface MemorySearchOptions {
+    minImportance?: number;
+    memoryType?: MemoryType;
+    includeMetadata?: boolean;
+}
+/**
+ * Memory update payload
+ */
+export interface MemoryUpdate {
+    importance?: number;
+    access_count?: number | {
+        increment: number;
+    };
+    updated_at?: Date;
+    metadata?: Record<string, any>;
+}
+/**
+ * Memory context options
+ */
+export interface MemoryContextOptions {
+    maxMemories?: number;
+    minImportance?: number;
+}
+/**
+ * Performance metrics
+ */
+export interface MemoryMetrics {
+    cacheHits: number;
+    cacheMisses: number;
+    vectorSearches: number;
+    summarizations: number;
+    errors: number;
+    cacheSize: number;
+    recentMessagesCount: number;
+    isProcessing: boolean;
+}
+/**
+ * Memory initialization options
+ */
+export interface MemoryOptions {
+    maxMemories?: number;
+    summaryThreshold?: number;
+    cacheExpiry?: number;
+    batchSize?: number;
+    relevanceThreshold?: number;
+    enableVectorSearch?: boolean;
+    enableAutoSummarization?: boolean;
+}
+/**
+ * Extracted fact structure
+ */
+export interface ExtractedFact {
+    content: string;
+    importance?: number;
+    category?: MemoryType;
+    metadata?: Record<string, any>;
+}

package/dist/models/providers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module agent-toolkit/models/providers
+ * @description Re-export provider UI configuration
+ */
+export { getModelProvidersUIConfigSection } from '../config/provider-ui-config';

package/dist/models/registry.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @fileoverview Re-export ModelRegistry from config directory
+ */
+export { default } from '../config/model-registry';

package/dist/models/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @fileoverview Re-export model types from config directory
+ */
+export type { Model, ConfigModelProvider, MinimalProvider } from '../config/config-types';