@axiom-lattice/core 2.1.10 → 2.1.12

package/dist/index.mjs

@@ -574,30 +574,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 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);
   }
 );
 
@@ -1748,10 +1735,8 @@ var AgentManager = class _AgentManager {
       if (return_agent_state) {
         event_bus_default.subscribeOnce(callback_event, (data) => {
           if (data.success) {
-            console.log("AgentManager callAgentInQueue success", data);
             resolve(data.state);
           } else {
-            console.log("AgentManager callAgentInQueue error", data);
             reject(data.error);
           }
         });
@@ -2139,7 +2124,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");
       }
@@ -2945,7 +2929,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     this.config = {
       ttl: config?.ttl ?? 60 * 60 * 1e3,
       cleanupInterval: config?.cleanupInterval ?? 0,
-      maxChunks: config?.maxChunks ?? 1e3
+      maxChunks: config?.maxChunks ?? 1e5
       // Default max chunks per thread
     };
     if (this.config.cleanupInterval > 0) {
@@ -2999,9 +2983,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       const now = Date.now();
       buffer = {
         threadId,
-        chunks$: new ReplaySubject(
-          this.config.maxChunks ?? 1e5
-        ),
+        chunks$: new ReplaySubject(this.config.maxChunks),
         status: "active" /* ACTIVE */,
         createdAt: now,
         updatedAt: now,
@@ -3011,9 +2993,7 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
     }
     if (buffer.status !== "active" /* ACTIVE */) {
       buffer.status = "active" /* ACTIVE */;
-      buffer.chunks$ = new ReplaySubject(
-        this.config.maxChunks ?? 1e5
-      );
+      buffer.chunks$ = new ReplaySubject(this.config.maxChunks);
       buffer.updatedAt = Date.now();
       buffer.expiresAt = Date.now() + this.config.ttl;
     }
@@ -3246,6 +3226,498 @@ var getChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().get(key);
 var registerChunkBuffer = (key, buffer) => ChunkBufferLatticeManager.getInstance().register(key, buffer);
 var hasChunkBuffer = (key) => ChunkBufferLatticeManager.getInstance().has(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
 import * as Protocols from "@axiom-lattice/protocols";
 export {
@@ -3256,17 +3728,23 @@ export {
   AgentType,
   ChunkBuffer,
   ChunkBufferLatticeManager,
+  EmbeddingsLatticeManager,
   GraphBuildOptions,
+  InMemoryAssistantStore,
   InMemoryChunkBuffer,
+  InMemoryThreadStore,
   MemoryLatticeManager,
   MemoryQueueClient,
   MemoryType,
   ModelLatticeManager,
   Protocols,
   QueueLatticeManager,
+  StoreLatticeManager,
   ThreadStatus,
   ToolLatticeManager,
+  VectorStoreLatticeManager,
   agentLatticeManager,
+  embeddingsLatticeManager,
   eventBus,
   event_bus_default as eventBusDefault,
   getAgentClient,
@@ -3276,11 +3754,16 @@ export {
   getAllToolDefinitions,
   getCheckpointSaver,
   getChunkBuffer,
+  getEmbeddingsClient,
+  getEmbeddingsLattice,
   getModelLattice,
   getQueueLattice,
+  getStoreLattice,
   getToolClient,
   getToolDefinition,
   getToolLattice,
+  getVectorStoreClient,
+  getVectorStoreLattice,
   hasChunkBuffer,
   modelLatticeManager,
   queueLatticeManager,
@@ -3288,11 +3771,16 @@ export {
   registerAgentLattices,
   registerCheckpointSaver,
   registerChunkBuffer,
+  registerEmbeddingsLattice,
   registerModelLattice,
   registerQueueLattice,
+  registerStoreLattice,
   registerToolLattice,
+  registerVectorStoreLattice,
+  storeLatticeManager,
   toolLatticeManager,
   validateAgentInput,
-  validateToolInput
+  validateToolInput,
+  vectorStoreLatticeManager
 };
 //# sourceMappingURL=index.mjs.map