@openclaw/slack 2026.7.2-beta.4 → 2026.7.2-beta.7

package/node_modules/@slack/web-api/dist/WebClient.js

@@ -32,37 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -73,10 +42,6 @@ const node_path_1 = require("node:path");
 const node_querystring_1 = require("node:querystring");
 const node_util_1 = require("node:util");
 const node_zlib_1 = __importDefault(require("node:zlib"));
-const axios_1 = __importDefault(require("axios"));
-const form_data_1 = __importDefault(require("form-data"));
-const is_electron_1 = __importDefault(require("is-electron"));
-const is_stream_1 = __importDefault(require("is-stream"));
 const p_queue_1 = __importDefault(require("p-queue"));
 const p_retry_1 = __importStar(require("p-retry"));
 const chat_stream_1 = require("./chat-stream");
@@ -90,20 +55,6 @@ const retry_policies_1 = require("./retry-policies");
 /*
  * Helpers
  */
-// Props on axios default headers object to ignore when retrieving full list of actual headers sent in any HTTP requests
-const axiosHeaderPropsToIgnore = [
-    'delete',
-    'common',
-    'get',
-    'put',
-    'head',
-    'post',
-    'link',
-    'patch',
-    'purge',
-    'unlink',
-    'options',
-];
 const defaultFilename = 'Untitled';
 const defaultPageSize = 200;
 const noopPageReducer = () => undefined;
