@axiom-lattice/core 2.1.12 → 2.1.14

package/dist/index.d.mts

@@ -5,7 +5,7 @@ import { BaseChatModel, BaseChatModelCallOptions } from '@langchain/core/languag
 import { BaseLanguageModelInput } from '@langchain/core/language_models/base';
 import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import { ChatResult } from '@langchain/core/outputs';
-import { LLMConfig, ToolConfig, ToolExecutor, AgentConfig, GraphBuildOptions, MessageChunk, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ThreadStore, AssistantStore, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest } from '@axiom-lattice/protocols';
+import { LLMConfig, ToolConfig, ToolExecutor, AgentConfig, GraphBuildOptions, MessageChunk, QueueLatticeProtocol, QueueConfig, QueueClient, QueueResult, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduleStorage, TaskHandler, ScheduleOnceOptions, ScheduleCronOptions, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, ThreadStore, AssistantStore, Thread, CreateThreadRequest, Assistant, CreateAssistantRequest } from '@axiom-lattice/protocols';
 import * as protocols from '@axiom-lattice/protocols';
 export { protocols as Protocols };
 export { AgentConfig, AgentType, GraphBuildOptions, MemoryType } from '@axiom-lattice/protocols';
@@ -206,6 +206,168 @@ declare const modelLatticeManager: ModelLatticeManager;
 declare const registerModelLattice: (key: string, config: ModelConfig) => void;
 declare const getModelLattice: (key: string) => ModelLatticeInterface;
 
+/**
+ * SQL Tool Types
+ * Type definitions for SQL database tools
+ */
+/**
+ * Supported database types
+ */
+type DatabaseType = "postgres" | "mysql" | "sqlite";
+/**
+ * Database connection configuration
+ */
+interface DatabaseConfig {
+    type: DatabaseType;
+    host?: string;
+    port?: number;
+    database: string;
+    user?: string;
+    password?: string;
+    connectionString?: string;
+    ssl?: boolean;
+}
+/**
+ * Table information
+ */
+interface TableInfo {
+    name: string;
+    schema?: string;
+}
+/**
+ * Column information
+ */
+interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    default?: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    foreignKeyRef?: string;
+}
+/**
+ * Table schema information
+ */
+interface TableSchema {
+    tableName: string;
+    schema?: string;
+    columns: ColumnInfo[];
+    sampleRows?: Record<string, unknown>[];
+}
+/**
+ * Query result
+ */
+interface QueryResult {
+    rows: Record<string, unknown>[];
+    rowCount: number;
+    fields?: string[];
+}
+/**
+ * SQL Database interface
+ * Defines the contract for database implementations
+ */
+interface ISqlDatabase {
+    /**
+     * Connect to the database
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the database
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get list of all tables in the database
+     */
+    listTables(): Promise<TableInfo[]>;
+    /**
+     * Get schema information for specified tables
+     * @param tables - Array of table names
+     */
+    getTableInfo(tables: string[]): Promise<TableSchema[]>;
+    /**
+     * Execute a SQL query
+     * @param query - SQL query string
+     */
+    executeQuery(query: string): Promise<QueryResult>;
+    /**
+     * Get the database type
+     */
+    getDatabaseType(): DatabaseType;
+}
+
+/**
+ * SQL Database Manager
+ * Singleton manager for SQL database connections
+ */
+
+/**
+ * PostgreSQL Database Implementation
+ * Uses pg library for PostgreSQL connections
+ */
+declare class PostgresDatabase implements ISqlDatabase {
+    private config;
+    private pool;
+    private connected;
+    constructor(config: DatabaseConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTables(): Promise<TableInfo[]>;
+    getTableInfo(tables: string[]): Promise<TableSchema[]>;
+    executeQuery(query: string): Promise<QueryResult>;
+    getDatabaseType(): DatabaseType;
+    private ensureConnected;
+}
+/**
+ * SQL Database Manager
+ * Manages database connections and provides a unified interface
+ */
+declare class SqlDatabaseManager {
+    private static instance;
+    private databases;
+    private defaultDatabaseKey;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): SqlDatabaseManager;
+    /**
+     * Register a database connection
+     * @param key - Unique identifier for the database
+     * @param config - Database configuration
+     */
+    registerDatabase(key: string, config: DatabaseConfig): void;
+    /**
+     * Set the default database
+     * @param key - Database key to set as default
+     */
+    setDefaultDatabase(key: string): void;
+    /**
+     * Get a database by key
+     * @param key - Database key (optional, uses default if not provided)
+     */
+    getDatabase(key?: string): ISqlDatabase;
+    /**
+     * Check if a database is registered
+     * @param key - Database key
+     */
+    hasDatabase(key: string): boolean;
+    /**
+     * Get all registered database keys
+     */
+    getDatabaseKeys(): string[];
+    /**
+     * Remove a database connection
+     * @param key - Database key
+     */
+    removeDatabase(key: string): Promise<void>;
+    /**
+     * Disconnect all databases
+     */
+    disconnectAll(): Promise<void>;
+}
+declare const sqlDatabaseManager: SqlDatabaseManager;
+
 type ToolDefinition = ToolConfig;
 interface ToolLattice {
     key: string;
@@ -751,6 +913,259 @@ declare class MemoryQueueClient implements QueueClient {
     }>;
 }
 
