@axiom-lattice/client-sdk 1.0.23 → 1.0.25

package/dist/index.mjs

@@ -20,182 +20,6 @@ var AuthenticationError = class extends Error {
   }
 };
 
-// src/client.ts
-import axios from "axios";
-
-// src/wechat-client.ts
-import { promisify } from "miniprogram-api-promise";
-function createWechatClient(config) {
-  let wxApi = null;
-  if (typeof global !== "undefined" && global.wx) {
-    wxApi = global.wx;
-  } else if (typeof globalThis !== "undefined" && globalThis.wx) {
-    wxApi = globalThis.wx;
-  } else {
-    try {
-      const win = globalThis;
-      if (win.wx) {
-        wxApi = win.wx;
-      }
-    } catch (e) {
-    }
-  }
-  if (!wxApi) {
-    throw new Error("WeChat Mini Program environment not detected");
-  }
-  const request = promisify(wxApi.request);
-  const defaultHeaders = {
-    "Content-Type": "application/json",
-    ...config.headers
-  };
-  const interceptors = {
-    request: {
-      handlers: [],
-      use(fulfilled, rejected) {
-        const id = this.handlers.length;
-        this.handlers.push({ fulfilled, rejected });
-        return id;
-      },
-      eject(id) {
-        if (this.handlers[id]) {
-          this.handlers[id] = {};
-        }
-      }
-    },
-    response: {
-      handlers: [],
-      use(fulfilled, rejected) {
-        const id = this.handlers.length;
-        this.handlers.push({ fulfilled, rejected });
-        return id;
-      },
-      eject(id) {
-        if (this.handlers[id]) {
-          this.handlers[id] = {};
-        }
-      }
-    }
-  };
-  const processRequestInterceptors = (requestConfig) => {
-    let config2 = { ...requestConfig };
-    for (const handler of interceptors.request.handlers) {
-      if (handler.fulfilled) {
-        try {
-          config2 = handler.fulfilled(config2);
-        } catch (error) {
-          if (handler.rejected) {
-            handler.rejected(error);
-          }
-          throw error;
-        }
-      }
-    }
-    return config2;
-  };
-  const processResponseInterceptors = async (response) => {
-    let result = response;
-    for (const handler of interceptors.response.handlers) {
-      if (handler.fulfilled) {
-        try {
-          result = await handler.fulfilled(result);
-        } catch (error) {
-          if (handler.rejected) {
-            result = await handler.rejected(error);
-          } else {
-            throw error;
-          }
-        }
-      }
-    }
-    return result;
-  };
-  const processErrorInterceptors = async (error) => {
-    let result = error;
-    for (const handler of interceptors.response.handlers) {
-      if (handler.rejected) {
-        try {
-          result = await handler.rejected(result);
-        } catch (newError) {
-          result = newError;
-        }
-      }
-    }
-    return Promise.reject(result);
-  };
-  const CancelToken = {
-    source() {
-      let cancel = () => {
-      };
-      const token = {
-        promise: new Promise((resolve) => {
-          cancel = (message = "Request cancelled") => resolve(message);
-        }),
-        reason: void 0
-      };
-      return {
-        token,
-        cancel
-      };
-    }
-  };
-  const isCancel = (value) => {
-    return value && value.__CANCEL__;
-  };
-  const makeRequest = async (method, url, data, customConfig) => {
-    try {
-      const requestConfig = processRequestInterceptors({
-        url: `${config.baseURL}${url}`,
-        method,
-        data,
-        header: { ...defaultHeaders, ...customConfig?.headers },
-        timeout: config.timeout || 3e4,
-        ...customConfig
-      });
-      if (customConfig?.cancelToken) {
-        customConfig.cancelToken.promise.then((reason) => {
-          throw Object.assign(new Error(reason), { __CANCEL__: true });
-        });
-      }
-      const response = await request(requestConfig);
-      const transformedResponse = {
-        data: response.data,
-        status: response.statusCode,
-        statusText: response.errMsg,
-        headers: response.header,
-        config: requestConfig
-      };
-      return await processResponseInterceptors(transformedResponse);
-    } catch (error) {
-      return processErrorInterceptors(error);
-    }
-  };
-  const client = {
-    get: (url, customConfig) => makeRequest("GET", url, null, customConfig),
-    post: (url, data, customConfig) => makeRequest("POST", url, data, customConfig),
-    delete: (url, customConfig) => makeRequest("DELETE", url, null, customConfig),
-    put: (url, data, customConfig) => makeRequest("PUT", url, data, customConfig),
-    patch: (url, data, customConfig) => makeRequest("PATCH", url, data, customConfig),
-    head: (url, customConfig) => makeRequest("HEAD", url, null, customConfig),
-    options: (url, customConfig) => makeRequest("OPTIONS", url, null, customConfig),
-    defaults: {
-      headers: defaultHeaders
-    },
-    interceptors: {
-      request: {
-        use: interceptors.request.use.bind(interceptors.request),
-        eject: interceptors.request.eject.bind(interceptors.request)
-      },
-      response: {
-        use: interceptors.response.use.bind(interceptors.response),
-        eject: interceptors.response.eject.bind(interceptors.response)
-      }
-    },
-    CancelToken,
-    isCancel
-  };
-  return client;
-}
-
 // src/client.ts
 var Client = class {
   /**
@@ -283,63 +107,70 @@ var Client = class {
       }
     };
     this.config = {
-      timeout: 3e4,
-      environment: "web",
-      // Default to web environment
+      timeout: 3e5,
       ...config
     };
-    this.environment = this.config.environment || "web";
     this.assistantId = config.assistantId;
-    if (this.environment === "wechat-miniprogram") {
-      this.client = createWechatClient({
-        baseURL: this.config.baseURL,
-        timeout: this.config.timeout,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`,
-          ...this.config.headers
-        }
-      });
-    } else {
-      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
+        );
+      }
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    try {
+      return await response.json();
+    } catch (error) {
+      throw new Error(`Failed to parse response: ${error}`);
     }
-    this.setupInterceptors();
   }
   /**
-   * 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
@@ -347,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
@@ -356,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;
     }
@@ -372,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;
     }
@@ -389,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;
     }
@@ -407,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;
@@ -423,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;
     }
@@ -446,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;
     }
@@ -460,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;
     }
@@ -471,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 {
@@ -484,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,
@@ -494,10 +332,8 @@ var Client = class {
             command: options.command,
             streaming: false,
             background: options.background || false
-          },
-          { headers }
-        );
-        return response.data;
+          })
+        });
       }
     } catch (error) {
       throw error;
@@ -512,30 +348,22 @@ var Client = class {
    * @returns A function that can be called to stop the stream
    */
   streamRun(options, onEvent, onComplete, onError) {
-    if (this.environment === "wechat-miniprogram") {
-      return this.streamRunWechat(options, onEvent, onComplete, onError);
-    } else {
-      return this.streamRunWeb(options, onEvent, onComplete, onError);
-    }
-  }
-  /**
-   * Stream run results using axios for web environment
-   * @private
-   */
-  streamRunWeb(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 source = axios.CancelToken.source();
+    const controller = new AbortController();
+    const { signal } = controller;
     (async () => {
       try {
-        const axiosClient = this.client;
-        const response = await axiosClient.post(
-          "/api/runs",
-          {
+        const response = await fetch(`${this.config.baseURL}/api/runs`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
             assistant_id: this.assistantId,
             thread_id: options.threadId,
             message: options.message,
@@ -543,33 +371,50 @@ var Client = class {
             command: options.command,
             streaming: true,
             background: options.background || false
-          },
-          {
-            headers,
-            cancelToken: source.token,
-            responseType: "text",
-            transformResponse: (data) => {
-              if (!data)
-                return data;
-              const lines = data.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))
-                      );
-                    }
-                  }
+          }),
+          signal
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          const chunk = decoder.decode(value, { stream: true });
+          buffer += chunk;
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.trim().startsWith("data: ")) {
+              try {
+                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))
+                  );
                 }
               }