@@ -119,13 +70,57 @@ var WebClientEvent;
  * a convenience wrapper for calling the {@link WebClient#apiCall} method using the method name as the first parameter.
  */
 class WebClient extends methods_1.Methods {
+    /**
+     * The base URL for reaching Slack's Web API. Consider changing this value for testing purposes.
+     */
+    slackApiUrl;
+    /**
+     * Authentication and authorization token for accessing Slack Web API (usually begins with `xoxp` or `xoxb`)
+     */
+    token;
+    /**
+     * Configuration for retry operations. See {@link https://github.com/tim-kos/node-retry|node-retry} for more details.
+     */
+    retryConfig;
+    /**
+     * Queue of requests in which a maximum of {@link WebClientOptions.maxRequestConcurrency} can concurrently be
+     * in-flight.
+     */
+    requestQueue;
+    /**
+     * The fetch function used for HTTP requests
+     */
+    fetchFn;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout;
+    /**
+     * Default headers sent with every request
+     */
+    defaultHeaders;
+    /**
+     * Preference for immediately rejecting API calls which result in a rate-limited response
+     */
+    rejectRateLimitedCalls;
+    /**
+     * The name used to prefix all logging generated from this object
+     */
+    static loggerName = 'WebClient';
+    /**
+     * This object's logger instance
+     */
+    logger;
+    /**
+     * This object's teamId value
+     */
+    teamId;
+    allowAbsoluteUrls;
     /**
      * @param token - An API token to authenticate/authorize with Slack (usually start with `xoxp`, `xoxb`)
      * @param {Object} [webClientOptions] - Configuration options.
-     * @param {Function} [webClientOptions.requestInterceptor] - An interceptor to mutate outgoing requests. See {@link https://axios-http.com/docs/interceptors Axios interceptors}
-     * @param {Function} [webClientOptions.adapter] - An adapter to allow custom handling of requests. Useful if you would like to use a pre-configured http client. See {@link https://github.com/axios/axios/blob/v1.x/README.md?plain=1#L586 Axios adapter}
      */
-    constructor(token, { slackApiUrl = 'https://slack.com/api/', logger = undefined, logLevel = undefined, maxRequestConcurrency = 100, retryConfig = retry_policies_1.tenRetriesInAboutThirtyMinutes, agent = undefined, tls = undefined, timeout = 0, rejectRateLimitedCalls = false, headers = {}, teamId = undefined, allowAbsoluteUrls = true, attachOriginalToWebAPIRequestError = true, requestInterceptor = undefined, adapter = undefined, } = {}) {
+    constructor(token, { slackApiUrl = 'https://slack.com/api/', logger = undefined, logLevel = undefined, maxRequestConcurrency = 100, retryConfig = retry_policies_1.tenRetriesInAboutThirtyMinutes, fetch = undefined, timeout = 0, rejectRateLimitedCalls = false, headers = {}, teamId = undefined, allowAbsoluteUrls = true, } = {}) {
         super();
         this.token = token;
         this.slackApiUrl = slackApiUrl;
@@ -134,12 +129,9 @@ class WebClient extends methods_1.Methods {
         }
         this.retryConfig = retryConfig;
         this.requestQueue = new p_queue_1.default({ concurrency: maxRequestConcurrency });
-        // NOTE: may want to filter the keys to only those acceptable for TLS options
-        this.tlsConfig = tls !== undefined ? tls : {};
         this.rejectRateLimitedCalls = rejectRateLimitedCalls;
         this.teamId = teamId;
         this.allowAbsoluteUrls = allowAbsoluteUrls;
-        this.attachOriginalToWebAPIRequestError = attachOriginalToWebAPIRequestError;
         // Logging
         if (typeof logger !== 'undefined') {
             this.logger = logger;
@@ -148,39 +140,19 @@ class WebClient extends methods_1.Methods {
             }
         }
         else {
-            this.logger = (0, logger_1.getLogger)(WebClient.loggerName, logLevel !== null && logLevel !== void 0 ? logLevel : logger_1.LogLevel.INFO, logger);
+            this.logger = (0, logger_1.getLogger)(WebClient.loggerName, logLevel ?? logger_1.LogLevel.INFO, logger);
         }
         if (this.token && !headers.Authorization)
             headers.Authorization = `Bearer ${this.token}`;
-        this.axios = axios_1.default.create({
-            adapter: adapter ? (config) => adapter(Object.assign(Object.assign({}, config), { adapter: undefined })) : undefined,
-            timeout,
-            baseURL: this.slackApiUrl,
-            headers: (0, is_electron_1.default)() ? headers : Object.assign({ 'User-Agent': (0, instrument_1.getUserAgent)() }, headers),
-            httpAgent: agent,
-            httpsAgent: agent,
-            validateStatus: () => true, // all HTTP status codes should result in a resolved promise (as opposed to only 2xx)
-            maxRedirects: 0,
-            // disabling axios' automatic proxy support:
-            // axios would read from envvars to configure a proxy automatically, but it doesn't support TLS destinations.
-            // for compatibility with https://api.slack.com, and for a larger set of possible proxies (SOCKS or other
-            // protocols), users of this package should use the `agent` option to configure a proxy.
-            proxy: false,
-        });
-        // serializeApiCallData will always determine the appropriate content-type
-        this.axios.defaults.headers.post['Content-Type'] = undefined;
-        // request interceptors have reversed execution order
-        // see: https://github.com/axios/axios/blob/v1.x/test/specs/interceptors.spec.js#L88
-        if (requestInterceptor) {
-            this.axios.interceptors.request.use(requestInterceptor, null);
-        }
-        this.axios.interceptors.request.use(this.serializeApiCallData.bind(this), null);
+        this.fetchFn = fetch ?? globalThis.fetch;
+        this.timeout = timeout;
+        this.defaultHeaders = { 'User-Agent': (0, instrument_1.getUserAgent)(), Accept: 'application/json', ...headers };
         this.logger.debug('initialized');
     }
     /**
      * Generic method for calling a Web API method
      * @param method - the Web API method to call {@link https://docs.slack.dev/reference/methods}
-     * @param options - options
+     * @param options - arguments for the Web API method
      */
     async apiCall(method, options = {}) {
         this.logger.debug(`apiCall('${method}') start`);
@@ -190,7 +162,6 @@ class WebClient extends methods_1.Methods {
         if (typeof options === 'string' || typeof options === 'number' || typeof options === 'boolean') {
             throw new TypeError(`Expected an options argument but instead received a ${typeof options}`);
         }
-        (0, file_upload_1.warnIfNotUsingFilesUploadV2)(method, this.logger);
         // @ts-expect-error insufficient overlap between Record and FilesUploadV2Arguments
         if (method === 'files.uploadV2')
             return this.filesUploadV2(options);
@@ -198,9 +169,12 @@ class WebClient extends methods_1.Methods {
         if (options.token)
             headers.Authorization = `Bearer ${options.token}`;
         const url = this.deriveRequestUrl(method);
-        const response = await this.makeRequest(url, Object.assign({ team_id: this.teamId }, options), headers);
+        const response = await this.makeRequest(url, {
+            team_id: this.teamId,
+            ...options,
+        }, headers);
         const result = await this.buildResult(response);
-        this.logger.debug(`http request result: ${JSON.stringify(result)}`);
+        this.logger.debug(`http request result: ${JSON.stringify(redact(result))}`);
         // log warnings in response metadata
         if (result.response_metadata !== undefined && result.response_metadata.warnings !== undefined) {
             result.response_metadata.warnings.forEach(this.logger.warn.bind(this.logger));
@@ -228,11 +202,11 @@ class WebClient extends methods_1.Methods {
         // If result's content is gzip, "ok" property is not returned with successful response
         // TODO: look into simplifying this code block to only check for the second condition
         // if an { ok: false } body applies for all API errors
-        if (!result.ok && response.headers['content-type'] !== 'application/gzip') {
-            throw (0, errors_1.platformErrorFromResult)(result);
+        if (!result.ok && response.headers.get('content-type') !== 'application/gzip') {
+            throw new errors_1.WebAPIPlatformError(result);
         }
         if ('ok' in result && result.ok === false) {
-            throw (0, errors_1.platformErrorFromResult)(result);
+            throw new errors_1.WebAPIPlatformError(result);
         }
         this.logger.debug(`apiCall('${method}') end`);
         return result;
@@ -246,24 +220,22 @@ class WebClient extends methods_1.Methods {
             }
             return defaultPageSize;
         })();
-        function generatePages() {
-            return __asyncGenerator(this, arguments, function* generatePages_1() {
-                // when result is undefined, that signals that the first of potentially many calls has not yet been made
-                let result;
-                // paginationOptions stores pagination options not already stored in the options argument
-                let paginationOptions = {
-                    limit: pageSize,
-                };
-                if (options !== undefined && options.cursor !== undefined) {
-                    paginationOptions.cursor = options.cursor;
-                }
-                // NOTE: test for the situation where you're resuming a pagination using and existing cursor
-                while (result === undefined || paginationOptions !== undefined) {
-                    result = yield __await(this.apiCall(method, Object.assign(options !== undefined ? options : {}, paginationOptions)));
-                    yield yield __await(result);
-                    paginationOptions = paginationOptionsForNextPage(result, pageSize);
-                }
-            });
+        async function* generatePages() {
+            // when result is undefined, that signals that the first of potentially many calls has not yet been made
+            let result;
+            // paginationOptions stores pagination options not already stored in the options argument
+            let paginationOptions = {
+                limit: pageSize,
+            };
+            if (options !== undefined && options.cursor !== undefined) {
+                paginationOptions.cursor = options.cursor;
+            }
+            // NOTE: test for the situation where you're resuming a pagination using and existing cursor
+            while (result === undefined || paginationOptions !== undefined) {
+                result = await this.apiCall(method, Object.assign(options !== undefined ? options : {}, paginationOptions));
+                yield result;
+                paginationOptions = paginationOptionsForNextPage(result, pageSize);
+            }
         }
         if (shouldStop === undefined) {
             return generatePages.call(this);
@@ -275,7 +247,6 @@ class WebClient extends methods_1.Methods {
             // This is done primarily because in order to satisfy the type system, we need a variable that is typed as A
             // (shown as accumulator before), but before the first iteration all we have is a variable typed A | undefined.
             // Unrolling the first iteration allows us to deal with undefined as a special case.
-            var _a, e_1, _b, _c;
             const pageIterator = generatePages.call(this);
             const firstIteratorResult = await pageIterator.next(undefined);
             // Assumption: there will always be at least one result in a paginated API request
@@ -286,25 +257,13 @@ class WebClient extends methods_1.Methods {
             if (shouldStop(firstPage)) {
                 return accumulator;
             }
-            try {
-                // Continue iteration
-                for (var _d = true, pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = await pageIterator_1.next(), _a = pageIterator_1_1.done, !_a; _d = true) {
-                    _c = pageIterator_1_1.value;
-                    _d = false;
-                    const page = _c;
-                    accumulator = pageReducer(accumulator, page, index);
-                    if (shouldStop(page)) {
-                        return accumulator;
-                    }
-                    index += 1;
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = pageIterator_1.return)) await _b.call(pageIterator_1);
+            // Continue iteration
+            for await (const page of pageIterator) {
+                accumulator = pageReducer(accumulator, page, index);
+                if (shouldStop(page)) {
+                    return accumulator;
                 }
-                finally { if (e_1) throw e_1.error; }
+                index += 1;
             }
             return accumulator;
         })();
@@ -336,7 +295,7 @@ class WebClient extends methods_1.Methods {
      * @see {@link https://docs.slack.dev/reference/methods/chat.stopStream}
      */
     chatStream(params) {
-        const { buffer_size } = params, args = __rest(params, ["buffer_size"]);
+        const { buffer_size, ...args } = params;
         const options = {
             buffer_size,
         };
@@ -421,7 +380,8 @@ class WebClient extends methods_1.Methods {
                 if (uploadRes.status !== 200) {
                     return Promise.reject(Error(`Failed to upload file (id:${file_id}, filename: ${filename})`));
                 }
-                const returnData = { ok: true, body: uploadRes.data };
+                const responseBody = await uploadRes.text();
+                const returnData = { ok: true, body: responseBody };
                 return Promise.resolve(returnData);
             }
             return Promise.reject(Error(`No upload url found for file (id: ${file_id}, filename: ${filename}`));
@@ -447,49 +407,42 @@ class WebClient extends methods_1.Methods {
      * Low-level function to make a single API request. handles queuing, retries, and http-level errors
      */
     async makeRequest(url, body, headers = {}) {
-        // TODO: better input types - remove any
         const task = () => this.requestQueue.add(async () => {
+            // apps.event.authorizations.list will reject HTTP requests that send token in the body
+            // TODO: consider applying this change to all methods - though that will require thorough integration testing
+            if (url.endsWith('/apps.event.authorizations.list')) {
+                body.token = undefined;
+            }
+            this.logger.debug(`http request url: ${url}`);
+            this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
+            const { serializedBody, contentHeaders } = this.serializeBody(body);
+            const allHeaders = { ...this.defaultHeaders, ...contentHeaders, ...headers };
+            this.logger.debug(`http request headers: ${JSON.stringify(redact(allHeaders))}`);
+            const signal = this.timeout > 0 ? AbortSignal.timeout(this.timeout) : undefined;
             try {
-                // biome-ignore lint/suspicious/noExplicitAny: TODO: type this
-                const config = Object.assign({ headers }, this.tlsConfig);
-                // admin.analytics.getFile returns a binary response
-                // To be able to parse it, it should be read as an ArrayBuffer
-                if (url.endsWith('admin.analytics.getFile')) {
-                    config.responseType = 'arraybuffer';
-                }
-                // apps.event.authorizations.list will reject HTTP requests that send token in the body
-                // TODO: consider applying this change to all methods - though that will require thorough integration testing
-                if (url.endsWith('apps.event.authorizations.list')) {
-                    body.token = undefined;
-                }
-                this.logger.debug(`http request url: ${url}`);
-                this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
-                // compile all headers - some set by default under the hood by axios - that will be sent along
-                let allHeaders = Object.keys(this.axios.defaults.headers).reduce((acc, cur) => {
-                    if (!axiosHeaderPropsToIgnore.includes(cur)) {
-                        acc[cur] = this.axios.defaults.headers[cur];
-                    }
-                    return acc;
-                }, {});
-                allHeaders = Object.assign(Object.assign(Object.assign({}, this.axios.defaults.headers.common), allHeaders), headers);
-                this.logger.debug(`http request headers: ${JSON.stringify(redact(allHeaders))}`);
-                const response = await this.axios.post(url, body, config);
+                const response = await this.fetchFn(url, {
+                    method: 'POST',
+                    headers: allHeaders,
+                    body: serializedBody,
+                    redirect: 'error',
+                    signal,
+                });
                 this.logger.debug('http response received');
                 if (response.status === 429) {
                     const retrySec = parseRetryHeaders(response);
                     if (retrySec !== undefined) {
                         this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
                         if (this.rejectRateLimitedCalls) {
-                            throw new p_retry_1.AbortError((0, errors_1.rateLimitedErrorWithDelay)(retrySec));
+                            throw new p_retry_1.AbortError(new errors_1.WebAPIRateLimitedError(retrySec));
                         }
                         this.logger.info(`API Call failed due to rate limiting. Will retry in ${retrySec} seconds.`);
                         // pause the request queue and then delay the rejection by the amount of time in the retry header
                         this.requestQueue.pause();
                         // NOTE: if there was a way to introspect the current RetryOperation and know what the next timeout
-                        // would be, then we could subtract that time from the following delay, knowing that it the next
-                        // attempt still wouldn't occur until after the rate-limit header has specified. an even better
+                        // would be, then we could subtract that time from the following delay, knowing that the next
+                        // attempt still wouldn't occur until after the rate-limit header has specified. An even better
                         // solution would be to subtract the time from only the timeout of this next attempt of the
-                        // RetryOperation. this would result in the staying paused for the entire duration specified in the
+                        // RetryOperation. This would result in staying paused for the entire duration specified in the
                         // header, yet this operation not having to pay the timeout cost in addition to that.
                         await (0, helpers_1.default)(retrySec * 1000);
                         // resume the request queue and throw a non-abort error to signal a retry
@@ -498,26 +451,27 @@ class WebClient extends methods_1.Methods {
                         throw new Error(`A rate limit was exceeded (url: ${url}, retry-after: ${retrySec})`);
                     }
                     // TODO: turn this into some CodedError
-                    throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers['retry-after']})`));
+                    throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers.get('retry-after')})`));
                 }
                 // Slack's Web API doesn't use meaningful status codes besides 429 and 200
                 if (response.status !== 200) {
-                    throw (0, errors_1.httpErrorFromResponse)(response);
+                    const responseBody = await response.text();
+                    throw new errors_1.WebAPIHTTPError(response.status, response.statusText, Object.fromEntries(response.headers.entries()), responseBody);
                 }
                 return response;
             }
             catch (error) {
-                // To make this compatible with tsd, casting here instead of `catch (error: any)`
-                // biome-ignore lint/suspicious/noExplicitAny: errors can be anything
-                const e = error;
-                this.logger.warn('http request failed', e.message);
-                if (e.request) {
-                    throw (0, errors_1.requestErrorWithOriginal)(e, this.attachOriginalToWebAPIRequestError);
+                if (error instanceof p_retry_1.AbortError) {
+                    throw error;
+                }
+                if (error instanceof errors_1.SlackError) {
+                    throw error;
                 }
-                throw error;
+                const message = error instanceof Error ? error.message : String(error);
+                this.logger.warn('http request failed', message);
+                throw new errors_1.WebAPIRequestError(error instanceof Error ? error : new Error(String(error)));
             }
         });
-        // biome-ignore lint/suspicious/noExplicitAny: http responses can be anything
         return (0, p_retry_1.default)(task, this.retryConfig);
     }
     /**
@@ -529,19 +483,15 @@ class WebClient extends methods_1.Methods {
         if (isAbsoluteURL && this.allowAbsoluteUrls) {
             return url;
         }
-        return `${this.axios.getUri() + url}`;
+        return `${this.slackApiUrl}${url}`;
     }
     /**
-     * Transforms options (a simple key-value object) into an acceptable value for a body. This can be either
-     * a string, used when posting with a content-type of url-encoded. Or, it can be a readable stream, used
-     * when the options contain a binary (a stream or a buffer) and the upload should be done with content-type
-     * multipart/form-data.
-     * @param config - The Axios request configuration object
+     * Transforms a key-value object into a serialized body suitable for fetch.
+     * Flattens complex objects into JSON-encoded strings, detects binary content,
+     * and returns either a FormData (for binary uploads) or a URL-encoded string,
+     * along with any content-type headers that should be set.
      */
-    serializeApiCallData(config) {
-        const { data, headers } = config;
-        // The following operation both flattens complex objects into a JSON-encoded strings and searches the values for
-        // binary content
+    serializeBody(data) {
         let containsBinaryData = false;
         // biome-ignore lint/suspicious/noExplicitAny: HTTP request data can be anything
         const flattened = Object.entries(data).map(([key, value]) => {
@@ -549,7 +499,7 @@ class WebClient extends methods_1.Methods {
                 return [];
             }
             let serializedValue = value;
-            if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
+            if (Buffer.isBuffer(value)) {
                 containsBinaryData = true;
             }
             else if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
@@ -562,55 +512,41 @@ class WebClient extends methods_1.Methods {
         // A body with binary content should be serialized as multipart/form-data
         if (containsBinaryData) {
             this.logger.debug('Request arguments contain binary data');
-            const form = flattened.reduce((frm, [key, value]) => {
-                if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
-                    const opts = {};
-                    opts.filename = (() => {
-                        // attempt to find filename from `value`. adapted from:
-                        // https://github.com/form-data/form-data/blob/028c21e0f93c5fefa46a7bbf1ba753e4f627ab7a/lib/form_data.js#L227-L230
-                        // formidable and the browser add a name property
-                        // fs- and request- streams have path property
-                        // biome-ignore lint/suspicious/noExplicitAny: form values can be anything
-                        const streamOrBuffer = value;
-                        if (typeof streamOrBuffer.name === 'string') {
-                            return (0, node_path_1.basename)(streamOrBuffer.name);
-                        }
-                        if (typeof streamOrBuffer.path === 'string') {
-                            return (0, node_path_1.basename)(streamOrBuffer.path);
-                        }
-                        return defaultFilename;
-                    })();
-                    frm.append(key, value, opts);
-                }
-                else if (key !== undefined && value !== undefined) {
-                    frm.append(key, value);
+            const form = new FormData();
+            for (const [key, value] of flattened) {
+                if (key === undefined || value === undefined)
+                    continue;
+                if (Buffer.isBuffer(value)) {
+                    const streamOrBuffer = value;
+                    let filename = defaultFilename;
+                    if (typeof streamOrBuffer.name === 'string') {
+                        filename = (0, node_path_1.basename)(streamOrBuffer.name);
+                    }
+                    else if (typeof streamOrBuffer.path === 'string') {
+                        filename = (0, node_path_1.basename)(streamOrBuffer.path);
+                    }
+                    form.append(key, new Blob([new Uint8Array(value)]), filename);
                 }
-                return frm;
-            }, new form_data_1.default());
-            if (headers) {
-                // Copying FormData-generated headers into headers param
-                // not reassigning to headers param since it is passed by reference and behaves as an inout param
-                for (const [header, value] of Object.entries(form.getHeaders())) {
-                    headers[header] = value;
+                else {
+                    form.append(key, String(value));
                 }
             }
-            config.data = form;
-            config.headers = headers;
-            return config;
+            // Do not set Content-Type — fetch auto-generates the multipart boundary
+            return { serializedBody: form, contentHeaders: {} };
         }
-        // Otherwise, a simple key-value object is returned
-        if (headers)
-            headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        // Otherwise, serialize as url-encoded key-value pairs
         // biome-ignore lint/suspicious/noExplicitAny: form values can be anything
         const initialValue = {};
-        config.data = (0, node_querystring_1.stringify)(flattened.reduce((accumulator, [key, value]) => {
+        const encoded = (0, node_querystring_1.stringify)(flattened.reduce((accumulator, [key, value]) => {
             if (key !== undefined && value !== undefined) {
                 accumulator[key] = value;
             }
             return accumulator;
         }, initialValue));
-        config.headers = headers;
-        return config;
+        return {
+            serializedBody: encoded,
+            contentHeaders: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        };
     }
     /**
      * Processes an HTTP response into a WebAPICallResult by performing JSON parsing on the body and merging relevant
@@ -618,23 +554,21 @@ class WebClient extends methods_1.Methods {
      * @param response - an http response
      */
     async buildResult(response) {
-        let { data } = response;
-        const isGzipResponse = response.headers['content-type'] === 'application/gzip';
-        // Check for GZIP response - if so, it is a successful response from admin.analytics.getFile
+        const contentType = response.headers.get('content-type');
+        const isGzipResponse = contentType === 'application/gzip';
+        // biome-ignore lint/suspicious/noExplicitAny: HTTP response data can be anything
+        let data;
+        // admin.analytics.getFile returns a gzip binary response that can be unzipped
         if (isGzipResponse) {
-            // admin.analytics.getFile will return a Buffer that can be unzipped
             try {
+                const buffer = Buffer.from(await response.arrayBuffer());
                 const unzippedData = await new Promise((resolve, reject) => {
-                    node_zlib_1.default.unzip(data, (err, buf) => {
+                    node_zlib_1.default.unzip(buffer, (err, buf) => {
                         if (err) {
                             return reject(err);
                         }
                         return resolve(buf.toString().split('\n'));
                     });
-                })
-                    .then((res) => res)
-                    .catch((err) => {
-                    throw err;
                 });
                 const fileData = [];
                 if (Array.isArray(unzippedData)) {
@@ -650,32 +584,33 @@ class WebClient extends methods_1.Methods {
                 data = { ok: false, error: err };
             }
         }
-        else if (!isGzipResponse && response.request.path === '/api/admin.analytics.getFile') {
+        else if (!isGzipResponse && response.url.endsWith('/admin.analytics.getFile')) {
             // if it isn't a Gzip response but is from the admin.analytics.getFile request,
             // decode the ArrayBuffer to JSON read the error
-            data = JSON.parse(new node_util_1.TextDecoder().decode(data));
+            const buffer = await response.arrayBuffer();
+            data = JSON.parse(new node_util_1.TextDecoder().decode(buffer));
         }
-        if (typeof data === 'string') {
-            // response.data can be a string, not an object for some reason
+        else {
+            const text = await response.text();
             try {
-                data = JSON.parse(data);
+                data = JSON.parse(text);
             }
             catch (_) {
-                // failed to parse the string value as JSON data
-                data = { ok: false, error: data };
+                // failed to parse the response body as JSON
+                data = { ok: false, error: text };
             }
         }
         if (data.response_metadata === undefined) {
             data.response_metadata = {};
         }
         // add scopes metadata from headers
-        if (response.headers['x-oauth-scopes'] !== undefined) {
-            data.response_metadata.scopes = response.headers['x-oauth-scopes'].trim().split(/\s*,\s*/);
+        const oauthScopes = response.headers.get('x-oauth-scopes');
+        if (oauthScopes !== null) {
+            data.response_metadata.scopes = oauthScopes.trim().split(/\s*,\s*/);
         }
-        if (response.headers['x-accepted-oauth-scopes'] !== undefined) {
-            data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes']
-                .trim()
-                .split(/\s*,\s*/);
+        const acceptedOauthScopes = response.headers.get('x-accepted-oauth-scopes');
+        if (acceptedOauthScopes !== null) {
+            data.response_metadata.acceptedScopes = acceptedOauthScopes.trim().split(/\s*,\s*/);
         }
         // add retry metadata from headers
         const retrySec = parseRetryHeaders(response);
@@ -686,10 +621,6 @@ class WebClient extends methods_1.Methods {
     }
 }
 exports.WebClient = WebClient;
-/**
- * The name used to prefix all logging generated from this object
- */
-WebClient.loggerName = 'WebClient';
 exports.default = WebClient;
 /**
  * Determines an appropriate set of cursor pagination options for the next request to a paginated API method.
@@ -713,8 +644,9 @@ function paginationOptionsForNextPage(previousResult, pageSize) {
  * from a rate-limited HTTP response (statusCode = 429).
  */
 function parseRetryHeaders(response) {
-    if (response.headers['retry-after'] !== undefined) {
-        const retryAfter = Number.parseInt(response.headers['retry-after'], 10);
+    const retryAfterHeader = response.headers.get('retry-after');
+    if (retryAfterHeader !== null) {
+        const retryAfter = Number.parseInt(retryAfterHeader, 10);
         if (!Number.isNaN(retryAfter)) {
             return retryAfter;
         }
@@ -727,7 +659,7 @@ function parseRetryHeaders(response) {
  * @param logger instance of web clients logger
  */
 function warnDeprecations(method, logger) {
-    const deprecatedMethods = ['workflows.stepCompleted', 'workflows.stepFailed', 'workflows.updateStep'];
+    const deprecatedMethods = ['oauth.access'];
     const isDeprecated = deprecatedMethods.some((depMethod) => {
         const re = new RegExp(`^${depMethod}`);
         return re.test(method);
@@ -771,9 +703,9 @@ function warnIfFallbackIsMissing(method, logger, options) {
  * @param options arguments for the Web API method
  */
 function warnIfThreadTsIsNotString(method, logger, options) {
-    const targetMethods = ['chat.postEphemeral', 'chat.postMessage', 'chat.scheduleMessage', 'files.upload'];
+    const targetMethods = ['chat.postEphemeral', 'chat.postMessage', 'chat.scheduleMessage'];
     const isTargetMethod = targetMethods.includes(method);
-    if (isTargetMethod && (options === null || options === void 0 ? void 0 : options.thread_ts) !== undefined && typeof (options === null || options === void 0 ? void 0 : options.thread_ts) !== 'string') {
+    if (isTargetMethod && options?.thread_ts !== undefined && typeof options?.thread_ts !== 'string') {
         logger.warn(buildThreadTsWarningMessage(method));
     }
 }
@@ -797,12 +729,12 @@ function redact(body) {
         if (key.match(/.*token.*/) !== null || key.match(/[Aa]uthorization/)) {
             serializedValue = '[[REDACTED]]';
         }
-        // when value is buffer or stream we can avoid logging it
-        if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
+        // when value is buffer we can avoid logging it
+        if (Buffer.isBuffer(value)) {
             serializedValue = '[[BINARY VALUE OMITTED]]';
         }
-        else if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
-            serializedValue = JSON.stringify(value);
+        else if (typeof value === 'object') {
+            serializedValue = redact(value);
         }
         return [key, serializedValue];
     });