@axiom-lattice/client-sdk 1.0.22 → 1.0.24

package/dist/index.mjs

@@ -21,7 +21,6 @@ var AuthenticationError = class extends Error {
 };
 
 // src/client.ts
-import axios from "axios";
 var Client = class {
   /**
    * Creates a new Client instance
@@ -74,7 +73,8 @@ var Client = class {
             threadId: options.threadId,
             message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
             streaming: true,
-            background: options.background
+            background: options.background,
+            enableReturnStateWhenSteamCompleted: options.enableReturnStateWhenSteamCompleted
           },
           onEvent,
           onComplete,
@@ -107,48 +107,70 @@ var Client = class {
       }
     };
     this.config = {
-      timeout: 3e4,
+      timeout: 3e5,
       ...config
     };
     this.assistantId = config.assistantId;
-    this.client = axios.create({
-      baseURL: this.config.baseURL,
-      timeout: this.config.timeout,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`,
-        ...this.config.headers
+    this.headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`,
+      ...this.config.headers
+    };
+  }
+  /**
+   * Helper method to handle fetch responses and errors
+   * @private
+   */
+  async handleResponse(response) {
+    if (!response.ok) {
+      if (response.status === 401) {
+        throw new AuthenticationError("Authentication failed");
+      } else {
+        const errorData = await response.json().catch(() => ({}));
+        throw new ApiError(
+          errorData.message || "API Error",
+          response.status,
+          errorData
+        );
       }
-    });
-    this.setupInterceptors();
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    try {
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Failed to parse response: ${error}`);
+    }
   }
   /**
-   * Sets up axios interceptors for error handling
+   * Helper method to make fetch requests
    * @private
    */
-  setupInterceptors() {
-    this.client.interceptors.response.use(
-      (response) => response,
-      (error) => {
-        if (error.response) {
-          if (error.response.status === 401) {
-            throw new AuthenticationError(
-              error.response.data.message || "Authentication failed"
-            );
-          } else {
-            throw new ApiError(
-              error.response.data.message || "API Error",
-              error.response.status,
-              error.response.data
-            );
-          }
-        } else if (error.request) {
-          throw new NetworkError("No response received from server");
-        } else {
-          throw new Error(`Request error: ${error.message}`);
-        }
+  async fetchWithTimeout(url, options = {}) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const fullUrl = url.startsWith("http") ? url : `${this.config.baseURL}${url}`;
+      const response = await fetch(fullUrl, {
+        ...options,
+        headers: {
+          ...this.headers,
+          ...options.headers || {}
+        },
+        signal: controller.signal
+      });
+      return await this.handleResponse(response);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new NetworkError("Request timed out");
+      } else if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new NetworkError("Network request failed");
       }
-    );
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
   /**
    * Set tenant ID for multi-tenant environments
@@ -156,7 +178,7 @@ var Client = class {
    */
   setTenantId(tenantId) {
     this.tenantId = tenantId;
-    this.client.defaults.headers["x-tenant-id"] = tenantId;
+    this.headers["x-tenant-id"] = tenantId;
   }
   /**
    * Creates a new thread
@@ -165,11 +187,14 @@ var Client = class {
    */
   async createThread(options) {
     try {
-      const response = await this.client.post("/threads", {
-        ...options,
-        assistantId: this.assistantId
+      const data = await this.fetchWithTimeout("/threads", {
+        method: "POST",
+        body: JSON.stringify({
+          ...options,
+          assistantId: this.assistantId
+        })
       });
-      return response.data.id;
+      return data.id;
     } catch (error) {
       throw error;
     }
@@ -181,12 +206,9 @@ var Client = class {
    */
   async getThread(threadId) {
     try {
-      const response = await this.client.get(`/threads/${threadId}`, {
-        params: {
-          assistantId: this.assistantId
-        }
-      });
-      return response.data;
+      const url = new URL(`${this.config.baseURL}/threads/${threadId}`);
+      url.searchParams.append("assistantId", this.assistantId);
+      return await this.fetchWithTimeout(url.toString());
     } catch (error) {
       throw error;
     }
@@ -198,13 +220,18 @@ var Client = class {
    */
   async listThreads(options) {
     try {
-      const response = await this.client.get("/threads", {
-        params: {
-          ...options,
-          assistantId: this.assistantId
-        }
-      });
-      return response.data.threads;
+      const url = new URL(`${this.config.baseURL}/threads`);
+      url.searchParams.append("assistantId", this.assistantId);
+      if (options?.limit) {
+        url.searchParams.append("limit", options.limit.toString());
+      }
+      if (options?.offset !== void 0) {
+        url.searchParams.append("offset", options.offset.toString());
+      }
+      const data = await this.fetchWithTimeout(
+        url.toString()
+      );
+      return data.threads;
     } catch (error) {
       throw error;
     }
@@ -216,10 +243,10 @@ var Client = class {
    */
   async deleteThread(threadId) {
     try {
-      await this.client.delete(`/threads/${threadId}`, {
-        params: {
-          assistantId: this.assistantId
-        }
+      const url = new URL(`${this.config.baseURL}/threads/${threadId}`);
+      url.searchParams.append("assistantId", this.assistantId);
+      await this.fetchWithTimeout(url.toString(), {
+        method: "DELETE"
       });
     } catch (error) {
       throw error;
@@ -232,18 +259,20 @@ var Client = class {
    */
   async getMessages(options) {
     try {
-      const response = await this.client.get(
-        `/api/assistants/${this.assistantId}/${options.threadId}/memory`,
-        {
-          params: {
-            limit: options.limit,
-            after: options.after,
-            reverse: options.reverse,
-            assistantId: this.assistantId
-          }
-        }
+      const url = new URL(
+        `${this.config.baseURL}/api/assistants/${this.assistantId}/${options.threadId}/memory`
       );
-      return response.data;
+      if (options.limit) {
+        url.searchParams.append("limit", options.limit.toString());
+      }
+      if (options.after) {
+        url.searchParams.append("after", options.after);
+      }
+      if (options.reverse !== void 0) {
+        url.searchParams.append("reverse", options.reverse.toString());
+      }
+      url.searchParams.append("assistantId", this.assistantId);
+      return await this.fetchWithTimeout(url.toString());
     } catch (error) {
       throw error;
     }
@@ -255,10 +284,9 @@ var Client = class {
    */
   async getAgentState(threadId) {
     try {
-      const response = await this.client.get(
+      return await this.fetchWithTimeout(
         `/api/assistants/${this.assistantId}/${threadId}/state`
       );
-      return response.data;
     } catch (error) {
       throw error;
     }
@@ -269,10 +297,10 @@ var Client = class {
    */
   async getAgentGraph() {
     try {
-      const response = await this.client.get(
+      const data = await this.fetchWithTimeout(
         `/api/assistants/${this.assistantId}/graph`
       );
-      return response.data.image;
+      return data.image;
     } catch (error) {
       throw error;
     }
@@ -280,7 +308,7 @@ var Client = class {
   /**
    * Run agent with options
    * @param options - Options for running the agent
-   * @returns A promise that resolves to the run result or a stream
+   * @returns A promise that resolves to the run result
    */
   async run(options) {
     try {
@@ -293,9 +321,10 @@ var Client = class {
           "Streaming without callbacks is not supported. Use chat.stream with callbacks instead."
         );
       } else {
-        const response = await this.client.post(
-          "/api/runs",
-          {
+        return await this.fetchWithTimeout("/api/runs", {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
             assistant_id: this.assistantId,
             thread_id: options.threadId,
             message: options.message,
@@ -303,10 +332,8 @@ var Client = class {
             command: options.command,
             streaming: false,
             background: options.background || false
-          },
-          { headers }
-        );
-        return response.data;
+          })
+        });
       }
     } catch (error) {
       throw error;
@@ -322,22 +349,20 @@ var Client = class {
    */
   streamRun(options, onEvent, onComplete, onError) {
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      ...this.headers
     };
     if (this.tenantId) {
       headers["x-tenant-id"] = this.tenantId;
     }
     const controller = new AbortController();
-    const signal = controller.signal;
+    const { signal } = controller;
     (async () => {
       try {
         const response = await fetch(`${this.config.baseURL}/api/runs`, {
           method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.config.apiKey}`,
-            ...headers
-          },
+          headers,
           body: JSON.stringify({
             assistant_id: this.assistantId,
             thread_id: options.threadId,
@@ -350,7 +375,7 @@ var Client = class {
           signal
         });
         if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
+          throw new Error(`HTTP error! Status: ${response.status}`);
         }
         if (!response.body) {
           throw new Error("Response body is null");
@@ -359,17 +384,9 @@ var Client = class {
         const decoder = new TextDecoder();
         let buffer = "";
         while (true) {
-          const { value, done } = await reader.read();
-          if (done) {
-            if (buffer.trim()) {
-              try {
-                const data = JSON.parse(buffer.trim());
-                onEvent(data);
-              } catch (error) {
-              }
-            }
+          const { done, value } = await reader.read();
+          if (done)
             break;
-          }
           const chunk = decoder.decode(value, { stream: true });
           buffer += chunk;
           const lines = buffer.split("\n");
@@ -377,9 +394,10 @@ var Client = class {
           for (const line of lines) {
             if (line.trim().startsWith("data: ")) {
               try {
-                const data = JSON.parse(line.trim().slice(6));
-                onEvent(data);
+                const eventData = JSON.parse(line.trim().slice(6));
+                onEvent(eventData);
               } catch (error) {
+                console.error("Error parsing SSE data:", line, error);
                 if (onError) {
                   onError(
                     error instanceof Error ? error : new Error(String(error))
@@ -389,11 +407,28 @@ var Client = class {
             }
           }
         }
+        if (buffer && buffer.trim().startsWith("data: ")) {
+          try {
+            const eventData = JSON.parse(buffer.trim().slice(6));
+            onEvent(eventData);
+          } catch (error) {
+            console.error("Error parsing SSE data:", buffer, error);
+          }
+        }
         if (onComplete) {
-          onComplete();
+          if (options.enableReturnStateWhenSteamCompleted) {
+            try {
+              const state = await this.getAgentState(options.threadId);
+              onComplete(state);
+            } catch (error) {
+              onComplete();
+            }
+          } else {
+            onComplete();
+          }
         }
       } catch (error) {
-        if (signal.aborted) {
+        if (error instanceof DOMException && error.name === "AbortError") {
           return;
         }
         if (onError) {
@@ -407,6 +442,405 @@ var Client = class {
   }
 };
 
+// src/wechat-client.ts
+var WeChatClient = class {
+  /**
+   * Creates a new WeChatClient instance
+   * @param config - Configuration options for the client
+   */
+  constructor(config) {
+    this.tenantId = "";
+    this.registeredTools = /* @__PURE__ */ new Map();
+    /**
+     * Chat namespace for sending messages and streaming responses
+     */
+    this.chat = {
+      /**
+       * Sends a message to a thread and receives a response
+       * @param options - Options for sending a message
+       * @returns A promise that resolves to the chat response
+       */
+      send: async (options) => {
+        try {
+          const message = options.messages[options.messages.length - 1];
+          const result = await this.run({
+            threadId: options.threadId,
+            message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            streaming: false
+          });
+          return {
+            message: {
+              role: "ai",
+              content: result.output || "",
+              id: result.id || ""
+            },
+            traceId: result.id || ""
+          };
+        } catch (error) {
+          throw error;
+        }
+      },
+      /**
+       * Sends a message to a thread and streams the response
+       * @param options - Options for streaming a message
+       * @param onEvent - Callback function that receives stream events
+       * @param onComplete - Optional callback function called when streaming completes
+       * @param onError - Optional callback function called when an error occurs
+       * @returns A function that can be called to stop the stream
+       */
+      stream: (options, onEvent, onComplete, onError) => {
+        const message = options.messages[options.messages.length - 1];
+        return this.streamRun(
+          {
+            threadId: options.threadId,
+            message: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            streaming: true,
+            background: options.background,
+            enableReturnStateWhenSteamCompleted: options.enableReturnStateWhenSteamCompleted
+          },
+          onEvent,
+          onComplete,
+          onError
+        );
+      }
+    };
+    /**
+     * Tools namespace for registering and unregistering client-side tools
+     */
+    this.tools = {
+      /**
+       * Registers a client-side tool
+       * @param options - Options for registering a tool
+       */
+      register: (options) => {
+        if (this.config.transport !== "ws") {
+          throw new Error(
+            "Client-side tools are only supported with WebSocket transport"
+          );
+        }
+        this.registeredTools.set(options.name, options);
+      },
+      /**
+       * Unregisters a client-side tool
+       * @param name - Tool name
+       */
+      unregister: (name) => {
+        this.registeredTools.delete(name);
+      }
+    };
+    this.config = {
+      timeout: 3e4,
+      ...config
+    };
+    this.assistantId = config.assistantId;
+  }
+  /**
+   * Set tenant ID for multi-tenant environments
+   * @param tenantId - Tenant identifier
+   */
+  setTenantId(tenantId) {
+    this.tenantId = tenantId;
+  }
+  /**
+   * Helper method to make WeChat HTTP requests
+   * @private
+   */
+  async request(options) {
+    const { url, method, data, params } = options;
+    let fullUrl = `${this.config.baseURL}${url}`;
+    if (params && Object.keys(params).length > 0) {
+      const queryParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          queryParams.append(key, String(value));
+        }
+      });
+      fullUrl += `?${queryParams.toString()}`;
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`,
+      ...this.config.headers
+    };
+    if (this.tenantId) {
+      headers["x-tenant-id"] = this.tenantId;
+    }
+    return new Promise((resolve, reject) => {
+      wx.request({
+        url: fullUrl,
+        method,
+        data,
+        header: headers,
+        timeout: this.config.timeout,
+        success: (res) => {
+          const statusCode = res.statusCode;
+          if (statusCode >= 200 && statusCode < 300) {
+            resolve(res.data);
+          } else if (statusCode === 401) {
+            reject(
+              new AuthenticationError(
+                res.data?.message || "Authentication failed"
+              )
+            );
+          } else {
+            reject(
+              new ApiError(
+                res.data?.message || "API Error",
+                statusCode,
+                res.data
+              )
+            );
+          }
+        },
+        fail: (err) => {
+          reject(new NetworkError(`Request failed: ${err.errMsg}`));
+        }
+      });
+    });
+  }
+  /**
+   * Creates a new thread
+   * @param options - Options for creating a thread
+   * @returns A promise that resolves to the thread ID
+   */
+  async createThread(options) {
+    try {
+      const response = await this.request({
+        url: "/threads",
+        method: "POST",
+        data: {
+          ...options,
+          assistantId: this.assistantId
+        }
+      });
+      return response.id;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves thread information
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves to the thread information
+   */
+  async getThread(threadId) {
+    try {
+      return await this.request({
+        url: `/threads/${threadId}`,
+        method: "GET",
+        params: {
+          assistantId: this.assistantId
+        }
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Lists all threads
+   * @param options - Options for listing threads
+   * @returns A promise that resolves to an array of threads
+   */
+  async listThreads(options) {
+    try {
+      const response = await this.request({
+        url: "/threads",
+        method: "GET",
+        params: {
+          ...options,
+          assistantId: this.assistantId
+        }
+      });
+      return response.threads;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Deletes a thread
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves when the thread is deleted
+   */
+  async deleteThread(threadId) {
+    try {
+      await this.request({
+        url: `/threads/${threadId}`,
+        method: "DELETE",
+        params: {
+          assistantId: this.assistantId
+        }
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves messages from a thread
+   * @param options - Options for retrieving messages
+   * @returns A promise that resolves to an array of messages
+   */
+  async getMessages(options) {
+    try {
+      return await this.request({
+        url: `/api/assistants/${this.assistantId}/${options.threadId}/memory`,
+        method: "GET",
+        params: {
+          limit: options.limit,
+          after: options.after,
+          reverse: options.reverse,
+          assistantId: this.assistantId
+        }
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Retrieves agent state
+   * @param threadId - Thread identifier
+   * @returns A promise that resolves to the agent state
+   */
+  async getAgentState(threadId) {
+    try {
+      return await this.request({
+        url: `/api/assistants/${this.assistantId}/${threadId}/state`,
+        method: "GET"
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Gets agent graph visualization
+   * @returns A promise that resolves to the graph visualization data
+   */
+  async getAgentGraph() {
+    try {
+      const response = await this.request({
+        url: `/api/assistants/${this.assistantId}/graph`,
+        method: "GET"
+      });
+      return response.image;
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Run agent with options
+   * @param options - Options for running the agent
+   * @returns A promise that resolves to the run result
+   */
+  async run(options) {
+    try {
+      if (options.streaming) {
+        throw new Error(
+          "Streaming without callbacks is not supported. Use chat.stream with callbacks instead."
+        );
+      } else {
+        return await this.request({
+          url: "/api/runs",
+          method: "POST",
+          data: {
+            assistant_id: this.assistantId,
+            thread_id: options.threadId,
+            message: options.message,
+            files: options.files,
+            command: options.command,
+            streaming: false,
+            background: options.background || false
+          }
+        });
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * Stream run results using WeChat's downloadFile API
+   * @param options - Options for streaming run results
+   * @param onEvent - Callback function that receives stream events
+   * @param onComplete - Optional callback function called when streaming completes
+   * @param onError - Optional callback function called when an error occurs
+   * @returns A function that can be called to stop the stream
+   */
+  streamRun(options, onEvent, onComplete, onError) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`,
+      ...this.config.headers
+    };
+    if (this.tenantId) {
+      headers["x-tenant-id"] = this.tenantId;
+    }
+    const taskId = wx.request({
+      url: `${this.config.baseURL}/api/runs`,
+      method: "POST",
+      data: {
+        assistant_id: this.assistantId,
+        thread_id: options.threadId,
+        message: options.message,
+        files: options.files,
+        command: options.command,
+        streaming: true,
+        background: options.background || false
+      },
+      header: headers,
+      responseType: "text",
+      enableChunked: true,
+      success: async () => {
+      },
+      fail: (err) => {
+        if (onError) {
+          onError(new Error(`Stream request failed: ${err.errMsg}`));
+        }
+      },
+      complete: async () => {
+        if (onComplete) {
+          if (options.enableReturnStateWhenSteamCompleted) {
+            try {
+              const state = await this.getAgentState(options.threadId);
+              onComplete(state);
+            } catch (error) {
+              onComplete();
+            }
+          } else {
+            onComplete();
+          }
+        }
+      },
+      // Using WeChat's chunked data capability
+      dataReceived: (res) => {
+        if (!res.data)
+          return;
+        const textDecoder = new TextDecoder();
+        const text = textDecoder.decode(res.data);
+        const lines = text.split("\n");
+        for (const line of lines) {
+          if (line.trim().startsWith("data: ")) {
+            try {
+              const eventData = JSON.parse(line.trim().slice(6));
+              onEvent(eventData);
+            } catch (error) {
+              if (onError) {
+                onError(
+                  error instanceof Error ? error : new Error(String(error))
+                );
+              }
+            }
+          }
+        }
+      }
+    });
+    return () => {
+      wx.abortRequest({
+        requestId: taskId,
+        success: () => console.log("Stream request aborted"),
+        fail: (err) => console.error("Failed to abort stream request:", err.errMsg)
+      });
+    };
+  }
+};
+
 // src/ChunkMessageMerger.ts
 function createSimpleMessageMerger() {
   let messages = [];
@@ -489,7 +923,6 @@ function createSimpleMessageMerger() {
     messages = msgs;
   }
   function push(chunk) {
-    console.log(chunk);
     const role = normalizeRole(chunk.type);
     const message = ensureMessage(chunk.data.id, role);
     if (chunk.data.content) {
@@ -525,7 +958,8 @@ function createSimpleMessageMerger() {
         name: tc.name,
         args: tc.args,
         type: "tool_call",
-        response: tc.response
+        response: tc.response,
+        status: "success"
       }));
       if (toolCalls.length > 0) {
         message.tool_calls = toolCalls;
@@ -568,7 +1002,8 @@ function createSimpleMessageMerger() {
               if (toolResponse) {
                 return {
                   ...toolCall,
-                  response: toolResponse.content
+                  response: toolResponse.content,
+                  status: "success"
                 };
               }
               return toolCall;
@@ -603,6 +1038,7 @@ export {
   AuthenticationError,
   Client,
   NetworkError,
+  WeChatClient,
   createSimpleMessageMerger
 };
 //# sourceMappingURL=index.mjs.map