@axiom-lattice/protocols 2.1.7 → 2.1.9

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/protocols@2.1.7 build /home/runner/work/agentic/agentic/packages/protocols
+> @axiom-lattice/protocols@2.1.9 build /home/runner/work/agentic/agentic/packages/protocols
 > tsup src/index.ts --format cjs,esm --dts --sourcemap
 
 CLI Building entry: src/index.ts
@@ -8,13 +8,13 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/index.js     3.42 KB
-CJS dist/index.js.map 12.14 KB
-CJS ⚡️ Build success in 44ms
-ESM dist/index.mjs     2.11 KB
-ESM dist/index.mjs.map 11.38 KB
-ESM ⚡️ Build success in 45ms
+ESM dist/index.mjs     3.11 KB
+ESM dist/index.mjs.map 22.34 KB
+ESM ⚡️ Build success in 50ms
+CJS dist/index.js     4.55 KB
+CJS dist/index.js.map 23.16 KB
+CJS ⚡️ Build success in 50ms
 DTS Build start
-DTS ⚡️ Build success in 2322ms
-DTS dist/index.d.ts  22.08 KB
-DTS dist/index.d.mts 22.08 KB
+DTS ⚡️ Build success in 2210ms
+DTS dist/index.d.ts  30.49 KB
+DTS dist/index.d.mts 30.49 KB

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @axiom-lattice/protocols
 
+## 2.1.9
+
+### Patch Changes
+
+- ef0fb84: update lagger lattice
+
+## 2.1.8
+
+### Patch Changes
+
+- d43ea0b: add schedule task
+
 ## 2.1.7
 
 ### Patch Changes

package/dist/index.d.mts

@@ -126,6 +126,16 @@ declare enum AgentType {
     PLAN_EXECUTE = "plan_execute",
     SEQUENTIAL = "sequential"
 }
+/**
+ * Runtime configuration that will be injected into LangGraphRunnableConfig.configurable
+ * Tools can access these values via config.configurable.runConfig
+ */
+interface AgentRunConfig {
+    /** Database key for SQL tools (registered via sqlDatabaseManager) */
+    databaseKey?: string;
+    /** Any additional runtime configuration */
+    [key: string]: any;
+}
 /**
  * Base agent configuration shared by all agent types
  */
@@ -136,6 +146,11 @@ interface BaseAgentConfig {
     prompt: string;
     schema?: ZodObject<any, any, any, any, any>;
     modelKey?: string;
+    /**
+     * Runtime configuration to inject into tool execution context
+     * Will be available in tools via config.configurable.runConfig
+     */
+    runConfig?: AgentRunConfig;
 }
 /**
  * REACT agent configuration
@@ -367,14 +382,36 @@ interface QueueLatticeProtocol extends BaseLatticeProtocol<QueueConfig, QueueCli
 /**
  * ScheduleLatticeProtocol
  *
- * Schedule Lattice protocol for delayed task execution management
+ * Schedule Lattice protocol for delayed and recurring task execution management
+ * Supports persistence and recovery after service restart
+ * Supports both one-time delayed tasks and cron-style recurring tasks
  */
 
 /**
  * Schedule service type enumeration
  */
 declare enum ScheduleType {
-    MEMORY = "memory"
+    MEMORY = "memory",
+    POSTGRES = "postgres",
+    REDIS = "redis"
+}
+/**
+ * Schedule execution type - one-time or recurring
+ */
+declare enum ScheduleExecutionType {
+    ONCE = "once",// Execute once at specified time
+    CRON = "cron"
+}
+/**
+ * Task status enumeration
+ */
+declare enum ScheduledTaskStatus {
+    PENDING = "pending",// Waiting to be executed
+    RUNNING = "running",// Currently executing
+    COMPLETED = "completed",// Successfully completed (for ONCE type)
+    FAILED = "failed",// Execution failed
+    CANCELLED = "cancelled",// Manually cancelled
+    PAUSED = "paused"
 }
 /**
  * Schedule configuration interface
@@ -383,77 +420,248 @@ interface ScheduleConfig {
     name: string;
     description: string;
     type: ScheduleType;
+    storage?: ScheduleStorage;
     options?: Record<string, any>;
 }
 /**
- * Scheduled task information interface
+ * Scheduled task definition - fully serializable
+ * Supports both one-time and cron-style recurring tasks
  */