-              return data;
             }
           }
-        );
+        }
+        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) {
           if (options.enableReturnStateWhenSteamCompleted) {
             try {
@@ -583,7 +428,7 @@ var Client = class {
           }
         }
       } catch (error) {
-        if (axios.isCancel(error)) {
+        if (error instanceof DOMException && error.name === "AbortError") {
           return;
         }
         if (onError) {
@@ -592,74 +437,406 @@ var Client = class {
       }
     })();
     return () => {
-      source.cancel("Request cancelled by user");
+      controller.abort();
     };
   }
+};
+
+// src/wechat-client.ts
+var WeChatClient = class {
   /**
-   * Stream run results using WeChat Mini Program request API
+   * 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
    */
-  streamRunWechat(options, onEvent, onComplete, onError) {
-    const wechatClient = this.client;
-    let isRunning = true;
-    let messageId = null;
-    const poll = async () => {
-      if (!isRunning)
-        return;
-      try {
-        if (!messageId) {
-          const response = await wechatClient.post("/api/runs", {
+  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,
-            // We can't do true streaming in WeChat
             background: options.background || false
-          });
-          if (response.data && response.data.id) {
-            messageId = response.data.id;
-            onEvent({
-              type: "ai",
-              data: {
-                id: messageId,
-                content: response.data.output || ""
-              }
-            });
-            if (response.data.tool_calls && response.data.tool_calls.length > 0) {
-              onEvent({
-                type: "ai",
-                data: {
-                  id: messageId,
-                  tool_calls: response.data.tool_calls
-                }
-              });
+          }
+        });
+      }
+    } 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();
             }
-            if (onComplete) {
-              if (options.enableReturnStateWhenSteamCompleted) {
-                try {
-                  const state = await this.getAgentState(options.threadId);
-                  onComplete(state);
-                } catch (error) {
-                  onComplete();
-                }
-              } else {
-                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))
+                );
               }
             }
           }
         }
-      } catch (error) {
-        if (onError) {
-          onError(error instanceof Error ? error : new Error(String(error)));
-        }
-        isRunning = false;
       }
-    };
-    poll();
+    });
     return () => {
-      isRunning = false;
+      wx.abortRequest({
+        requestId: taskId,
+        success: () => console.log("Stream request aborted"),
+        fail: (err) => console.error("Failed to abort stream request:", err.errMsg)
+      });
     };
   }
 };
@@ -861,6 +1038,7 @@ export {
   AuthenticationError,
   Client,
   NetworkError,
+  WeChatClient,
   createSimpleMessageMerger
 };
 //# sourceMappingURL=index.mjs.map