@axiom-lattice/client-sdk 2.1.56 → 2.1.57

package/dist/index.d.ts

@@ -935,6 +935,8 @@ declare abstract class AbstractClient {
         update: (id: string, data: UpdateMcpServerConfigRequest) => Promise<McpServerConfigEntry>;
         delete: (id: string) => Promise<void>;
         test: (id: string) => Promise<TestMcpServerResponse>;
+        connect: (id: string) => Promise<McpServerConfigEntry>;
+        disconnect: (id: string) => Promise<McpServerConfigEntry>;
     };
     /**
      * Tasks namespace for managing tasks
@@ -1217,6 +1219,80 @@ declare abstract class AbstractClient {
          */
         delete: (id: string) => Promise<void>;
     };
+    /**
+     * Collections namespace for managing vector collections
+     */
+    collections: {
+        /**
+         * Lists all available collections
+         * @returns A promise that resolves to the list of collections
+         */
+        list: () => Promise<any[]>;
+        /**
+         * Retrieves a single collection by name
+         * @param name - Collection name
+         * @returns A promise that resolves to the collection information
+         */
+        get: (name: string) => Promise<any>;
+        /**
+         * Creates a new collection
+         * @param options - Options for creating a collection
+         * @returns A promise that resolves to the created collection
+         */
+        create: (options: {
+            name: string;
+            label: string;
+            embeddingKey: string;
+            schema?: {
+                fields: Array<{
+                    key: string;
+                    type: string;
+                    enumValues?: string[];
+                    required?: boolean;
+                }>;
+            };
+        }) => Promise<any>;
+        /**
+         * Updates an existing collection by name
+         * @param name - Collection name
+         * @param options - Options for updating a collection
+         * @returns A promise that resolves to the updated collection
+         */
+        update: (name: string, options: {
+            label?: string;
+            embeddingKey?: string;
+            schema?: any;
+        }) => Promise<any>;
+        /**
+         * Deletes a collection by name
+         * @param name - Collection name
+         * @returns A promise that resolves when the collection is deleted
+         */
+        delete: (name: string) => Promise<void>;
+        /**
+         * Entries sub-namespace for a specific collection.
+         * Returns entry CRUD + search methods scoped to the given collection.
+         * @param collectionName - The collection name
+         * @returns Entry operation methods
+         */
+        entries: (collectionName: string) => {
+            list: () => Promise<any[]>;
+            create: (data: {
+                content: string;
+                metadata?: Record<string, unknown>;
+            }) => Promise<any>;
+            get: (id: string) => Promise<any>;
+            update: (id: string, data: {
+                content?: string;
+                metadata?: Record<string, unknown>;
+            }) => Promise<any>;
+            delete: (id: string) => Promise<void>;
+            search: (query: string, opts?: {
+                filter?: Record<string, unknown>;
+                top_k?: number;
+            }) => Promise<any[]>;
+        };
+    };
     /**
      * Threads namespace for managing threads for the current assistant
      */

package/dist/index.js

@@ -2154,6 +2154,124 @@ var AbstractClient = class {
         );
       }
     };
