@axiom-lattice/client-sdk 1.0.22 → 1.0.23

package/README.md

@@ -14,6 +14,7 @@ The Client SDK provides a simple interface for interacting with the Axiom Lattic
 - Register client-side tools
 - Handle tool calls and responses
 - Process streaming message chunks with ChunkMessageMerger
+- Standardized HTTP client using axios for all API calls
 
 ## Installation
 
@@ -32,6 +33,7 @@ const client = new Client({
   apiKey: "your-api-key",
   assistantId: "your-assistant-id",
   transport: "sse",
+  environment: "web", // Optional: "web" (default) or "wechat-miniprogram"
 });
 
 // Create a thread
@@ -121,6 +123,35 @@ const messages = merger.getMessages();
 
 ## Migration Notes
 
+### Runtime Environment Support
+
+As of version 1.0.13, the client SDK now supports different runtime environments through the `environment` configuration option. Currently supported environments are:
+
+- `"web"` (default): Uses axios for all HTTP requests, including streaming responses
+- `"wechat-miniprogram"`: Uses a custom WeChat Mini Program HTTP client implementation for compatibility with WeChat Mini Programs
+
+To specify the environment:
+
+```typescript
+const client = new Client({
+  // ... other options
+  environment: "wechat-miniprogram", // For WeChat Mini Program environments
+});
+```
+
+The WeChat Mini Program environment uses a different approach for streaming responses since true streaming is not supported in that environment. It uses a polling mechanism instead.
+
+### HTTP Client Standardization
+
+As of version 1.0.12, the client SDK now uses axios exclusively for all HTTP requests, including streaming responses. Previously, the SDK used a combination of axios for regular requests and the native fetch API for streaming. This change standardizes the HTTP client implementation across the SDK.
+
+Benefits:
+
+- Consistent error handling
+- Unified request/response interceptors
+- Simplified maintenance and debugging
+- Better compatibility with different JavaScript environments
+
 ### ChunkMessageMerger
 
 The `ChunkMessageMerger` module has been moved from the web project to the client-sdk package. It provides functionality for processing streaming message chunks and merging them into complete messages.

package/dist/index.d.ts

@@ -9,6 +9,10 @@ import { Message, MessageChunk, AssistantMessage } from '@axiom-lattice/protocol
  * Note: Currently only "ws" is used for tool registration
  */
 type Transport = "sse" | "ws";
+/**
+ * Runtime environment for the client
+ */
+type RuntimeEnvironment = "web" | "wechat-miniprogram";
 /**
  * Configuration options for the Client
  */
@@ -29,6 +33,11 @@ interface ClientConfig {
      * Transport method (Server-Sent Events or WebSocket)
      */
     transport: Transport;
+    /**
+     * Runtime environment (web or wechat-miniprogram)
+     * Defaults to "web" if not specified
+     */
+    environment?: RuntimeEnvironment;
     /**
      * Request timeout in milliseconds (optional, defaults to 30000)
      */
@@ -110,6 +119,10 @@ interface ChatStreamOptions extends ChatSendOptions {
      * Whether to run in background (optional)
      */
     background?: boolean;
+    /**
+     * Whether to return agent state when stream completes (optional)
+     */
+    enableReturnStateWhenSteamCompleted?: boolean;
 }
 /**
  * Stream callbacks interface
@@ -120,9 +133,9 @@ interface StreamCallbacks {
      */
     onEvent: (event: MessageChunk) => void;
     /**
-     * Called when the stream completes
+     * Called when the stream completes, with optional agent state
      */
-    onComplete?: () => void;
+    onComplete?: (state?: AgentState) => void;
     /**
      * Called when an error occurs
      */
@@ -220,6 +233,10 @@ interface RunOptions {
      * Whether to run in background (optional)
      */
     background?: boolean;
+    /**
+     * Whether to return agent state when stream completes (optional)
+     */
+    enableReturnStateWhenSteamCompleted?: boolean;
 }
 /**
  * Agent state
@@ -259,6 +276,7 @@ declare class Client {
     private assistantId;
     private tenantId;
     private registeredTools;
+    private environment;
     /**
      * Creates a new Client instance
      * @param config - Configuration options for the client
@@ -330,6 +348,16 @@ declare class Client {
      * @returns A function that can be called to stop the stream
      */
     private streamRun;
+    /**
+     * Stream run results using axios for web environment
+     * @private
+     */
+    private streamRunWeb;
+    /**
+     * Stream run results using WeChat Mini Program request API
+     * @private
+     */
+    private streamRunWechat;
     /**
      * Chat namespace for sending messages and streaming responses
      */
@@ -348,7 +376,7 @@ declare class Client {
          * @param onError - Optional callback function called when an error occurs
          * @returns A function that can be called to stop the stream
          */
-        stream: (options: ChatStreamOptions, onEvent: (event: MessageChunk) => void, onComplete?: () => void, onError?: (error: Error) => void) => (() => void);
+        stream: (options: ChatStreamOptions, onEvent: (event: MessageChunk) => void, onComplete?: (state?: AgentState) => void, onError?: (error: Error) => void) => (() => void);
     };
     /**
      * Tools namespace for registering and unregistering client-side tools
@@ -385,4 +413,4 @@ declare function createSimpleMessageMerger(): {
     reset: () => void;
 };
 
-export { AgentState, ApiError, AuthenticationError, ChatResponse, ChatSendOptions, ChatStreamOptions, Client, ClientConfig, CreateThreadOptions, GetMessagesOptions, ListThreadsOptions, NetworkError, RegisterToolOptions, RetryConfig, RunOptions, StreamCallbacks, Thread, Transport, createSimpleMessageMerger };
+export { AgentState, ApiError, AuthenticationError, ChatResponse, ChatSendOptions, ChatStreamOptions, Client, ClientConfig, CreateThreadOptions, GetMessagesOptions, ListThreadsOptions, NetworkError, RegisterToolOptions, RetryConfig, RunOptions, RuntimeEnvironment, StreamCallbacks, Thread, Transport, createSimpleMessageMerger };

package/dist/index.js

@@ -62,6 +62,181 @@ var AuthenticationError = class extends Error {
 
 // src/client.ts
 var import_axios = __toESM(require("axios"));
+
+// src/wechat-client.ts
+var import_miniprogram_api_promise = require("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 = (0, import_miniprogram_api_promise.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
@@ -114,7 +289,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,
@@ -148,18 +324,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 = import_axios.default.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 = import_axios.default.create({
+        baseURL: this.config.baseURL,
+        timeout: this.config.timeout,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`,
+          ...this.config.headers
+        }
+      });
+    }
     this.setupInterceptors();
   }
   /**
@@ -361,24 +552,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 = import_axios.default.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,
@@ -386,54 +583,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 (import_axios.default.isCancel(error)) {
           return;
         }
         if (onError) {
@@ -442,7 +632,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;
     };
   }
 };
@@ -529,7 +786,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) {
@@ -565,7 +821,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;
@@ -608,7 +865,8 @@ function createSimpleMessageMerger() {
               if (toolResponse) {
                 return {
                   ...toolCall,
-                  response: toolResponse.content
+                  response: toolResponse.content,
+                  status: "success"
                 };
               }
               return toolCall;