@axiom-lattice/client-sdk 2.1.4 → 2.1.6

package/dist/index.d.ts

@@ -80,6 +80,10 @@ interface Thread {
      * Thread identifier
      */
     id: string;
+    /**
+     * Assistant identifier this thread belongs to
+     */
+    assistantId: string;
     /**
      * Thread metadata
      */
@@ -87,7 +91,11 @@ interface Thread {
     /**
      * Thread creation timestamp
      */
-    createdAt: string;
+    createdAt: Date | string;
+    /**
+     * Thread last update timestamp
+     */
+    updatedAt: Date | string;
 }
 /**
  * Chat send options
@@ -283,6 +291,7 @@ type RunOptions = {
  * Agent state
  */
 interface AgentState {
+    createdAt?: string;
     values: {
         messages: Message[];
         [key: string]: any;
@@ -294,6 +303,164 @@ interface AgentState {
         }>;
     }>;
 }
+/**
+ * Assistant information
+ */
+interface Assistant {
+    /**
+     * Assistant identifier
+     */
+    id: string;
+    /**
+     * Assistant name
+     */
+    name: string;
+    /**
+     * Assistant description (optional)
+     */
+    description?: string;
+    /**
+     * Graph definition for the assistant
+     */
+    graphDefinition: any;
+    /**
+     * Creation timestamp
+     */
+    createdAt: Date | string;
+    /**
+     * Last update timestamp
+     */
+    updatedAt: Date | string;
+}
+/**
+ * Create assistant request options
+ */
+interface CreateAssistantOptions {
+    /**
+     * Assistant name
+     */
+    name: string;
+    /**
+     * Assistant description (optional)
+     */
+    description?: string;
+    /**
+     * Graph definition for the assistant
+     */
+    graphDefinition: any;
+}
+/**
+ * Update assistant request options
+ */
+interface UpdateAssistantOptions {
+    /**
+     * Assistant name (optional)
+     */
+    name?: string;
+    /**
+     * Assistant description (optional)
+     */
+    description?: string;
+    /**
+     * Graph definition for the assistant (optional)
+     */
+    graphDefinition?: any;
+}
+/**
+ * Assistant list response
+ */
+interface AssistantListResponse {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Response message
+     */
+    message: string;
+    /**
+     * Response data
+     */
+    data: {
+        /**
+         * List of assistants
+         */
+        records: Assistant[];
+        /**
+         * Total number of assistants
+         */
+        total: number;
+    };
+}
+/**
+ * Assistant response
+ */
+interface AssistantResponse {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Response message
+     */
+    message: string;
+    /**
+     * Assistant data (optional)
+     */
+    data?: Assistant;
+}
+/**
+ * Thread list response
+ */
+interface ThreadListResponse {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Response message
+     */
+    message: string;
+    /**
+     * Response data
+     */
+    data: {
+        /**
+         * List of threads
+         */
+        records: Thread[];
+        /**
+         * Total number of threads
+         */
+        total: number;
+    };
+}
+/**
+ * Thread response
+ */
+interface ThreadResponse {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Response message
+     */
+    message: string;
+    /**
+     * Thread data (optional)
+     */
+    data?: Thread;
+}
+/**
+ * Update thread request options
+ */
+interface UpdateThreadOptions {
+    /**
+     * Thread metadata (optional)
+     */
+    metadata?: Record<string, any>;
+}
 /**
  * Custom error classes
  */
@@ -371,24 +538,28 @@ declare abstract class AbstractClient {
     protected abstract streamRequest(options: RunOptions, onEvent: (event: MessageChunk) => void, onComplete?: (state?: AgentState) => void, onError?: (error: Error) => void): () => void;
     /**
      * 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
      */
     createThread(options: CreateThreadOptions): Promise<string>;
     /**
      * Retrieves thread information
+     * @deprecated Use threads.get() instead
      * @param threadId - Thread identifier
      * @returns A promise that resolves to the thread information
      */
     getThread(threadId: string): Promise<Thread>;
     /**
      * Lists all threads
+     * @deprecated Use threads.list() instead
      * @param options - Options for listing threads
      * @returns A promise that resolves to an array of threads
      */
     listThreads(options?: ListThreadsOptions): Promise<Thread[]>;
     /**
      * Deletes a thread
+     * @deprecated Use threads.delete() instead
      * @param threadId - Thread identifier
      * @returns A promise that resolves when the thread is deleted
      */
@@ -460,6 +631,81 @@ declare abstract class AbstractClient {
          */
         unregister: (name: string) => void;
     };
+    /**
+     * Assistants namespace for managing assistants
+     */
+    assistants: {
+        /**
+         * Lists all available assistants
+         * Returns both code-configured and stored assistants
+         * @returns A promise that resolves to the list of assistants
+         */
+        list: () => Promise<Assistant[]>;
+        /**
+         * 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: (id: string) => Promise<Assistant>;
+        /**
+         * 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: (options: CreateAssistantOptions) => Promise<Assistant>;
+        /**
+         * 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: (id: string, options: UpdateAssistantOptions) => Promise<Assistant>;
+        /**
+         * 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: (id: string) => Promise<void>;
+    };
+    /**
+     * Threads namespace for managing threads for the current assistant
+     */
+    threads: {
+        /**
+         * Lists all threads for the current assistant
+         * @returns A promise that resolves to the list of threads
+         */
+        list: () => Promise<Thread[]>;
+        /**
+         * Retrieves a single thread by ID for the current assistant
+         * @param threadId - Thread identifier
+         * @returns A promise that resolves to the thread information
+         */
+        get: (threadId: string) => Promise<Thread>;
+        /**
+         * 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: (options: CreateThreadOptions) => Promise<Thread>;
+        /**
+         * 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: (threadId: string, options: UpdateThreadOptions) => Promise<Thread>;
+        /**
+         * Deletes a thread by ID for the current assistant
+         * @param threadId - Thread identifier
+         * @returns A promise that resolves when the thread is deleted
+         */
+        delete: (threadId: string) => Promise<void>;
+    };
 }
 
 /**
@@ -615,4 +861,4 @@ declare function createSimpleMessageMerger(): {
     reset: () => void;
 };
 
-export { AbstractClient, AgentState, ApiError, AuthenticationError, ChatResponse, ChatSendOptions, ChatStreamOptions, Client, ClientConfig, CreateThreadOptions, GetMessagesOptions, ListThreadsOptions, NetworkError, RegisterToolOptions, ResumeStreamOptions, RetryConfig, RunOptions, StreamCallbacks, Thread, Transport, WeChatClient, createSimpleMessageMerger };
+export { AbstractClient, AgentState, ApiError, Assistant, AssistantListResponse, AssistantResponse, AuthenticationError, ChatResponse, ChatSendOptions, ChatStreamOptions, Client, ClientConfig, CreateAssistantOptions, CreateThreadOptions, GetMessagesOptions, ListThreadsOptions, NetworkError, RegisterToolOptions, ResumeStreamOptions, RetryConfig, RunOptions, StreamCallbacks, Thread, ThreadListResponse, ThreadResponse, Transport, UpdateAssistantOptions, UpdateThreadOptions, WeChatClient, createSimpleMessageMerger };

package/dist/index.js

@@ -1955,6 +1955,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
@@ -2017,65 +2220,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;
     }
@@ -2840,6 +3052,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);