+    /**
+     * Collections namespace for managing vector collections
+     */
+    this.collections = {
+      /**
+       * Lists all available collections
+       * @returns A promise that resolves to the list of collections
+       */
+      list: async () => {
+        const response = await this.makeRequest("/api/collections");
+        return response.data.records;
+      },
+      /**
+       * Retrieves a single collection by name
+       * @param name - Collection name
+       * @returns A promise that resolves to the collection information
+       */
+      get: async (name) => {
+        const response = await this.makeRequest(`/api/collections/${name}`);
+        if (!response.data) {
+          throw new ApiError("Collection not found", 404);
+        }
+        return response.data;
+      },
+      /**
+       * Creates a new collection
+       * @param options - Options for creating a collection
+       * @returns A promise that resolves to the created collection
+       */
+      create: async (options) => {
+        const response = await this.makeRequest("/api/collections", {
+          method: "POST",
+          body: options
+        });
+        if (!response.data) {
+          throw new ApiError("Failed to create collection", 500);
+        }
+        return response.data;
+      },
+      /**
+       * Updates an existing collection by name
+       * @param name - Collection name
+       * @param options - Options for updating a collection
+       * @returns A promise that resolves to the updated collection
+       */
+      update: async (name, options) => {
+        const response = await this.makeRequest(`/api/collections/${name}`, {
+          method: "PUT",
+          body: options
+        });
+        if (!response.data) {
+          throw new ApiError("Failed to update collection", 500);
+        }
+        return response.data;
+      },
+      /**
+       * Deletes a collection by name
+       * @param name - Collection name
+       * @returns A promise that resolves when the collection is deleted
+       */
+      delete: async (name) => {
+        await this.makeRequest(
+          `/api/collections/${name}`,
+          {
+            method: "DELETE"
+          }
+        );
+      },
+      /**
+       * Entries sub-namespace for a specific collection.
+       * Returns entry CRUD + search methods scoped to the given collection.
+       * @param collectionName - The collection name
+       * @returns Entry operation methods
+       */
+      entries: (collectionName) => ({
+        list: async () => {
+          const response = await this.makeRequest(`/api/collections/${collectionName}/entries`);
+          return response.data.records;
+        },
+        create: async (data) => {
+          const response = await this.makeRequest(`/api/collections/${collectionName}/entries`, {
+            method: "POST",
+            body: data
+          });
+          if (!response.data)
+            throw new ApiError("Failed to create entry", 500);
+          return response.data;
+        },
+        get: async (id) => {
+          const response = await this.makeRequest(`/api/collections/${collectionName}/entries/${id}`);
+          if (!response.data)
+            throw new ApiError("Entry not found", 404);
+          return response.data;
+        },
+        update: async (id, data) => {
+          const response = await this.makeRequest(`/api/collections/${collectionName}/entries/${id}`, {
+            method: "PUT",
+            body: data
+          });
+          if (!response.data)
+            throw new ApiError("Failed to update entry", 500);
+          return response.data;
+        },
+        delete: async (id) => {
+          await this.makeRequest(
+            `/api/collections/${collectionName}/entries/${id}`,
+            { method: "DELETE" }
+          );
+        },
+        search: async (query, opts) => {
+          const response = await this.makeRequest(`/api/collections/${collectionName}/search`, {
+            method: "POST",
+            body: { query, ...opts }
+          });
+          return response.data.records;
+        }
+      })
+    };
     /**
      * Threads namespace for managing threads for the current assistant
      */
@@ -2431,6 +2549,18 @@ var AbstractClient = class {
       },
       test: async (id) => {
         return await this.makeRequest(`/api/mcp-servers/${id}/test`, { method: "POST" });
+      },
+      connect: async (id) => {
+        const response = await this.makeRequest(`/api/mcp-servers/${id}/connect`, { method: "POST" });
+        if (!response.data)
+          throw new ApiError("Failed to connect MCP server", 500);
+        return response.data;
+      },
+      disconnect: async (id) => {
+        const response = await this.makeRequest(`/api/mcp-servers/${id}/disconnect`, { method: "POST" });
+        if (!response.data)
+          throw new ApiError("Failed to disconnect MCP server", 500);
+        return response.data;
       }
     };
     this.tasks = {
@@ -3738,14 +3868,20 @@ function createSimpleMessageMerger() {
     }
     return newMessage;
   }
