@axiom-lattice/core 2.1.11 → 2.1.13

package/dist/index.js

@@ -37,17 +37,25 @@ __export(index_exports, {
   AgentType: () => import_protocols.AgentType,
   ChunkBuffer: () => ChunkBuffer,
   ChunkBufferLatticeManager: () => ChunkBufferLatticeManager,
+  EmbeddingsLatticeManager: () => EmbeddingsLatticeManager,
   GraphBuildOptions: () => import_protocols.GraphBuildOptions,
+  InMemoryAssistantStore: () => InMemoryAssistantStore,
   InMemoryChunkBuffer: () => InMemoryChunkBuffer,
+  InMemoryThreadStore: () => InMemoryThreadStore,
   MemoryLatticeManager: () => MemoryLatticeManager,
   MemoryQueueClient: () => MemoryQueueClient,
+  MemoryScheduleClient: () => MemoryScheduleClient,
   MemoryType: () => import_protocols2.MemoryType,
   ModelLatticeManager: () => ModelLatticeManager,
   Protocols: () => Protocols,
   QueueLatticeManager: () => QueueLatticeManager,
+  ScheduleLatticeManager: () => ScheduleLatticeManager,
+  StoreLatticeManager: () => StoreLatticeManager,
   ThreadStatus: () => ThreadStatus,
   ToolLatticeManager: () => ToolLatticeManager,
+  VectorStoreLatticeManager: () => VectorStoreLatticeManager,
   agentLatticeManager: () => agentLatticeManager,
+  embeddingsLatticeManager: () => embeddingsLatticeManager,
   eventBus: () => eventBus,
   eventBusDefault: () => event_bus_default,
   getAgentClient: () => getAgentClient,
@@ -57,11 +65,17 @@ __export(index_exports, {
   getAllToolDefinitions: () => getAllToolDefinitions,
   getCheckpointSaver: () => getCheckpointSaver,
   getChunkBuffer: () => getChunkBuffer,
+  getEmbeddingsClient: () => getEmbeddingsClient,
+  getEmbeddingsLattice: () => getEmbeddingsLattice,
   getModelLattice: () => getModelLattice,
   getQueueLattice: () => getQueueLattice,
+  getScheduleLattice: () => getScheduleLattice,
+  getStoreLattice: () => getStoreLattice,
   getToolClient: () => getToolClient,
   getToolDefinition: () => getToolDefinition,
   getToolLattice: () => getToolLattice,
+  getVectorStoreClient: () => getVectorStoreClient,
+  getVectorStoreLattice: () => getVectorStoreLattice,
   hasChunkBuffer: () => hasChunkBuffer,
   modelLatticeManager: () => modelLatticeManager,
   queueLatticeManager: () => queueLatticeManager,
@@ -69,12 +83,19 @@ __export(index_exports, {
   registerAgentLattices: () => registerAgentLattices,
   registerCheckpointSaver: () => registerCheckpointSaver,
   registerChunkBuffer: () => registerChunkBuffer,
+  registerEmbeddingsLattice: () => registerEmbeddingsLattice,
   registerModelLattice: () => registerModelLattice,
   registerQueueLattice: () => registerQueueLattice,
+  registerScheduleLattice: () => registerScheduleLattice,
+  registerStoreLattice: () => registerStoreLattice,
   registerToolLattice: () => registerToolLattice,
+  registerVectorStoreLattice: () => registerVectorStoreLattice,
+  scheduleLatticeManager: () => scheduleLatticeManager,
+  storeLatticeManager: () => storeLatticeManager,
   toolLatticeManager: () => toolLatticeManager,
   validateAgentInput: () => validateAgentInput,
-  validateToolInput: () => validateToolInput
+  validateToolInput: () => validateToolInput,
+  vectorStoreLatticeManager: () => vectorStoreLatticeManager
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -650,30 +671,17 @@ registerToolLattice(
     topic = "general",
     includeRawContent = false
   }, config) => {
-    console.log("[DEBUG][internet_search] Starting search with params:", {
-      query,
-      maxResults,
-      topic,
-      includeRawContent
-    });
-    console.log("[DEBUG][internet_search] Creating TavilySearch instance...");
     const tavilySearch = new import_tavily.TavilySearch({
       maxResults,
       tavilyApiKey: process.env.TAVILY_API_KEY,
       includeRawContent,
       topic
     });
-    console.log("[DEBUG][internet_search] Invoking search for query:", query);
     const tavilyResponse = await tavilySearch.invoke({ query });
-    console.log(
-      "[DEBUG][internet_search] Search completed. Results count:",
-      tavilyResponse.results?.length ?? 0
-    );
     const result = genUICard("Internet Search:" + query, "generic_data_table", {
       dataSource: tavilyResponse.results
     });
-    console.log("[DEBUG][internet_search] Returning UI card result");
-    return result;
+    return JSON.stringify(tavilyResponse.results);
   }
 );
 
@@ -2182,7 +2190,6 @@ function createTaskTool(options) {
         input: { ...subagentState, message: description }
       });
       const result = workerResult.finalState?.values;
-      console.log("workerResult", workerResult);
       if (!config.toolCall?.id) {
         throw new Error("Tool call ID is required for subagent invocation");
       }
@@ -3273,6 +3280,752 @@ var getChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().get(key);
 var registerChunkBuffer = (key, buffer) => ChunkBufferLatticeManager.getInstance().register(key, buffer);
 var hasChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().has(key);
 
+// src/schedule_lattice/ScheduleLatticeManager.ts
+var import_protocols5 = require("@axiom-lattice/protocols");
+
+// src/schedule_lattice/MemoryScheduleClient.ts
+var _MemoryScheduleClient = class _MemoryScheduleClient {
+  constructor() {
+    this.tasks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get the singleton instance of MemoryScheduleClient
+   */
+  static getInstance() {
+    if (!_MemoryScheduleClient.instance) {
+      _MemoryScheduleClient.instance = new _MemoryScheduleClient();
+    }
+    return _MemoryScheduleClient.instance;
+  }
+  /**
+   * 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, callback, timeoutMs) {
+    if (this.tasks.has(taskId)) {
+      this.cancel(taskId);
+    }
+    const timerId = setTimeout(async () => {
+      try {
+        console.log("scheduler callback", taskId, "start");
+        await callback();
+        console.log("scheduler callback", taskId, "success");
+      } catch (error) {
+        console.error(`Scheduler: Error executing task "${taskId}":`, error);
+      } finally {
+        this.tasks.delete(taskId);
+        console.log("scheduler callback", taskId, "end");
+      }
+    }, timeoutMs);
+    this.tasks.set(taskId, {
+      timerId,
+      callback,
+      scheduledAt: Date.now(),
+      timeoutMs
+    });
+    console.log("scheduler register", taskId);
+    return true;
+  }
+  /**
+   * 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) {
+    console.log("scheduler cancel", taskId);
+    const task = this.tasks.get(taskId);
+    if (task) {
+      clearTimeout(task.timerId);
+      this.tasks.delete(taskId);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if a task is currently scheduled
+   * @param taskId - The task identifier to check
+   */
+  has(taskId) {
+    return this.tasks.has(taskId);
+  }
+  /**
+   * 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) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return -1;
+    }
+    const elapsed = Date.now() - task.scheduledAt;
+    return Math.max(0, task.timeoutMs - elapsed);
+  }
+  /**
+   * Get the count of currently scheduled tasks
+   */
+  getTaskCount() {
+    return this.tasks.size;
+  }
+  /**
+   * Get all scheduled task IDs
+   */
+  getTaskIds() {
+    return Array.from(this.tasks.keys());
+  }
+  /**
+   * Cancel all scheduled tasks
+   */
+  cancelAll() {
+    for (const [taskId, task] of this.tasks) {
+      clearTimeout(task.timerId);
+    }
+    this.tasks.clear();
+  }
+  /**
+   * Get task information
+   * @param taskId - The task identifier
+   * @returns Task info or null if not found
+   */
+  getTaskInfo(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return null;
+    }
+    return {
+      taskId,
+      scheduledAt: task.scheduledAt,
+      timeoutMs: task.timeoutMs,
+      remainingMs: this.getRemainingTime(taskId)
+    };
+  }
+  /**
+   * Reset the singleton instance (useful for testing)
+   */
+  static resetInstance() {
+    if (_MemoryScheduleClient.instance) {
+      _MemoryScheduleClient.instance.cancelAll();
+      _MemoryScheduleClient.instance = null;
+    }
+  }
+};
+_MemoryScheduleClient.instance = null;
+var MemoryScheduleClient = _MemoryScheduleClient;
+
+// src/schedule_lattice/ScheduleLatticeManager.ts
+var ScheduleLatticeManager = class _ScheduleLatticeManager extends BaseLatticeManager {
+  /**
+   * Get ScheduleLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_ScheduleLatticeManager._instance) {
+      _ScheduleLatticeManager._instance = new _ScheduleLatticeManager();
+    }
+    return _ScheduleLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "schedules";
+  }
+  /**
+   * 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, config, client) {
+    let scheduleClient;
+    if (client) {
+      scheduleClient = client;
+    } else {
+      if (config.type === import_protocols5.ScheduleType.MEMORY) {
+        scheduleClient = MemoryScheduleClient.getInstance();
+      } else {
+        scheduleClient = MemoryScheduleClient.getInstance();
+      }
+    }
+    const scheduleLattice = {
+      key,
+      config,
+      client: scheduleClient,
+      register: (taskId, callback, timeoutMs) => {
+        return scheduleClient.register(taskId, callback, timeoutMs);
+      },
+      cancel: (taskId) => {
+        return scheduleClient.cancel(taskId);
+      },
+      has: (taskId) => {
+        return scheduleClient.has(taskId);
+      },
+      getRemainingTime: (taskId) => {
+        return scheduleClient.getRemainingTime(taskId);
+      },
+      getTaskCount: () => {
+        return scheduleClient.getTaskCount();
+      },
+      getTaskIds: () => {
+        return scheduleClient.getTaskIds();
+      },
+      cancelAll: () => {
+        return scheduleClient.cancelAll();
+      },
+      getTaskInfo: scheduleClient.getTaskInfo ? (taskId) => {
+        return scheduleClient.getTaskInfo(taskId);
+      } : void 0
+    };
+    this.register(key, scheduleLattice);
+  }
+  /**
+   * Get ScheduleLattice
+   * @param key Lattice key name
+   */
+  getScheduleLattice(key) {
+    const scheduleLattice = this.get(key);
+    if (!scheduleLattice) {
+      throw new Error(`ScheduleLattice ${key} not found`);
+    }
+    return scheduleLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var scheduleLatticeManager = ScheduleLatticeManager.getInstance();
+var registerScheduleLattice = (key, config, client) => scheduleLatticeManager.registerLattice(key, config, client);
+var getScheduleLattice = (key) => scheduleLatticeManager.getScheduleLattice(key);
+
+// src/store_lattice/InMemoryThreadStore.ts
+var InMemoryThreadStore = class {
+  constructor() {
+    // Map<assistantId, Map<threadId, Thread>>
+    this.threads = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all threads for a specific assistant
+   */
+  async getThreadsByAssistantId(assistantId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return [];
+    }
+    return Array.from(assistantThreads.values());
+  }
+  /**
+   * Get a thread by ID for a specific assistant
+   */
+  async getThreadById(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return void 0;
+    }
+    return assistantThreads.get(threadId);
+  }
+  /**
+   * Create a new thread for an assistant
+   */
+  async createThread(assistantId, threadId, data) {
+    const now = /* @__PURE__ */ new Date();
+    const thread = {
+      id: threadId,
+      assistantId,
+      metadata: data.metadata || {},
+      createdAt: now,
+      updatedAt: now
+    };
+    if (!this.threads.has(assistantId)) {
+      this.threads.set(assistantId, /* @__PURE__ */ new Map());
+    }
+    const assistantThreads = this.threads.get(assistantId);
+    assistantThreads.set(threadId, thread);
+    return thread;
+  }
+  /**
+   * Update an existing thread
+   */
+  async updateThread(assistantId, threadId, updates) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return null;
+    }
+    const existing = assistantThreads.get(threadId);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      metadata: {
+        ...existing.metadata,
+        ...updates.metadata || {}
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    assistantThreads.set(threadId, updated);
+    return updated;
+  }
+  /**
+   * Delete a thread by ID
+   */
+  async deleteThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.delete(threadId);
+  }
+  /**
+   * Check if thread exists
+   */
+  async hasThread(assistantId, threadId) {
+    const assistantThreads = this.threads.get(assistantId);
+    if (!assistantThreads) {
+      return false;
+    }
+    return assistantThreads.has(threadId);
+  }
+  /**
+   * Clear all threads (useful for testing)
+   */
+  clear() {
+    this.threads.clear();
+  }
+  /**
+   * Get all threads for all assistants (useful for debugging)
+   */
+  getAllThreads() {
+    const allThreads = [];
+    for (const assistantThreads of this.threads.values()) {
+      allThreads.push(...Array.from(assistantThreads.values()));
+    }
+    return allThreads;
+  }
+};
+
+// src/store_lattice/InMemoryAssistantStore.ts
+var InMemoryAssistantStore = class {
+  constructor() {
+    this.assistants = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all assistants
+   */
+  async getAllAssistants() {
+    return Array.from(this.assistants.values());
+  }
+  /**
+   * Get assistant by ID
+   */
+  async getAssistantById(id) {
+    return this.assistants.get(id) || null;
+  }
+  /**
+   * Create a new assistant
+   */
+  async createAssistant(id, data) {
+    const now = /* @__PURE__ */ new Date();
+    const assistant = {
+      id,
+      name: data.name,
+      description: data.description,
+      graphDefinition: data.graphDefinition,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.assistants.set(id, assistant);
+    return assistant;
+  }
+  /**
+   * Update an existing assistant
+   */
+  async updateAssistant(id, updates) {
+    const existing = this.assistants.get(id);
+    if (!existing) {
+      return null;
+    }
+    const updated = {
+      ...existing,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.assistants.set(id, updated);
+    return updated;
+  }
+  /**
+   * Delete an assistant by ID
+   */
+  async deleteAssistant(id) {
+    return this.assistants.delete(id);
+  }
+  /**
+   * Check if assistant exists
+   */
+  async hasAssistant(id) {
+    return this.assistants.has(id);
+  }
+  /**
+   * Clear all assistants (useful for testing)
+   */
+  clear() {
+    this.assistants.clear();
+  }
+};
+
+// src/store_lattice/StoreLatticeManager.ts
+var StoreLatticeManager = class _StoreLatticeManager extends BaseLatticeManager {
+  /**
+   * Get StoreLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_StoreLatticeManager._instance) {
+      _StoreLatticeManager._instance = new _StoreLatticeManager();
+    }
+    return _StoreLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "stores";
+  }
+  /**
+   * Generate composite key from key and type
+   * @param key Lattice key name
+   * @param type Store type
+   * @returns Composite key string
+   */
+  getCompositeKey(key, type) {
+    return `${key}:${type}`;
+  }
+  /**
+   * 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(key, type, store) {
+    const storeLattice = {
+      key,
+      type,
+      store
+    };
+    const compositeKey = this.getCompositeKey(key, type);
+    this.register(compositeKey, storeLattice);
+  }
+  /**
+   * 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(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    const storeLattice = this.get(compositeKey);
+    if (!storeLattice) {
+      throw new Error(`StoreLattice ${key}:${type} not found`);
+    }
+    if (storeLattice.type !== type) {
+      throw new Error(
+        `StoreLattice ${key}:${type} has type "${storeLattice.type}", expected "${type}"`
+      );
+    }
+    return storeLattice;
+  }
+  /**
+   * 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, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    const storeLattice = this.get(compositeKey);
+    if (!storeLattice) {
+      throw new Error(`StoreLattice ${key}:${type} not found`);
+    }
+    return storeLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * Uses composite key (key + type) to check existence
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  hasLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.has(compositeKey);
+  }
+  /**
+   * Remove Lattice
+   * Uses composite key (key + type) to remove the store
+   * @param key Lattice key name
+   * @param type Store type
+   */
+  removeLattice(key, type) {
+    const compositeKey = this.getCompositeKey(key, type);
+    return this.remove(compositeKey);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+};
+var storeLatticeManager = StoreLatticeManager.getInstance();
+var registerStoreLattice = (key, type, store) => storeLatticeManager.registerLattice(key, type, store);
+var getStoreLattice = (key, type) => storeLatticeManager.getStoreLattice(key, type);
+var defaultThreadStore = new InMemoryThreadStore();
+var defaultAssistantStore = new InMemoryAssistantStore();
+storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
+storeLatticeManager.registerLattice(
+  "default",
+  "assistant",
+  defaultAssistantStore
+);
+
+// src/embeddings_lattice/EmbeddingsLatticeManager.ts
+var EmbeddingsLatticeManager = class _EmbeddingsLatticeManager extends BaseLatticeManager {
+  /**
+   * Get EmbeddingsLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_EmbeddingsLatticeManager._instance) {
+      _EmbeddingsLatticeManager._instance = new _EmbeddingsLatticeManager();
+    }
+    return _EmbeddingsLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "embeddings";
+  }
+  /**
+   * Register embeddings Lattice
+   * @param key Lattice key name
+   * @param embeddings Embeddings instance
+   */
+  registerLattice(key, embeddings) {
+    const embeddingsLattice = {
+      key,
+      client: embeddings
+    };
+    this.register(key, embeddingsLattice);
+  }
+  /**
+   * Get EmbeddingsLattice
+   * @param key Lattice key name
+   */
+  getEmbeddingsLattice(key) {
+    const embeddingsLattice = this.get(key);
+    if (!embeddingsLattice) {
+      throw new Error(`EmbeddingsLattice ${key} not found`);
+    }
+    return embeddingsLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+  /**
+   * Get embeddings client
+   * @param key Lattice key name
+   */
+  getEmbeddingsClient(key) {
+    const embeddingsLattice = this.getEmbeddingsLattice(key);
+    return embeddingsLattice.client;
+  }
+};
+var embeddingsLatticeManager = EmbeddingsLatticeManager.getInstance();
+var registerEmbeddingsLattice = (key, embeddings) => embeddingsLatticeManager.registerLattice(key, embeddings);
+var getEmbeddingsLattice = (key) => embeddingsLatticeManager.getEmbeddingsLattice(key);
+var getEmbeddingsClient = (key) => embeddingsLatticeManager.getEmbeddingsClient(key);
+
+// src/vectorstore_lattice/VectorStoreLatticeManager.ts
+var VectorStoreLatticeManager = class _VectorStoreLatticeManager extends BaseLatticeManager {
+  /**
+   * Get VectorStoreLatticeManager singleton instance
+   */
+  static getInstance() {
+    if (!_VectorStoreLatticeManager._instance) {
+      _VectorStoreLatticeManager._instance = new _VectorStoreLatticeManager();
+    }
+    return _VectorStoreLatticeManager._instance;
+  }
+  /**
+   * Get Lattice type prefix
+   */
+  getLatticeType() {
+    return "vectorstores";
+  }
+  /**
+   * Register vector store Lattice
+   * @param key Lattice key name
+   * @param vectorStore VectorStore instance
+   */
+  registerLattice(key, vectorStore) {
+    const vectorStoreLattice = {
+      key,
+      client: vectorStore
+    };
+    this.register(key, vectorStoreLattice);
+  }
+  /**
+   * Get VectorStoreLattice
+   * @param key Lattice key name
+   */
+  getVectorStoreLattice(key) {
+    const vectorStoreLattice = this.get(key);
+    if (!vectorStoreLattice) {
+      throw new Error(`VectorStoreLattice ${key} not found`);
+    }
+    return vectorStoreLattice;
+  }
+  /**
+   * Get all Lattices
+   */
+  getAllLattices() {
+    return this.getAll();
+  }
+  /**
+   * Check if Lattice exists
+   * @param key Lattice key name
+   */
+  hasLattice(key) {
+    return this.has(key);
+  }
+  /**
+   * Remove Lattice
+   * @param key Lattice key name
+   */
+  removeLattice(key) {
+    return this.remove(key);
+  }
+  /**
+   * Clear all Lattices
+   */
+  clearLattices() {
+    this.clear();
+  }
+  /**
+   * Get Lattice count
+   */
+  getLatticeCount() {
+    return this.count();
+  }
+  /**
+   * Get Lattice key list
+   */
+  getLatticeKeys() {
+    return this.keys();
+  }
+  /**
+   * Get vector store client
+   * @param key Lattice key name
+   */
+  getVectorStoreClient(key) {
+    const vectorStoreLattice = this.getVectorStoreLattice(key);
+    return vectorStoreLattice.client;
+  }
+};
+var vectorStoreLatticeManager = VectorStoreLatticeManager.getInstance();
+var registerVectorStoreLattice = (key, vectorStore) => vectorStoreLatticeManager.registerLattice(key, vectorStore);
+var getVectorStoreLattice = (key) => vectorStoreLatticeManager.getVectorStoreLattice(key);
+var getVectorStoreClient = (key) => vectorStoreLatticeManager.getVectorStoreClient(key);
+
 // src/index.ts
 var Protocols = __toESM(require("@axiom-lattice/protocols"));
 // Annotate the CommonJS export names for ESM import in node:
@@ -3284,17 +4037,25 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  EmbeddingsLatticeManager,
   GraphBuildOptions,
+  InMemoryAssistantStore,
   InMemoryChunkBuffer,
+  InMemoryThreadStore,
   MemoryLatticeManager,
   MemoryQueueClient,
+  MemoryScheduleClient,
   MemoryType,
   ModelLatticeManager,
   Protocols,
   QueueLatticeManager,
+  ScheduleLatticeManager,
+  StoreLatticeManager,
   ThreadStatus,
   ToolLatticeManager,
+  VectorStoreLatticeManager,
   agentLatticeManager,
+  embeddingsLatticeManager,
   eventBus,
   eventBusDefault,
   getAgentClient,
@@ -3304,11 +4065,17 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   getAllToolDefinitions,
   getCheckpointSaver,
   getChunkBuffer,
+  getEmbeddingsClient,
+  getEmbeddingsLattice,
   getModelLattice,
   getQueueLattice,
+  getScheduleLattice,
+  getStoreLattice,
   getToolClient,
   getToolDefinition,
   getToolLattice,
+  getVectorStoreClient,
+  getVectorStoreLattice,
   hasChunkBuffer,
   modelLatticeManager,
   queueLatticeManager,
@@ -3316,11 +4083,18 @@ var Protocols = __toESM(require("@axiom-lattice/protocols"));
   registerAgentLattices,
   registerCheckpointSaver,
   registerChunkBuffer,
+  registerEmbeddingsLattice,
   registerModelLattice,
   registerQueueLattice,
+  registerScheduleLattice,
+  registerStoreLattice,
   registerToolLattice,
+  registerVectorStoreLattice,
+  scheduleLatticeManager,
+  storeLatticeManager,
   toolLatticeManager,
   validateAgentInput,
-  validateToolInput
+  validateToolInput,
+  vectorStoreLatticeManager
 });
 //# sourceMappingURL=index.js.map