@axiom-lattice/client-sdk 1.0.22 → 1.0.23

package/dist/index.mjs

@@ -22,6 +22,181 @@ 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 {
   /**
    * Creates a new Client instance
@@ -74,7 +249,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,
@@ -108,18 +284,33 @@ var Client = class {
     };
     this.config = {
       timeout: 3e4,
+      environment: "web",
+      // Default to web environment
       ...config
     };
+    this.environment = this.config.environment || "web";
     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
-      }
-    });
+    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.setupInterceptors();
   }
   /**
@@ -321,24 +512,30 @@ 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"
     };
     if (this.tenantId) {
       headers["x-tenant-id"] = this.tenantId;
     }
-    const controller = new AbortController();
-    const signal = controller.signal;
+    const source = axios.CancelToken.source();
     (async () => {
       try {
-        const response = await fetch(`${this.config.baseURL}/api/runs`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.config.apiKey}`,
-            ...headers
-          },
-          body: JSON.stringify({
+        const axiosClient = this.client;
+        const response = await axiosClient.post(
+          "/api/runs",
+          {
             assistant_id: this.assistantId,
             thread_id: options.threadId,
             message: options.message,
@@ -346,54 +543,47 @@ var Client = class {
             command: options.command,
             streaming: true,
             background: options.background || false
-          }),
-          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 { value, done } = await reader.read();
-          if (done) {
-            if (buffer.trim()) {
-              try {
-                const data = JSON.parse(buffer.trim());
-                onEvent(data);
-              } catch (error) {
-              }
-            }
-            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 data = JSON.parse(line.trim().slice(6));
-                onEvent(data);
-              } catch (error) {
-                if (onError) {
-                  onError(
-                    error instanceof Error ? error : new Error(String(error))
-                  );
+          },
+          {
+            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))
+                      );
+                    }
+                  }
                 }
               }
+              return data;
             }
           }
-        }
+        );
         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 (axios.isCancel(error)) {
           return;
         }
         if (onError) {
@@ -402,7 +592,74 @@ var Client = class {
       }
     })();
     return () => {
-      controller.abort();
+      source.cancel("Request cancelled by user");
+    };
+  }
+  /**
+   * Stream run results using WeChat Mini Program request API
+   * @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", {
+            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
+                }
+              });
+            }
+            if (onComplete) {
+              if (options.enableReturnStateWhenSteamCompleted) {
+                try {
+                  const state = await this.getAgentState(options.threadId);
+                  onComplete(state);
+                } catch (error) {
+                  onComplete();
+                }
+              } else {
+                onComplete();
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (onError) {
+          onError(error instanceof Error ? error : new Error(String(error)));
+        }
+        isRunning = false;
+      }
+    };
+    poll();
+    return () => {
+      isRunning = false;
     };
   }
 };
@@ -489,7 +746,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 +781,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 +825,8 @@ function createSimpleMessageMerger() {
               if (toolResponse) {
                 return {
                   ...toolCall,
-                  response: toolResponse.content
+                  response: toolResponse.content,
+                  status: "success"
                 };
               }
               return toolCall;