@axiom-lattice/core 2.1.11 → 2.1.13

package/dist/index.d.ts

@@ -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 } from '@axiom-lattice/protocols';
+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 * as protocols from '@axiom-lattice/protocols';
 export { protocols as Protocols };
 export { AgentConfig, AgentType, GraphBuildOptions, MemoryType } from '@axiom-lattice/protocols';
@@ -15,6 +15,8 @@ import { CompiledStateGraph } from '@langchain/langgraph';
 import { ReactAgent } from 'langchain';
 import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
 import { ReplaySubject } from 'rxjs';
+import { Embeddings } from '@langchain/core/embeddings';
+import { VectorStore } from '@langchain/core/vectorstores';
 
 /**
  * BaseLatticeManager - 抽象基类，为各种Lattice管理器提供通用功能
@@ -749,6 +751,480 @@ declare class MemoryQueueClient implements QueueClient {
     }>;
 }
 
+/**
+ * ScheduleLatticeManager
+ *
+ * Schedule Lattice manager for registering and managing schedule services
+ */
+
+/**
+ * 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;
+
+/**
+ * MemoryScheduleClient
+ *
+ * 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
+ */
+
+/**
+ * Memory-based schedule client implementation
+ */
+declare class MemoryScheduleClient implements ScheduleClient {
+    private static instance;
+    private tasks;
+    constructor();
+    /**
+     * Get the singleton instance of MemoryScheduleClient
+     */
+    static getInstance(): MemoryScheduleClient;
+    /**
+     * 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(taskId: string, callback: () => void | Promise<void>, timeoutMs: number): boolean;
+    /**
+     * Cancel a scheduled task by its ID
+     * @param taskId - The task identifier to cancel
+     * @returns true if task was found and cancelled, false otherwise
+     */
+    cancel(taskId: string): boolean;
+    /**
+     * Check if a task is currently scheduled
+     * @param taskId - The task identifier to check
+     */
+    has(taskId: 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
+     */
+    getRemainingTime(taskId: string): number;
+    /**
+     * Get the count of currently scheduled tasks
+     */
+    getTaskCount(): number;
+    /**
+     * Get all scheduled task IDs
+     */
+    getTaskIds(): string[];
+    /**
+     * Cancel all scheduled tasks
+     */
+    cancelAll(): void;
+    /**
+     * Get task information
+     * @param taskId - The task identifier
+     * @returns Task info or null if not found
+     */
+    getTaskInfo(taskId: string): ScheduledTaskInfo | null;
+    /**
+     * Reset the singleton instance (useful for testing)
+     */
+    static resetInstance(): void;
+}
+
+/**
+ * StoreLatticeManager
+ *
+ * Store Lattice manager for registering and managing store services
+ */
+
+/**
+ * Store type to store interface mapping
+ * Maps store type strings to their corresponding interface types
+ */
+type StoreTypeMap = {
+    thread: ThreadStore;
+    assistant: AssistantStore;
+};
+/**
+ * Store type keys
+ */
+type StoreType = keyof StoreTypeMap;
+/**
+ * Store Lattice interface with type safety
+ * @template TStoreType - The type of store (e.g., "thread")
+ */
+interface StoreLattice<TStoreType extends StoreType = StoreType> {
+    type: TStoreType;
+    key: string;
+    store: StoreTypeMap[TStoreType];
+}
+/**
+ * StoreLatticeManager - Singleton store Lattice manager
+ * Responsible for registering and managing various store service Lattices
+ */
+declare class StoreLatticeManager extends BaseLatticeManager<StoreLattice<StoreType>> {
+    private static _instance;
+    /**
+     * Get StoreLatticeManager singleton instance
+     */
+    static getInstance(): StoreLatticeManager;
+    /**
+     * Get Lattice type prefix
+     */
+    protected getLatticeType(): string;
+    /**
+     * Generate composite key from key and type
+     * @param key Lattice key name
+     * @param type Store type
+     * @returns Composite key string
+     */
+    private getCompositeKey;
+    /**
+     * Register store Lattice with type safety
+     * Uses composite key (key + type) as unique identifier
+     * @param key Lattice key name
+     * @param type Store type (e.g., "thread")
+     * @param store Store implementation instance matching the type
+     */
+    registerLattice<TStoreType extends StoreType>(key: string, type: TStoreType, store: StoreTypeMap[TStoreType]): void;
+    /**
+     * Get StoreLattice with type safety
+     * Uses composite key (key + type) to retrieve the store
+     * @param key Lattice key name
+     * @param type Expected store type for type checking
+     * @returns StoreLattice with typed store
+     */
+    getStoreLattice<TStoreType extends StoreType>(key: string, type: TStoreType): StoreLattice<TStoreType>;
+    /**
+     * Get StoreLattice without type checking (for backward compatibility)
+     * @param key Lattice key name
+     * @param type Store type
+     * @returns StoreLattice (type may be unknown)
+     */
+    getStoreLatticeUnsafe(key: string, type: StoreType): StoreLattice<StoreType>;
+    /**
+     * Get all Lattices
+     */
+    getAllLattices(): StoreLattice<StoreType>[];
+    /**
+     * Check if Lattice exists
+     * Uses composite key (key + type) to check existence
+     * @param key Lattice key name
+     * @param type Store type
+     */
+    hasLattice(key: string, type: StoreType): boolean;
+    /**
+     * Remove Lattice
+     * Uses composite key (key + type) to remove the store
+     * @param key Lattice key name
+     * @param type Store type
+     */
+    removeLattice(key: string, type: StoreType): boolean;
+    /**
+     * Clear all Lattices
+     */
+    clearLattices(): void;
+    /**
+     * Get Lattice count
+     */
+    getLatticeCount(): number;
+    /**
+     * Get Lattice key list
+     */
+    getLatticeKeys(): string[];
+}
+declare const storeLatticeManager: StoreLatticeManager;
+declare const registerStoreLattice: <TStoreType extends StoreType>(key: string, type: TStoreType, store: StoreTypeMap[TStoreType]) => void;
+declare const getStoreLattice: <TStoreType extends StoreType>(key: string, type: TStoreType) => StoreLattice<TStoreType>;
+
+/**
+ * InMemoryThreadStore
+ *
+ * In-memory implementation of ThreadStore
+ * Provides CRUD operations for thread data stored in memory
+ * Threads are organized by assistant ID
+ */
+
+/**
+ * In-memory implementation of ThreadStore
+ */
+declare class InMemoryThreadStore implements ThreadStore {
+    private threads;
+    /**
+     * Get all threads for a specific assistant
+     */
+    getThreadsByAssistantId(assistantId: string): Promise<Thread[]>;
+    /**
+     * Get a thread by ID for a specific assistant
+     */
+    getThreadById(assistantId: string, threadId: string): Promise<Thread | undefined>;
+    /**
+     * Create a new thread for an assistant
+     */
+    createThread(assistantId: string, threadId: string, data: CreateThreadRequest): Promise<Thread>;
+    /**
+     * Update an existing thread
+     */
+    updateThread(assistantId: string, threadId: string, updates: Partial<CreateThreadRequest>): Promise<Thread | null>;
+    /**
+     * Delete a thread by ID
+     */
+    deleteThread(assistantId: string, threadId: string): Promise<boolean>;
+    /**
+     * Check if thread exists
+     */
+    hasThread(assistantId: string, threadId: string): Promise<boolean>;
+    /**
+     * Clear all threads (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get all threads for all assistants (useful for debugging)
+     */
+    getAllThreads(): Thread[];
+}
+
+/**
+ * InMemoryAssistantStore
+ *
+ * In-memory implementation of AssistantStore
+ * Provides CRUD operations for assistant data stored in memory
+ */
+
+/**
+ * In-memory implementation of AssistantStore
+ */
+declare class InMemoryAssistantStore implements AssistantStore {
+    private assistants;
+    /**
+     * Get all assistants
+     */
+    getAllAssistants(): Promise<Assistant[]>;
+    /**
+     * Get assistant by ID
+     */
+    getAssistantById(id: string): Promise<Assistant | null>;
+    /**
+     * Create a new assistant
+     */
+    createAssistant(id: string, data: CreateAssistantRequest): Promise<Assistant>;
+    /**
+     * Update an existing assistant
+     */
+    updateAssistant(id: string, updates: Partial<CreateAssistantRequest>): Promise<Assistant | null>;
+    /**
+     * Delete an assistant by ID
+     */
+    deleteAssistant(id: string): Promise<boolean>;
+    /**
+     * Check if assistant exists
+     */
+    hasAssistant(id: string): Promise<boolean>;
+    /**
+     * Clear all assistants (useful for testing)
+     */
+    clear(): void;
+}
+
+/**
+ * Embeddings Lattice Interface
+ * Defines the structure of an embeddings lattice entry
+ */
+interface EmbeddingsLatticeInterface {
+    key: string;
+    client: Embeddings;
+}
+/**
+ * EmbeddingsLatticeManager - Singleton embeddings Lattice manager
+ * Responsible for registering and managing various embeddings model Lattices
+ */
+declare class EmbeddingsLatticeManager extends BaseLatticeManager<EmbeddingsLatticeInterface> {
+    private static _instance;
+    /**
+     * Get EmbeddingsLatticeManager singleton instance
+     */
+    static getInstance(): EmbeddingsLatticeManager;
+    /**
+     * Get Lattice type prefix
+     */
+    protected getLatticeType(): string;
+    /**
+     * Register embeddings Lattice
+     * @param key Lattice key name
+     * @param embeddings Embeddings instance
+     */
+    registerLattice(key: string, embeddings: Embeddings): void;
+    /**
+     * Get EmbeddingsLattice
+     * @param key Lattice key name
+     */
+    getEmbeddingsLattice(key: string): EmbeddingsLatticeInterface;
+    /**
+     * Get all Lattices
+     */
+    getAllLattices(): EmbeddingsLatticeInterface[];
+    /**
+     * 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[];
+    /**
+     * Get embeddings client
+     * @param key Lattice key name
+     */
+    getEmbeddingsClient(key: string): Embeddings;
+}
+declare const embeddingsLatticeManager: EmbeddingsLatticeManager;
+declare const registerEmbeddingsLattice: (key: string, embeddings: Embeddings) => void;
+declare const getEmbeddingsLattice: (key: string) => EmbeddingsLatticeInterface;
+declare const getEmbeddingsClient: (key: string) => Embeddings<number[]>;
+
+/**
+ * VectorStore Lattice Interface
+ * Defines the structure of a vector store lattice entry
+ */
+interface VectorStoreLatticeInterface {
+    key: string;
+    client: VectorStore;
+}
+/**
+ * VectorStoreLatticeManager - Singleton vector store Lattice manager
+ * Responsible for registering and managing various vector store Lattices
+ */
+declare class VectorStoreLatticeManager extends BaseLatticeManager<VectorStoreLatticeInterface> {
+    private static _instance;
+    /**
+     * Get VectorStoreLatticeManager singleton instance
+     */
+    static getInstance(): VectorStoreLatticeManager;
+    /**
+     * Get Lattice type prefix
+     */
+    protected getLatticeType(): string;
+    /**
+     * Register vector store Lattice
+     * @param key Lattice key name
+     * @param vectorStore VectorStore instance
+     */
+    registerLattice(key: string, vectorStore: VectorStore): void;
+    /**
+     * Get VectorStoreLattice
+     * @param key Lattice key name
+     */
+    getVectorStoreLattice(key: string): VectorStoreLatticeInterface;
+    /**
+     * Get all Lattices
+     */
+    getAllLattices(): VectorStoreLatticeInterface[];
+    /**
+     * 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[];
+    /**
+     * Get vector store client
+     * @param key Lattice key name
+     */
+    getVectorStoreClient(key: string): VectorStore;
+}
+declare const vectorStoreLatticeManager: VectorStoreLatticeManager;
+declare const registerVectorStoreLattice: (key: string, vectorStore: VectorStore) => void;
+declare const getVectorStoreLattice: (key: string) => VectorStoreLatticeInterface;
+declare const getVectorStoreClient: (key: string) => VectorStore;
+
 /**
  * Event bus service
  * Used for event publishing and subscription between internal system components
@@ -806,4 +1282,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, InMemoryChunkBuffer, MemoryLatticeManager, MemoryQueueClient, type ModelConfig, type ModelLatticeInterface, ModelLatticeManager, type QueueLattice, QueueLatticeManager, type ThreadBuffer, type ThreadBufferConfig, ThreadStatus, type ToolDefinition, type ToolLattice, ToolLatticeManager, agentLatticeManager, eventBus, eventBus as eventBusDefault, getAgentClient, getAgentConfig, getAgentLattice, getAllAgentConfigs, getAllToolDefinitions, getCheckpointSaver, getChunkBuffer, getModelLattice, getQueueLattice, getToolClient, getToolDefinition, getToolLattice, hasChunkBuffer, modelLatticeManager, queueLatticeManager, registerAgentLattice, registerAgentLattices, registerCheckpointSaver, registerChunkBuffer, registerModelLattice, registerQueueLattice, registerToolLattice, toolLatticeManager, validateAgentInput, validateToolInput };
+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 };