+/**
+ * ScheduleLatticeManager
+ *
+ * Schedule Lattice manager for registering and managing schedule services
+ * Supports both one-time and cron-style recurring tasks
+ */
+
+/**
+ * Schedule Lattice interface
+ */
+interface ScheduleLattice extends ScheduleLatticeProtocol {
+    key: string;
+    config: ScheduleConfig;
+    client: ScheduleLatticeProtocol["client"];
+}
+/**
+ * ScheduleLatticeManager - Singleton schedule Lattice manager
+ * Responsible for registering and managing various schedule service Lattices
+ */
+declare class ScheduleLatticeManager extends BaseLatticeManager<ScheduleLattice> {
+    private static _instance;
+    /**
+     * Get ScheduleLatticeManager singleton instance
+     */
+    static getInstance(): ScheduleLatticeManager;
+    /**
+     * Get Lattice type prefix
+     */
+    protected getLatticeType(): string;
+    /**
+     * Register schedule Lattice
+     * @param key Lattice key name
+     * @param config Schedule configuration
+     * @param client Optional schedule client. If not provided, will create based on config type.
+     */
+    registerLattice(key: string, config: ScheduleConfig, client?: ScheduleClient): void;
+    /**
+     * Get ScheduleLattice
+     * @param key Lattice key name
+     */
+    getScheduleLattice(key: string): ScheduleLattice;
+    /**
+     * Get all Lattices
+     */
+    getAllLattices(): ScheduleLattice[];
+    /**
+     * Check if Lattice exists
+     * @param key Lattice key name
+     */
+    hasLattice(key: string): boolean;
+    /**
+     * Remove Lattice
+     * @param key Lattice key name
+     */
+    removeLattice(key: string): boolean;
+    /**
+     * Clear all Lattices
+     */
+    clearLattices(): void;
+    /**
+     * Get Lattice count
+     */
+    getLatticeCount(): number;
+    /**
+     * Get Lattice key list
+     */
+    getLatticeKeys(): string[];
+}
+declare const scheduleLatticeManager: ScheduleLatticeManager;
+declare const registerScheduleLattice: (key: string, config: ScheduleConfig, client?: ScheduleClient) => void;
+declare const getScheduleLattice: (key: string) => ScheduleLattice;
+
+/**
+ * DefaultScheduleClient
+ *
+ * Default schedule client implementation with full protocol support
+ * Core scheduling engine that handles timer management, cron parsing, and task execution
+ * Supports both one-time and cron-style recurring tasks
+ * Storage backend is pluggable - uses MemoryScheduleStorage by default
+ */
+
+/**
+ * Default schedule client implementation
+ * Core scheduling engine with pluggable storage backend
+ */
+declare class DefaultScheduleClient implements ScheduleClient {
+    private static instance;
+    private handlers;
+    private timers;
+    private storage;
+    constructor(storage?: ScheduleStorage);
+    /**
+     * Get the singleton instance of DefaultScheduleClient
+     */
+    static getInstance(storage?: ScheduleStorage): DefaultScheduleClient;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+    registerHandler(taskType: string, handler: TaskHandler): void;
+    unregisterHandler(taskType: string): boolean;
+    hasHandler(taskType: string): boolean;
+    getHandlerTypes(): string[];
+    scheduleOnce(taskId: string, taskType: string, payload: Record<string, any>, options: ScheduleOnceOptions): Promise<boolean>;
+    scheduleCron(taskId: string, taskType: string, payload: Record<string, any>, options: ScheduleCronOptions): Promise<boolean>;
+    cancel(taskId: string): Promise<boolean>;
+    pause(taskId: string): Promise<boolean>;
+    resume(taskId: string): Promise<boolean>;
+    has(taskId: string): Promise<boolean>;
+    getTask(taskId: string): Promise<ScheduledTaskDefinition | null>;
+    getRemainingTime(taskId: string): Promise<number>;
+    getActiveTaskCount(): Promise<number>;
+    getActiveTaskIds(): Promise<string[]>;
+    cancelAll(): Promise<void>;
+    restore(): Promise<number>;
+    setStorage(storage: ScheduleStorage): void;
+    getStorage(): ScheduleStorage | null;
+    private scheduleTimer;
+    private executeTask;
+}
+
+/**
+ * MemoryScheduleStorage
+ *
+ * In-memory storage implementation for scheduled tasks
+ * Useful for development and testing, not recommended for production
+ * Data is lost on service restart
+ */
+
+/**
+ * In-memory storage for scheduled tasks
+ */
+declare class MemoryScheduleStorage implements ScheduleStorage {
+    private tasks;
+    /**
+     * Save a new task
+     */
+    save(task: ScheduledTaskDefinition): Promise<void>;
+    /**
+     * Get task by ID
+     */
+    get(taskId: string): Promise<ScheduledTaskDefinition | null>;
+    /**
+     * Update task
+     */
+    update(taskId: string, updates: Partial<ScheduledTaskDefinition>): Promise<void>;
+    /**
+     * Delete task
+     */
+    delete(taskId: string): Promise<void>;
+    /**
+     * Get all active tasks (pending or paused)
+     */
+    getActiveTasks(): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get tasks by type
+     */
+    getTasksByType(taskType: string): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get tasks by status
+     */
+    getTasksByStatus(status: ScheduledTaskStatus): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get tasks by execution type
+     */
+    getTasksByExecutionType(executionType: ScheduleExecutionType): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get tasks by assistant ID
+     */
+    getTasksByAssistantId(assistantId: string): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get tasks by thread ID
+     */
+    getTasksByThreadId(threadId: string): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Get all tasks with optional filters
+     */
+    getAllTasks(filters?: {
+        status?: ScheduledTaskStatus;
+        executionType?: ScheduleExecutionType;
+        taskType?: string;
+        assistantId?: string;
+        threadId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ScheduledTaskDefinition[]>;
+    /**
+     * Count tasks with optional filters
+     */
+    countTasks(filters?: {
+        status?: ScheduledTaskStatus;
+        executionType?: ScheduleExecutionType;
+        taskType?: string;
+        assistantId?: string;
+        threadId?: string;
+    }): Promise<number>;
+    /**
+     * Delete completed/cancelled tasks older than specified time
+     */
+    deleteOldTasks(olderThanMs: number): Promise<number>;
+    /**
+     * Clear all tasks (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get total task count (useful for debugging)
+     */
+    size(): number;
+}
+
+/**
+ * CronParser
+ *
+ * Simple cron expression parser for calculating next execution time
+ * Supports standard 5-field cron format: minute hour day-of-month month day-of-week
+ *
+ * Field values:
+ *   minute: 0-59
+ *   hour: 0-23
+ *   day-of-month: 1-31
+ *   month: 1-12
+ *   day-of-week: 0-7 (0 and 7 are Sunday)
+ *
+ * Special characters:
+ *   asterisk (*) : any value
+ *   comma (,) : value list separator (1,3,5)
+ *   dash (-) : range of values (1-5)
+ *   slash (/) : step values (asterisk/5 = every 5)
+ */
+interface CronFields {
+    minute: number[];
+    hour: number[];
+    dayOfMonth: number[];
+    month: number[];
+    dayOfWeek: number[];
+}
+/**
+ * Parse a cron expression into field arrays
+ */
+declare function parseCronExpression(expression: string): CronFields;
+/**
+ * Get the next execution time after the given date
+ */
+declare function getNextCronTime(expression: string, after?: Date, timezone?: string): Date;
+/**
+ * Validate a cron expression
+ */
+declare function isValidCronExpression(expression: string): boolean;
+/**
+ * Get a human-readable description of a cron expression
+ */
+declare function describeCronExpression(expression: string): string;
+
 /**
  * StoreLatticeManager
  *
@@ -1143,4 +1558,4 @@ declare class AgentManager {
 
 declare const AGENT_TASK_EVENT = "agent:execute";
 
-export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryThreadStore, MemoryLatticeManager, MemoryQueueClient, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, type QueueLattice, QueueLatticeManager, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, type VectorStoreLatticeInterface, VectorStoreLatticeManager, agentLatticeManager, embeddingsLatticeManager, eventBus, eventBus as eventBusDefault, getAgentClient, getAgentConfig, getAgentLattice, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getModelLattice, getQueueLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, hasChunkBuffer, modelLatticeManager, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerModelLattice, registerQueueLattice, registerStoreLattice, registerToolLattice, registerVectorStoreLattice, storeLatticeManager, toolLatticeManager, validateAgentInput, validateToolInput, vectorStoreLatticeManager };
+export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, type CronFields, type DatabaseConfig, type DatabaseType, DefaultScheduleClient, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryThreadStore, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, PostgresDatabase, type QueryResult, type QueueLattice, QueueLatticeManager, type ScheduleLattice, ScheduleLatticeManager, SqlDatabaseManager, type StoreLattice, StoreLatticeManager, type StoreType, type StoreTypeMap, type TableInfo, type TableSchema, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, type VectorStoreLatticeInterface, VectorStoreLatticeManager, agentLatticeManager, describeCronExpression, embeddingsLatticeManager, eventBus, eventBus as eventBusDefault, getAgentClient, getAgentConfig, getAgentLattice, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getEmbeddingsClient, getEmbeddingsLattice, getModelLattice, getNextCronTime, getQueueLattice, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, hasChunkBuffer, isValidCronExpression, modelLatticeManager, parseCronExpression, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerToolLattice, registerVectorStoreLattice, scheduleLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, validateAgentInput, validateToolInput, vectorStoreLatticeManager };