@axiom-lattice/core 2.1.13 → 2.1.15

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, ScheduleLatticeProtocol, ScheduleConfig, ScheduleClient, ScheduledTaskInfo, 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, LoggerLatticeProtocol, LoggerConfig, LoggerClient, LoggerContext } 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;
@@ -755,6 +917,7 @@ declare class MemoryQueueClient implements QueueClient {
  * ScheduleLatticeManager
  *
  * Schedule Lattice manager for registering and managing schedule services
+ * Supports both one-time and cron-style recurring tasks
  */
 
 /**
@@ -823,73 +986,186 @@ declare const registerScheduleLattice: (key: string, config: ScheduleConfig, cli
 declare const getScheduleLattice: (key: string) => ScheduleLattice;
 
 /**
- * MemoryScheduleClient
+ * DefaultScheduleClient
  *
- * In-memory schedule service implementation (default)
- * A singleton class for managing delayed function execution
- * Registers functions with timeout and automatically executes and cleans up when time expires
+ * 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
  */
 
 /**
- * Memory-based schedule client implementation
+ * Default schedule client implementation
+ * Core scheduling engine with pluggable storage backend
  */
-declare class MemoryScheduleClient implements ScheduleClient {
+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;
-    constructor();
     /**
-     * Get the singleton instance of MemoryScheduleClient
+     * Save a new task
      */
-    static getInstance(): MemoryScheduleClient;
+    save(task: ScheduledTaskDefinition): Promise<void>;
     /**
-     * Register a function to be executed after the specified timeout
-     * @param taskId - Unique identifier for the task
-     * @param callback - Function to execute when timeout expires
-     * @param timeoutMs - Delay in milliseconds before execution
-     * @returns true if registered successfully
+     * Get task by ID
      */
-    register(taskId: string, callback: () => void | Promise<void>, timeoutMs: number): boolean;
+    get(taskId: string): Promise<ScheduledTaskDefinition | null>;
     /**
-     * Cancel a scheduled task by its ID
-     * @param taskId - The task identifier to cancel
-     * @returns true if task was found and cancelled, false otherwise
+     * Update task
      */
-    cancel(taskId: string): boolean;
+    update(taskId: string, updates: Partial<ScheduledTaskDefinition>): Promise<void>;
     /**
-     * Check if a task is currently scheduled
-     * @param taskId - The task identifier to check
+     * Delete task
      */
-    has(taskId: string): boolean;
+    delete(taskId: string): Promise<void>;
     /**
-     * Get the remaining time in milliseconds for a scheduled task
-     * @param taskId - The task identifier
-     * @returns Remaining time in ms, or -1 if task not found
+     * Get all active tasks (pending or paused)
      */
-    getRemainingTime(taskId: string): number;
+    getActiveTasks(): Promise<ScheduledTaskDefinition[]>;
     /**
-     * Get the count of currently scheduled tasks
+     * Get tasks by type
      */
-    getTaskCount(): number;
+    getTasksByType(taskType: string): Promise<ScheduledTaskDefinition[]>;
     /**
-     * Get all scheduled task IDs
+     * Get tasks by status
      */
-    getTaskIds(): string[];
+    getTasksByStatus(status: ScheduledTaskStatus): Promise<ScheduledTaskDefinition[]>;
     /**
-     * Cancel all scheduled tasks
+     * Get tasks by execution type
      */
-    cancelAll(): void;
+    getTasksByExecutionType(executionType: ScheduleExecutionType): Promise<ScheduledTaskDefinition[]>;
     /**
-     * Get task information
-     * @param taskId - The task identifier
-     * @returns Task info or null if not found
+     * Get tasks by assistant ID
      */
-    getTaskInfo(taskId: string): ScheduledTaskInfo | null;
+    getTasksByAssistantId(assistantId: string): Promise<ScheduledTaskDefinition[]>;
     /**
-     * Reset the singleton instance (useful for testing)
+     * Get tasks by thread ID
      */
-    static resetInstance(): void;
+    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
  *
@@ -1225,6 +1501,134 @@ declare const registerVectorStoreLattice: (key: string, vectorStore: VectorStore
 declare const getVectorStoreLattice: (key: string) => VectorStoreLatticeInterface;
 declare const getVectorStoreClient: (key: string) => VectorStore;
 
+/**
+ * LoggerLatticeManager
+ *
+ * Logger Lattice manager for registering and managing logger services
+ */
+
+/**
+ * Logger Lattice interface
+ */
+interface LoggerLattice extends LoggerLatticeProtocol {
+    key: string;
+    config: LoggerConfig;
+    client: LoggerLatticeProtocol["client"];
+}
+/**
+ * LoggerLatticeManager - Singleton logger Lattice manager
+ * Responsible for registering and managing various logger service Lattices
+ */
+declare class LoggerLatticeManager extends BaseLatticeManager<LoggerLattice> {
+    private static _instance;
+    /**
+     * Get LoggerLatticeManager singleton instance
+     */
+    static getInstance(): LoggerLatticeManager;
+    /**
+     * Get Lattice type prefix
+     */
+    protected getLatticeType(): string;
+    /**
+     * Register logger Lattice
+     * @param key Lattice key name
+     * @param config Logger configuration
+     * @param client Optional logger client. If not provided, will create based on config type.
+     */
+    registerLattice(key: string, config: LoggerConfig, client?: LoggerClient): void;
+    /**
+     * Get LoggerLattice
+     * @param key Lattice key name
+     */
+    getLoggerLattice(key: string): LoggerLattice;
+    /**
+     * Get all Lattices
+     */
+    getAllLattices(): LoggerLattice[];
+    /**
+     * 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 loggerLatticeManager: LoggerLatticeManager;
+declare const registerLoggerLattice: (key: string, config: LoggerConfig, client?: LoggerClient) => void;
+declare const getLoggerLattice: (key: string) => LoggerLattice;
+
+/**
+ * PinoLoggerClient
+ *
+ * Pino-based logger client implementation
+ */
+
+/**
+ * Pino-based logger client implementation
+ * Supports custom file paths and pino configurations
+ */
+declare class PinoLoggerClient implements LoggerClient {
+    private pinoLogger;
+    private config;
+    private context;
+    constructor(config: LoggerConfig);
+    /**
+     * Determine if file logging should be used
+     */
+    private shouldUseFileLogging;
+    /**
+     * Get file options from config
+     */
+    private getFileOptions;
+    /**
+     * Get contextual logger with merged context
+     */
+    private getContextualLogger;
+    info(msg: string, obj?: object): void;
+    error(msg: string, obj?: object | Error): void;
+    warn(msg: string, obj?: object): void;
+    debug(msg: string, obj?: object): void;
+    updateContext(context: Partial<LoggerContext>): void;
+    child(options: Partial<LoggerConfig>): LoggerClient;
+}
+
+/**
+ * ConsoleLoggerClient
+ *
+ * Simple console-based logger client implementation
+ */
+
+/**
+ * Console-based logger client implementation
+ */
+declare class ConsoleLoggerClient implements LoggerClient {
+    private config;
+    private context;
+    constructor(config: LoggerConfig);
+    private formatMessage;
+    info(msg: string, obj?: object): void;
+    error(msg: string, obj?: object | Error): void;
+    warn(msg: string, obj?: object): void;
+    debug(msg: string, obj?: object): void;
+    updateContext(context: Partial<LoggerContext>): void;
+    child(options: Partial<LoggerConfig>): LoggerClient;
+}
+
 /**
  * Event bus service
  * Used for event publishing and subscription between internal system components
@@ -1282,4 +1686,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, MemoryScheduleClient, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, type QueueLattice, QueueLatticeManager, type ScheduleLattice, ScheduleLatticeManager, 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, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, hasChunkBuffer, modelLatticeManager, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerToolLattice, registerVectorStoreLattice, scheduleLatticeManager, storeLatticeManager, toolLatticeManager, validateAgentInput, validateToolInput, vectorStoreLatticeManager };
+export { AGENT_TASK_EVENT, type AgentClient, type AgentLattice, AgentLatticeManager, AgentManager, type BufferStats, type Chunk, ChunkBuffer, ChunkBufferLatticeManager, type ColumnInfo, ConsoleLoggerClient, type CronFields, type DatabaseConfig, type DatabaseType, DefaultScheduleClient, type EmbeddingsLatticeInterface, EmbeddingsLatticeManager, type ISqlDatabase, InMemoryAssistantStore, InMemoryChunkBuffer, InMemoryThreadStore, type LoggerLattice, LoggerLatticeManager, MemoryLatticeManager, MemoryQueueClient, MemoryScheduleStorage, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, PinoLoggerClient, 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, getLoggerLattice, getModelLattice, getNextCronTime, getQueueLattice, getScheduleLattice, getStoreLattice, getToolClient, getToolDefinition, getToolLattice, getVectorStoreClient, getVectorStoreLattice, hasChunkBuffer, isValidCronExpression, loggerLatticeManager, modelLatticeManager, parseCronExpression, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerEmbeddingsLattice, registerLoggerLattice, registerModelLattice, registerQueueLattice, registerScheduleLattice, registerStoreLattice, registerToolLattice, registerVectorStoreLattice, scheduleLatticeManager, sqlDatabaseManager, storeLatticeManager, toolLatticeManager, validateAgentInput, validateToolInput, vectorStoreLatticeManager };