@axiom-lattice/client-sdk 2.1.4 → 2.1.6

package/dist/index.mjs

@@ -1936,6 +1936,209 @@ var AbstractClient = class {
         this.registeredTools.delete(name);
       }
     };
+    /**
+     * Assistants namespace for managing assistants
+     */
+    this.assistants = {
+      /**
+       * Lists all available assistants
+       * Returns both code-configured and stored assistants
+       * @returns A promise that resolves to the list of assistants
+       */
+      list: async () => {
+        try {
+          const response = await this.makeRequest(
+            "/api/assistants"
+          );
+          return response.data.records;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Retrieves a single assistant by ID
+       * Checks both code-configured and stored assistants
+       * @param id - Assistant identifier
+       * @returns A promise that resolves to the assistant information
+       */
+      get: async (id) => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${id}`
+          );
+          if (!response.data) {
+            throw new ApiError("Assistant not found", 404);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Creates a new assistant
+       * Only creates stored assistants (code-configured assistants cannot be created via API)
+       * @param options - Options for creating an assistant
+       * @returns A promise that resolves to the created assistant
+       */
+      create: async (options) => {
+        try {
+          const response = await this.makeRequest(
+            "/api/assistants",
+            {
+              method: "POST",
+              body: options
+            }
+          );
+          if (!response.data) {
+            throw new ApiError("Failed to create assistant", 500);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Updates an existing assistant by ID
+       * Only works on stored assistants (code-configured assistants cannot be updated)
+       * @param id - Assistant identifier
+       * @param options - Options for updating an assistant
+       * @returns A promise that resolves to the updated assistant
+       */
+      update: async (id, options) => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${id}`,
+            {
+              method: "PUT",
+              body: options
+            }
+          );
+          if (!response.data) {
+            throw new ApiError("Failed to update assistant", 500);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Deletes an assistant by ID
+       * Only works on stored assistants (code-configured assistants cannot be deleted)
+       * @param id - Assistant identifier
+       * @returns A promise that resolves when the assistant is deleted
+       */
+      delete: async (id) => {
+        try {
+          await this.makeRequest(
+            `/api/assistants/${id}`,
+            {
+              method: "DELETE"
+            }
+          );
+        } catch (error) {
+          throw error;
+        }
+      }
+    };
+    /**
+     * Threads namespace for managing threads for the current assistant
+     */
+    this.threads = {
+      /**
+       * Lists all threads for the current assistant
+       * @returns A promise that resolves to the list of threads
+       */
+      list: async () => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${this.assistantId}/threads`
+          );
+          return response.data.records;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Retrieves a single thread by ID for the current assistant
+       * @param threadId - Thread identifier
+       * @returns A promise that resolves to the thread information
+       */
+      get: async (threadId) => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${this.assistantId}/threads/${threadId}`
+          );
+          if (!response.data) {
+            throw new ApiError("Thread not found", 404);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Creates a new thread for the current assistant
+       * @param options - Options for creating a thread
+       * @returns A promise that resolves to the created thread
+       */
+      create: async (options) => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${this.assistantId}/threads`,
+            {
+              method: "POST",
+              body: options
+            }
+          );
+          if (!response.data) {
+            throw new ApiError("Failed to create thread", 500);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Updates an existing thread by ID for the current assistant
+       * @param threadId - Thread identifier
+       * @param options - Options for updating a thread
+       * @returns A promise that resolves to the updated thread
+       */
+      update: async (threadId, options) => {
+        try {
+          const response = await this.makeRequest(
+            `/api/assistants/${this.assistantId}/threads/${threadId}`,
+            {
+              method: "PUT",
+              body: options
+            }
+          );
+          if (!response.data) {
+            throw new ApiError("Failed to update thread", 500);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Deletes a thread by ID for the current assistant
+       * @param threadId - Thread identifier
+       * @returns A promise that resolves when the thread is deleted
+       */
+      delete: async (threadId) => {
+        try {
+          await this.makeRequest(
+            `/api/assistants/${this.assistantId}/threads/${threadId}`,
+            {
+              method: "DELETE"
+            }
+          );
+        } catch (error) {
+          throw error;
+        }
+      }
+    };
     this.config = {
       timeout: 3e5,
       // Default timeout
@@ -1998,65 +2201,74 @@ var AbstractClient = class {
   }
   /**
    * Creates a new thread
+   * @deprecated Use threads.create() instead
    * @param options - Options for creating a thread
    * @returns A promise that resolves to the thread ID
    */
   async createThread(options) {
     try {
-      const data = await this.makeRequest("/threads", {
-        method: "POST",
-        body: {
-          ...options,
-          assistantId: this.assistantId
+      const response = await this.makeRequest(
+        `/api/assistants/${this.assistantId}/threads`,
+        {
+          method: "POST",
+          body: options
         }
-      });
-      return data.id;
+      );
+      if (!response.data) {
+        throw new ApiError("Failed to create thread", 500);
+      }
+      return response.data.id;
     } catch (error) {
       throw error;
     }
   }
   /**
    * Retrieves thread information
+   * @deprecated Use threads.get() instead
    * @param threadId - Thread identifier
    * @returns A promise that resolves to the thread information
    */
   async getThread(threadId) {
     try {
-      const url = `/threads/${threadId}?assistantId=${this.assistantId}`;
-      return await this.makeRequest(url);
+      const response = await this.makeRequest(
+        `/api/assistants/${this.assistantId}/threads/${threadId}`
+      );
+      if (!response.data) {
+        throw new ApiError("Thread not found", 404);
+      }
+      return response.data;
     } catch (error) {
       throw error;
     }
   }
   /**
    * Lists all threads
+   * @deprecated Use threads.list() instead
    * @param options - Options for listing threads
    * @returns A promise that resolves to an array of threads
    */
   async listThreads(options) {
     try {
-      let url = `/threads?assistantId=${this.assistantId}`;
-      if (options?.limit) {
-        url += `&limit=${options.limit}`;
-      }
-      if (options?.offset !== void 0) {
-        url += `&offset=${options.offset}`;
-      }
-      const data = await this.makeRequest(url);
-      return data.threads;
+      const response = await this.makeRequest(
+        `/api/assistants/${this.assistantId}/threads`
+      );
+      return response.data.records;
     } catch (error) {
       throw error;
     }
   }
   /**
    * Deletes a thread
+   * @deprecated Use threads.delete() instead
    * @param threadId - Thread identifier
    * @returns A promise that resolves when the thread is deleted
    */
   async deleteThread(threadId) {
     try {
-      const url = `/threads/${threadId}?assistantId=${this.assistantId}`;
-      await this.makeRequest(url, { method: "DELETE" });
+      await this.makeRequest(
+        `/api/assistants/${this.assistantId}/threads/${threadId}`,
+        { method: "DELETE" }
+      );
     } catch (error) {
       throw error;
     }
@@ -2821,6 +3033,31 @@ function createSimpleMessageMerger() {
   }
   function initialMessages(msgs) {
     messages = msgs;
+    messageMap.clear();
+    messages.forEach((msg, index) => {
+      if (msg.id) {
+        messageMap.set(msg.id, index);
+      }
+    });
+    toolBuilders.clear();
+    messages.forEach((msg) => {
+      if (msg.role === "ai" && msg.tool_calls && Array.isArray(msg.tool_calls)) {
+        const builders = /* @__PURE__ */ new Map();
+        msg.tool_calls.forEach((toolCall, index) => {
+          if (toolCall.id && toolCall.name) {
+            const argsStr = typeof toolCall.args === "object" ? JSON.stringify(toolCall.args) : String(toolCall.args || "");
+            builders.set(index, {
+              id: toolCall.id,
+              name: toolCall.name,
+              args: argsStr
+            });
+          }
+        });
+        if (builders.size > 0) {
+          toolBuilders.set(msg.id, builders);
+        }
+      }
+    });
   }
   function push(chunk) {
     const role = normalizeRole(chunk.type);