-interface ScheduledTaskInfo {
+interface ScheduledTaskDefinition {
     taskId: string;
-    scheduledAt: number;
-    timeoutMs: number;
-    remainingMs: number;
+    taskType: string;
+    payload: Record<string, any>;
+    assistantId?: string;
+    threadId?: string;
+    executionType: ScheduleExecutionType;
+    executeAt?: number;
+    delayMs?: number;
+    cronExpression?: string;
+    timezone?: string;
+    nextRunAt?: number;
+    lastRunAt?: number;
+    status: ScheduledTaskStatus;
+    runCount: number;
+    maxRuns?: number;
+    retryCount: number;
+    maxRetries: number;
+    lastError?: string;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt?: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Task handler function type
+ */
+type TaskHandler = (payload: Record<string, any>, taskInfo: ScheduledTaskDefinition) => void | Promise<void>;
+/**
+ * Options for scheduling a one-time task
+ */
+interface ScheduleOnceOptions {
+    executeAt?: number;
+    delayMs?: number;
+    maxRetries?: number;
+    assistantId?: string;
+    threadId?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Options for scheduling a cron task
+ */
+interface ScheduleCronOptions {
+    cronExpression: string;
+    timezone?: string;
+    maxRuns?: number;
+    expiresAt?: number;
+    maxRetries?: number;
+    assistantId?: string;
+    threadId?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Schedule storage interface for persistence
+ */
+interface ScheduleStorage {
+    /**
+     * 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 pending/active tasks (for recovery)
+     * Returns tasks with status: 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
+     * Useful for cleanup
+     */
+    deleteOldTasks(olderThanMs: number): Promise<number>;
 }
 /**
  * Schedule client interface
  */
 interface ScheduleClient {
     /**
-     * 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
+     * Register a handler for a task type
+     * Must be called before scheduling tasks of this type
      */
-    register: (taskId: string, callback: () => void | Promise<void>, timeoutMs: number) => boolean;
+    registerHandler(taskType: string, handler: TaskHandler): void;
     /**
-     * Cancel a scheduled task by its ID
-     * @param taskId - The task identifier to cancel
-     * @returns true if task was found and cancelled, false otherwise
+     * Unregister a handler
      */
-    cancel: (taskId: string) => boolean;
+    unregisterHandler(taskType: string): boolean;
     /**
-     * Check if a task is currently scheduled
-     * @param taskId - The task identifier to check
+     * Check if a handler is registered
      */
-    has: (taskId: string) => boolean;
+    hasHandler(taskType: string): boolean;
     /**
-     * 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 registered handler types
      */
-    getRemainingTime: (taskId: string) => number;
+    getHandlerTypes(): string[];
     /**
-     * Get the count of currently scheduled tasks
+     * Schedule a one-time task
+     * @param taskId - Unique identifier for the task
+     * @param taskType - Type of task (must have a registered handler)
+     * @param payload - Data to pass to the handler (must be JSON-serializable)
+     * @param options - Execution options (executeAt or delayMs required)
+     */
+    scheduleOnce(taskId: string, taskType: string, payload: Record<string, any>, options: ScheduleOnceOptions): Promise<boolean>;
+    /**
+     * Schedule a recurring cron task
+     * @param taskId - Unique identifier for the task
+     * @param taskType - Type of task (must have a registered handler)
+     * @param payload - Data to pass to the handler (must be JSON-serializable)
+     * @param options - Cron options (cronExpression required)
      */
-    getTaskCount: () => number;
+    scheduleCron(taskId: string, taskType: string, payload: Record<string, any>, options: ScheduleCronOptions): Promise<boolean>;
     /**
-     * Get all scheduled task IDs
+     * Cancel a scheduled task
      */
-    getTaskIds: () => string[];
+    cancel(taskId: string): Promise<boolean>;
     /**
-     * Cancel all scheduled tasks
+     * Pause a cron task (only for CRON type)
      */
-    cancelAll: () => void;
+    pause(taskId: string): Promise<boolean>;
+    /**
+     * Resume a paused cron task (only for CRON type)
+     */
+    resume(taskId: string): Promise<boolean>;
+    /**
+     * Check if a task exists
+     */
+    has(taskId: string): Promise<boolean>;
     /**
      * Get task information
-     * @param taskId - The task identifier
-     * @returns Task info or null if not found
      */
-    getTaskInfo?: (taskId: string) => ScheduledTaskInfo | null;
+    getTask(taskId: string): Promise<ScheduledTaskDefinition | null>;
+    /**
+     * Get remaining time until next execution
+     * Returns -1 if task not found or already executed
+     */
+    getRemainingTime(taskId: string): Promise<number>;
+    /**
+     * Get count of active tasks (pending + paused)
+     */
+    getActiveTaskCount(): Promise<number>;
+    /**
+     * Get all active task IDs
+     */
+    getActiveTaskIds(): Promise<string[]>;
+    /**
+     * Cancel all active tasks
+     */
+    cancelAll(): Promise<void>;
+    /**
+     * Restore active tasks from storage (call on service startup)
+     * Re-schedules all pending tasks with their remaining time
+     * Re-schedules all cron tasks for their next run
+     * @returns Number of tasks restored
+     */
+    restore(): Promise<number>;
+    /**
+     * Set the storage backend
+     */
+    setStorage(storage: ScheduleStorage): void;
+    /**
+     * Get current storage backend
+     */
+    getStorage(): ScheduleStorage | null;
 }
 /**
  * Schedule Lattice protocol interface
  */
 interface ScheduleLatticeProtocol extends BaseLatticeProtocol<ScheduleConfig, ScheduleClient> {
-    register: (taskId: string, callback: () => void | Promise<void>, timeoutMs: number) => boolean;
-    cancel: (taskId: string) => boolean;
-    has: (taskId: string) => boolean;
-    getRemainingTime: (taskId: string) => number;
-    getTaskCount: () => number;
-    getTaskIds: () => string[];
-    cancelAll: () => void;
-    getTaskInfo?: (taskId: string) => ScheduledTaskInfo | null;
+    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>;
 }
 
 /**
@@ -512,6 +720,77 @@ interface VectorStoreLatticeProtocol extends BaseLatticeProtocol<VectorStoreConf
     }) => Promise<DocumentInterface[]>;
 }
 
+/**
+ * LoggerLatticeProtocol
+ *
+ * Logger Lattice protocol for logging management
+ */
+
+/**
+ * Logger service type enumeration
+ */
+declare enum LoggerType {
+    PINO = "pino",
+    CONSOLE = "console",
+    CUSTOM = "custom"
+}
+/**
+ * Logger context interface
+ */
+interface LoggerContext {
+    "x-user-id"?: string;
+    "x-tenant-id"?: string;
+    "x-request-id"?: string;
+    "x-task-id"?: string;
+    "x-thread-id"?: string;
+    [key: string]: any;
+}
+/**
+ * Pino logger file transport options
+ */
+interface PinoFileOptions {
+    file?: string;
+    frequency?: "daily" | "hourly" | "minutely" | string;
+    mkdir?: boolean;
+    size?: string;
+    maxFiles?: number;
+}
+/**
+ * Logger configuration interface
+ */
+interface LoggerConfig {
+    name: string;
+    description?: string;
+    type: LoggerType;
+    serviceName?: string;
+    loggerName?: string;
+    context?: LoggerContext;
+    file?: string | PinoFileOptions;
+    options?: Record<string, any>;
+}
+/**
+ * Logger client interface
+ */
+interface LoggerClient {
+    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;
+}
+/**
+ * Logger Lattice protocol interface
+ */
+interface LoggerLatticeProtocol extends BaseLatticeProtocol<LoggerConfig, LoggerClient> {
+    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;
+}
+
 /**
  * MessageProtocol
  *
@@ -865,4 +1144,4 @@ type Timestamp = number;
  */
 type Callback<T = any, R = void> = (data: T) => R | Promise<R>;
 
-export { type AgentClient, type AgentConfig, type AgentConfigWithTools, type AgentLatticeProtocol, AgentType, type Assistant, type AssistantMessage, type AssistantStore, type BaseLatticeProtocol, type BaseMessage, type Callback, type CreateAssistantRequest, type CreateThreadRequest, type DeepAgentConfig, type DeveloperMessage, type EmbeddingsConfig, type EmbeddingsLatticeProtocol, type FilterCondition, type GraphBuildOptions, type ID, type InterruptMessage, type LLMConfig, type LatticeError, type LatticeEventBus, type LatticeMessage, type MemoryClient, type MemoryConfig, type MemoryLatticeProtocol, MemoryType, type Message, type MessageChunk, type ModelLatticeProtocol, type PaginatedResult, type PaginationParams, type PlanExecuteAgentConfig, type QueryParams, type QueueClient, type QueueConfig, type QueueLatticeProtocol, type QueueResult, QueueType, type ReactAgentConfig, type Result, type ScheduleClient, type ScheduleConfig, type ScheduleLatticeProtocol, ScheduleType, type ScheduledTaskInfo, type SequentialAgentConfig, type SystemMessage, type Thread, type ThreadStore, type Timestamp, type ToolCall, type ToolConfig, type ToolExecutor, type ToolLatticeProtocol, type ToolMessage, type UIComponent, UIComponentType, type UIConfig, type UILatticeProtocol, type UserMessage, type VectorStoreConfig, type VectorStoreLatticeProtocol, getSubAgentsFromConfig, getToolsFromConfig, hasTools, isDeepAgentConfig };
+export { type AgentClient, type AgentConfig, type AgentConfigWithTools, type AgentLatticeProtocol, type AgentRunConfig, AgentType, type Assistant, type AssistantMessage, type AssistantStore, type BaseLatticeProtocol, type BaseMessage, type Callback, type CreateAssistantRequest, type CreateThreadRequest, type DeepAgentConfig, type DeveloperMessage, type EmbeddingsConfig, type EmbeddingsLatticeProtocol, type FilterCondition, type GraphBuildOptions, type ID, type InterruptMessage, type LLMConfig, type LatticeError, type LatticeEventBus, type LatticeMessage, type LoggerClient, type LoggerConfig, type LoggerContext, type LoggerLatticeProtocol, LoggerType, type MemoryClient, type MemoryConfig, type MemoryLatticeProtocol, MemoryType, type Message, type MessageChunk, type ModelLatticeProtocol, type PaginatedResult, type PaginationParams, type PinoFileOptions, type PlanExecuteAgentConfig, type QueryParams, type QueueClient, type QueueConfig, type QueueLatticeProtocol, type QueueResult, QueueType, type ReactAgentConfig, type Result, type ScheduleClient, type ScheduleConfig, type ScheduleCronOptions, ScheduleExecutionType, type ScheduleLatticeProtocol, type ScheduleOnceOptions, type ScheduleStorage, ScheduleType, type ScheduledTaskDefinition, ScheduledTaskStatus, type SequentialAgentConfig, type SystemMessage, type TaskHandler, type Thread, type ThreadStore, type Timestamp, type ToolCall, type ToolConfig, type ToolExecutor, type ToolLatticeProtocol, type ToolMessage, type UIComponent, UIComponentType, type UIConfig, type UILatticeProtocol, type UserMessage, type VectorStoreConfig, type VectorStoreLatticeProtocol, getSubAgentsFromConfig, getToolsFromConfig, hasTools, isDeepAgentConfig };