-  function updateToolCalls(message) {
-    if (message.role !== "ai")
-      return;
-    const builders = toolBuilders.get(message.id);
+  function replaceMessage(id, updates) {
+    const index = messageMap.get(id);
+    if (index === void 0)
+      return null;
+    const updated = { ...messages[index], ...updates };
+    messages[index] = updated;
+    return updated;
+  }
+  function buildToolCalls(messageId) {
+    const builders = toolBuilders.get(messageId);
     if (!builders || builders.size === 0)
-      return;
+      return null;
     const toolCalls = [];
-    for (const [index, builder] of Array.from(builders.entries())) {
+    for (const [, builder] of Array.from(builders.entries())) {
       if (builder.name && builder.id) {
         const args = builder.args.trim();
         const parsedArgs = safeJsonParse(args);
@@ -3757,9 +3893,7 @@ function createSimpleMessageMerger() {
         });
       }
     }
-    if (toolCalls.length > 0) {
-      message.tool_calls = toolCalls;
-    }
+    return toolCalls.length > 0 ? toolCalls : null;
   }
   function initialMessages(msgs) {
     reset();
@@ -3769,15 +3903,21 @@ function createSimpleMessageMerger() {
   }
   function push(chunk) {
     const role = normalizeRole(chunk.type);
-    const message = ensureMessage(chunk.data.id, role);
+    let message = ensureMessage(chunk.data.id, role);
+    const isInArray = message.role !== "tool";
     if (chunk.data.content) {
-      message.content = (message.content || "") + chunk.data.content;
+      const newContent = (message.content || "") + chunk.data.content;
+      if (isInArray) {
+        message = replaceMessage(chunk.data.id, { content: newContent }) || message;
+      } else {
+        message.content = newContent;
+      }
     }
     if (message.role === "ai" && chunk.data.tool_calls && chunk.data.tool_calls.length > 0) {
       for (const toolCall of chunk.data.tool_calls) {
         toolId_MessageIdMap.set(toolCall.id, message.id);
       }
-      message.tool_calls = chunk.data.tool_calls;
+      message = replaceMessage(chunk.data.id, { tool_calls: [...chunk.data.tool_calls] }) || message;
     }
     if (chunk.data.tool_call_chunks && message.role === "ai") {
       let builders = toolBuilders.get(message.id);
@@ -3798,7 +3938,10 @@ function createSimpleMessageMerger() {
         if (chunk_item.args)
           builder.args += chunk_item.args;
       }
-      updateToolCalls(message);
+      const toolCalls = buildToolCalls(message.id);
+      if (toolCalls) {
+        message = replaceMessage(chunk.data.id, { tool_calls: toolCalls }) || message;
+      }
     }
     if (message.role === "tool" && chunk.data.tool_call_id) {
       const original_tool_message_id = chunk.data.id;
@@ -3807,49 +3950,19 @@ function createSimpleMessageMerger() {
         return;
       const messageIndex = messageMap.get(messageId);
       if (messageIndex !== void 0) {
-        const message2 = messages[messageIndex];
-        message2.tool_calls = message2.tool_calls?.map((tc) => {
+        const aiMessage = messages[messageIndex];
+        const updatedToolCalls = aiMessage.tool_calls?.map((tc) => {
           if (tc.id === chunk.data.tool_call_id) {
             return { ...tc, response: chunk.data.content, status: "success", original_tool_message_id };
           }
           return tc;
         });
-        messages[messageIndex] = message2;
+        messages[messageIndex] = { ...aiMessage, tool_calls: updatedToolCalls };
       }
     }
   }
   function getMessages() {
     return [...messages];
-    const toolResponsesMap = {};
-    messages.forEach((message) => {
-      if (message.role === "tool" && message.tool_call_id) {
-        toolResponsesMap[message.tool_call_id] = message;
-      }
-    });
-    return messages.filter((message) => {
-      return message.role !== "tool";
-    }).map((message) => {
-      if (message.role === "ai" && message.tool_calls) {
-        const mergedMessage = { ...message };
-        if (mergedMessage.tool_calls) {
-          mergedMessage.tool_calls = mergedMessage.tool_calls.map(
-            (toolCall) => {
-              const toolResponse = toolResponsesMap[toolCall.id];
-              if (toolResponse) {
-                return {
-                  ...toolCall,
-                  response: toolResponse.content,
-                  status: "success"
-                };
-              }
-              return toolCall;
-            }
-          );
-        }
-        return mergedMessage;
-      }
-      return message;
-    });
   }
   function getMessagesWithoutToolCalls() {
     return messages.filter(