@doist/comms-sdk 0.7.0 → 0.8.0

package/dist/cjs/clients/add-comment-helper.js

@@ -3,38 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addCommentRequest = addCommentRequest;
 const endpoints_1 = require("../consts/endpoints");
 const http_client_1 = require("../transport/http-client");
-const enums_1 = require("../types/enums");
 const uuidv7_1 = require("../utils/uuidv7");
-const SENTINEL_GROUP_IDS = new Set(Object.values(enums_1.NOTIFY_AUDIENCE_GROUP_IDS));
-function isNotifyAudience(value) {
-    return typeof value === 'string' && enums_1.NOTIFY_AUDIENCES.includes(value);
-}
-function collectMarkerOffenses(field, values) {
-    if (!values)
-        return null;
-    const offending = values.filter((id) => SENTINEL_GROUP_IDS.has(id));
-    return offending.length > 0 ? { field, offending } : null;
-}
-function applyNotifyAudience(params) {
-    const offenses = [
-        collectMarkerOffenses('groups', params.groups ?? undefined),
-        collectMarkerOffenses('directGroupMentions', params.directGroupMentions ?? undefined),
-    ].filter((o) => o !== null);
-    if (offenses.length > 0) {
-        const details = offenses
-            .map(({ field, offending }) => `\`${field}\` contains ${offending.join(', ')}`)
-            .join('; ');
-        throw new Error(`Reserved broadcast marker IDs found: ${details}. Pass these via \`notifyAudience\` on createComment / closeThread / reopenThread (e.g. \`notifyAudience: 'channel'\` for EVERYONE) instead of populating \`groups\` / \`directGroupMentions\` directly.`);
-    }
-    if (params.notifyAudience == null)
-        return params;
-    if (!isNotifyAudience(params.notifyAudience)) {
-        throw new Error(`Invalid \`notifyAudience\` value "${String(params.notifyAudience)}". Expected one of: ${enums_1.NOTIFY_AUDIENCES.join(', ')}.`);
-    }
-    const sentinel = enums_1.NOTIFY_AUDIENCE_GROUP_IDS[params.notifyAudience];
-    const { notifyAudience: _stripped, groups, ...rest } = params;
-    return { ...rest, groups: [...(groups ?? []), sentinel] };
-}
+const notify_audience_1 = require("./notify-audience");
 /**
  * Internal helper that powers `comments.createComment`,
  * `threads.closeThread`, and `threads.reopenThread`.
@@ -53,7 +23,7 @@ function applyNotifyAudience(params) {
  * @returns The parsed {@link Comment} returned by the API.
  */
 function addCommentRequest(context, params, options) {
-    const normalized = applyNotifyAudience(params);
+    const normalized = (0, notify_audience_1.applyNotifyAudience)(params);
     const withId = { ...normalized, id: (0, uuidv7_1.resolveCreateId)(normalized.id) };
     const payload = options?.threadAction
         ? { ...withId, threadAction: options.threadAction }

package/dist/cjs/clients/notify-audience.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyNotifyAudience = applyNotifyAudience;
+const enums_1 = require("../types/enums");
+const SENTINEL_GROUP_IDS = new Set(Object.values(enums_1.NOTIFY_AUDIENCE_GROUP_IDS));
+function isNotifyAudience(value) {
+    return typeof value === 'string' && enums_1.NOTIFY_AUDIENCES.includes(value);
+}
+function collectMarkerOffenses(field, values) {
+    if (!values)
+        return null;
+    const offending = values.filter((id) => SENTINEL_GROUP_IDS.has(id));
+    return offending.length > 0 ? { field, offending } : null;
+}
+/**
+ * Normalizes a `notifyAudience` flag into a sentinel `groups` entry
+ * (`EVERYONE` / `EVERYONE_IN_THREAD`) and rejects callers who put those
+ * reserved markers directly into `groups` / `directGroupMentions`.
+ *
+ * When `notifyAudience` is set it is stripped and its sentinel is appended to
+ * `groups`; the backend only understands the marker in `groups`. When it is
+ * unset the params are returned unchanged, preserving any explicit
+ * `groups` / `directGroupMentions` (including a `null`) on the wire.
+ */
+function applyNotifyAudience(params) {
+    const offenses = [
+        collectMarkerOffenses('groups', params.groups ?? undefined),
+        collectMarkerOffenses('directGroupMentions', params.directGroupMentions ?? undefined),
+    ].filter((o) => o !== null);
+    if (offenses.length > 0) {
+        const details = offenses
+            .map(({ field, offending }) => `\`${field}\` contains ${offending.join(', ')}`)
+            .join('; ');
+        throw new Error(`Reserved broadcast marker IDs found: ${details}. Pass these via \`notifyAudience\` (e.g. \`notifyAudience: 'channel'\` for EVERYONE) instead of populating \`groups\` / \`directGroupMentions\` directly.`);
+    }
+    if (params.notifyAudience == null) {
+        return params;
+    }
+    if (!isNotifyAudience(params.notifyAudience)) {
+        throw new Error(`Invalid \`notifyAudience\` value "${String(params.notifyAudience)}". Expected one of: ${enums_1.NOTIFY_AUDIENCES.join(', ')}.`);
+    }
+    const sentinel = enums_1.NOTIFY_AUDIENCE_GROUP_IDS[params.notifyAudience];
+    const { notifyAudience: _stripped, groups, ...rest } = params;
+    return { ...rest, groups: [...(groups ?? []), sentinel] };
+}

package/dist/cjs/clients/threads-client.js

@@ -8,6 +8,7 @@ const entities_1 = require("../types/entities");
 const uuidv7_1 = require("../utils/uuidv7");
 const add_comment_helper_1 = require("./add-comment-helper");
 const base_client_1 = require("./base-client");
+const notify_audience_1 = require("./notify-audience");
 exports.ThreadListSchema = zod_1.z.array(entities_1.ThreadSchema);
 const GetUnreadResponseSchema = zod_1.z.object({
     data: zod_1.z.array(entities_1.UnreadThreadSchema),
@@ -95,6 +96,11 @@ class ThreadsClient extends base_client_1.BaseClient {
      * @param args.content - The thread content.
      * @param args.recipients - Optional array of user IDs to notify.
      * @param args.groups - Optional array of custom group IDs to notify.
+     * @param args.notifyAudience - Optional broader audience to notify in addition to
+     *   `recipients` and `groups`. `'channel'` notifies everyone in the channel;
+     *   `'thread'` notifies everyone who has interacted with the thread — but a
+     *   brand-new thread has no interactions yet, so the backend discards
+     *   `'thread'` at create time. It is only meaningful on replies (`createComment`).
      * @param args.attachments - Optional array of {@link Attachment}s (from `attachments.upload`).
      * @returns The created thread object.
      *
@@ -104,11 +110,13 @@ class ThreadsClient extends base_client_1.BaseClient {
      *   channelId: '7YpL3oZ4kZ9vP7Q1tR2sX44',
      *   title: 'New Feature Discussion',
      *   content: 'Let\'s discuss the new feature...',
+     *   notifyAudience: 'channel', // tag "Everyone in channel"
      * })
      * ```
      */
     createThread(args) {
-        return this.simple('POST', 'add', { ...args, id: (0, uuidv7_1.resolveCreateId)(args.id) }, this.threadSchema);
+        const normalized = (0, notify_audience_1.applyNotifyAudience)(args);
+        return this.simple('POST', 'add', { ...normalized, id: (0, uuidv7_1.resolveCreateId)(args.id) }, this.threadSchema);
     }
     /**
      * Partial update of an existing thread.

package/dist/cjs/testUtils/msw-setup.js

@@ -3,6 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.server = void 0;
 const node_1 = require("msw/node");
 const vitest_1 = require("vitest");
+// In production the transport uses undici's own `fetch` (paired with the
+// dispatcher) so the request client and dispatcher stay on one undici version.
+// MSW intercepts the *global* `fetch`, not that separate undici instance, so
+// force the transport onto the global `fetch` for every test in the suite;
+// MSW then intercepts requests as usual. The real undici transport is covered
+// directly by `http-dispatcher.test.ts` and `fetch-with-retry.test.ts`, which
+// opt out of this seam.
+vitest_1.vi.mock('../transport/http-dispatcher', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getDefaultTransport: vitest_1.vi.fn(async () => undefined),
+    };
+});
 // Create MSW server instance
 exports.server = (0, node_1.setupServer)();
 // Start server before all tests

package/dist/cjs/transport/fetch-with-retry.js

@@ -62,15 +62,25 @@ async function fetchWithRetry(url, options, maxRetries = 3, customFetch) {
     throw new errors_1.CommsRequestError(lastError?.message ?? 'Request failed');
 }
 async function fetchWithDefaultTransport(url, options, signal) {
-    const dispatcher = await (0, http_dispatcher_1.getDefaultDispatcher)();
-    const response = dispatcher
-        ? await fetch(url, {
+    // Read the dispatcher and its paired `fetch` as one value so they can never
+    // be mismatched. On Node, `fetch` is undici's own — paired with the
+    // dispatcher — so the request client and dispatcher stay on one undici
+    // version; otherwise the `decompress` interceptor terminates gzip responses
+    // when the global `fetch`'s bundled undici differs. Browser/edge (and Bun)
+    // have no paired `fetch` and fall back to the global one.
+    const transport = await (0, http_dispatcher_1.getDefaultTransport)();
+    // undici's `fetch` and the global `fetch` are the same function at runtime
+    // but carry different (undici vs DOM) `RequestInit`/`Response` types. Call
+    // through the global signature, which matches the global-typed `options`.
+    const fetchImpl = (transport?.fetch ?? fetch);
+    const response = transport?.dispatcher
+        ? await fetchImpl(url, {
             ...options,
             signal,
             // @ts-expect-error - dispatcher is valid for Node.js fetch but not in TS types
-            dispatcher,
+            dispatcher: transport.dispatcher,
         })
-        : await fetch(url, {
+        : await fetchImpl(url, {
             ...options,
             signal,
         });

package/dist/cjs/transport/http-dispatcher.js

@@ -33,29 +33,39 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTransport = getDefaultTransport;
 exports.getDefaultDispatcher = getDefaultDispatcher;
 exports.closeDefaultDispatcher = closeDefaultDispatcher;
 exports.resetDefaultDispatcherForTests = resetDefaultDispatcherForTests;
+exports.getDefaultFetch = getDefaultFetch;
 exports.suppressExperimentalWarningsSync = suppressExperimentalWarningsSync;
-let defaultDispatcher;
-let defaultDispatcherPromise;
-async function getDefaultDispatcher() {
-    if (defaultDispatcher) {
-        return defaultDispatcher;
+let defaultTransport;
+let defaultTransportPromise;
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+async function getDefaultTransport() {
+    if (defaultTransport) {
+        return defaultTransport;
     }
-    if (!defaultDispatcherPromise) {
-        defaultDispatcherPromise = createDefaultDispatcher()
-            .then((dispatcher) => {
-            defaultDispatcher = dispatcher;
-            return dispatcher;
+    if (!defaultTransportPromise) {
+        defaultTransportPromise = createDefaultTransport()
+            .then((transport) => {
+            defaultTransport = transport;
+            return transport;
         })
             .catch((error) => {
-            defaultDispatcher = undefined;
-            defaultDispatcherPromise = undefined;
+            defaultTransport = undefined;
+            defaultTransportPromise = undefined;
             throw error;
         });
     }
-    return defaultDispatcherPromise;
+    return defaultTransportPromise;
+}
+async function getDefaultDispatcher() {
+    return (await getDefaultTransport())?.dispatcher;
 }
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -64,17 +74,17 @@ async function getDefaultDispatcher() {
  */
 async function closeDefaultDispatcher() {
     // Clear the singleton *before* awaiting init, so any concurrent
-    // `getDefaultDispatcher()` after this point creates a fresh dispatcher
+    // `getDefaultTransport()` after this point creates a fresh dispatcher
     // instead of receiving a reference to the one we're about to close.
-    const initPromise = defaultDispatcherPromise;
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    const initPromise = defaultTransportPromise;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
     if (!initPromise)
         return;
     try {
-        const dispatcher = await initPromise;
-        if (dispatcher) {
-            await dispatcher.close();
+        const transport = await initPromise;
+        if (transport) {
+            await transport.dispatcher.close();
         }
     }
     catch {
@@ -82,20 +92,39 @@ async function closeDefaultDispatcher() {
     }
 }
 function resetDefaultDispatcherForTests() {
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
+}
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+function getDefaultFetch() {
+    return defaultTransport?.fetch;
 }
 function isNodeEnvironment() {
     return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
 }
-async function createDefaultDispatcher() {
+async function createDefaultTransport() {
     if (!isNodeEnvironment()) {
         return undefined;
     }
     // Dynamic import so non-Node consumers (browser, edge runtimes) don't pull
     // undici into their bundle. `isNodeEnvironment()` above already gated this
     // branch, so undici is safe to load when we get here.
-    const { EnvHttpProxyAgent, interceptors } = await Promise.resolve().then(() => __importStar(require('undici')));
+    const { EnvHttpProxyAgent, interceptors, fetch: undiciFetch } = await Promise.resolve().then(() => __importStar(require('undici')));
     // `EnvHttpProxyAgent` (with `allowH2`) and `interceptors.decompress()` both
     // emit an ExperimentalWarning on first use, so build the whole dispatcher
     // inside the suppression block.
@@ -112,14 +141,21 @@ async function createDefaultDispatcher() {
         // crashing on the missing API. Optional chaining also guards a runtime
         // that omits the `interceptors` export entirely.
         if (typeof interceptors?.decompress !== 'function') {
-            return agent;
+            // Bun: pair the agent with the global `fetch` (undefined), which
+            // decompresses natively.
+            return { dispatcher: agent, fetch: undefined };
         }
         // `interceptors.decompress()` decodes gzip/deflate/br/zstd bodies. On
         // Node 24+, attaching any custom dispatcher to global `fetch` strips
         // `content-encoding` without actually decompressing the body.
         // See https://github.com/Doist/todoist-cli/issues/318.
         const decompress = interceptors.decompress();
-        return agent.compose(decompress);
+        // Pair undici's own `fetch` with this dispatcher so the request client
+        // and the dispatcher stay on one undici version (see `getDefaultFetch`).
+        // The global `fetch` is backed by a different, Node-bundled undici;
+        // mixing the two makes the decompress interceptor terminate gzip
+        // responses on some Node versions.
+        return { dispatcher: agent.compose(decompress), fetch: undiciFetch };
     });
 }
 // `suppressExperimentalWarningsSync` is exported for direct unit testing —

package/dist/cjs/types/requests.js

@@ -42,6 +42,7 @@ exports.CreateThreadArgsSchema = zod_1.z.object({
     id: zod_1.z.string().optional(),
     recipients: zod_1.z.array(zod_1.z.number()).nullable().optional(),
     groups: zod_1.z.array(zod_1.z.string()).nullable().optional(),
+    notifyAudience: zod_1.z.enum(enums_1.NOTIFY_AUDIENCES).nullable().optional(),
     attachments: zod_1.z.array(entities_1.RequestAttachmentSchema).nullable().optional(),
 });
 exports.UpdateThreadArgsSchema = zod_1.z.object({

package/dist/esm/clients/add-comment-helper.js

@@ -1,37 +1,7 @@
 import { ENDPOINT_COMMENTS } from '../consts/endpoints.js';
 import { request } from '../transport/http-client.js';
-import { NOTIFY_AUDIENCE_GROUP_IDS, NOTIFY_AUDIENCES } from '../types/enums.js';
 import { resolveCreateId } from '../utils/uuidv7.js';
-const SENTINEL_GROUP_IDS = new Set(Object.values(NOTIFY_AUDIENCE_GROUP_IDS));
-function isNotifyAudience(value) {
-    return typeof value === 'string' && NOTIFY_AUDIENCES.includes(value);
-}
-function collectMarkerOffenses(field, values) {
-    if (!values)
-        return null;
-    const offending = values.filter((id) => SENTINEL_GROUP_IDS.has(id));
-    return offending.length > 0 ? { field, offending } : null;
-}
-function applyNotifyAudience(params) {
-    const offenses = [
-        collectMarkerOffenses('groups', params.groups ?? undefined),
-        collectMarkerOffenses('directGroupMentions', params.directGroupMentions ?? undefined),
-    ].filter((o) => o !== null);
-    if (offenses.length > 0) {
-        const details = offenses
-            .map(({ field, offending }) => `\`${field}\` contains ${offending.join(', ')}`)
-            .join('; ');
-        throw new Error(`Reserved broadcast marker IDs found: ${details}. Pass these via \`notifyAudience\` on createComment / closeThread / reopenThread (e.g. \`notifyAudience: 'channel'\` for EVERYONE) instead of populating \`groups\` / \`directGroupMentions\` directly.`);
-    }
-    if (params.notifyAudience == null)
-        return params;
-    if (!isNotifyAudience(params.notifyAudience)) {
-        throw new Error(`Invalid \`notifyAudience\` value "${String(params.notifyAudience)}". Expected one of: ${NOTIFY_AUDIENCES.join(', ')}.`);
-    }
-    const sentinel = NOTIFY_AUDIENCE_GROUP_IDS[params.notifyAudience];
-    const { notifyAudience: _stripped, groups, ...rest } = params;
-    return { ...rest, groups: [...(groups ?? []), sentinel] };
-}
+import { applyNotifyAudience } from './notify-audience.js';
 /**
  * Internal helper that powers `comments.createComment`,
  * `threads.closeThread`, and `threads.reopenThread`.

package/dist/esm/clients/notify-audience.js

@@ -0,0 +1,42 @@
+import { NOTIFY_AUDIENCE_GROUP_IDS, NOTIFY_AUDIENCES } from '../types/enums.js';
+const SENTINEL_GROUP_IDS = new Set(Object.values(NOTIFY_AUDIENCE_GROUP_IDS));
+function isNotifyAudience(value) {
+    return typeof value === 'string' && NOTIFY_AUDIENCES.includes(value);
+}
+function collectMarkerOffenses(field, values) {
+    if (!values)
+        return null;
+    const offending = values.filter((id) => SENTINEL_GROUP_IDS.has(id));
+    return offending.length > 0 ? { field, offending } : null;
+}
+/**
+ * Normalizes a `notifyAudience` flag into a sentinel `groups` entry
+ * (`EVERYONE` / `EVERYONE_IN_THREAD`) and rejects callers who put those
+ * reserved markers directly into `groups` / `directGroupMentions`.
+ *
+ * When `notifyAudience` is set it is stripped and its sentinel is appended to
+ * `groups`; the backend only understands the marker in `groups`. When it is
+ * unset the params are returned unchanged, preserving any explicit
+ * `groups` / `directGroupMentions` (including a `null`) on the wire.
+ */
+export function applyNotifyAudience(params) {
+    const offenses = [
+        collectMarkerOffenses('groups', params.groups ?? undefined),
+        collectMarkerOffenses('directGroupMentions', params.directGroupMentions ?? undefined),
+    ].filter((o) => o !== null);
+    if (offenses.length > 0) {
+        const details = offenses
+            .map(({ field, offending }) => `\`${field}\` contains ${offending.join(', ')}`)
+            .join('; ');
+        throw new Error(`Reserved broadcast marker IDs found: ${details}. Pass these via \`notifyAudience\` (e.g. \`notifyAudience: 'channel'\` for EVERYONE) instead of populating \`groups\` / \`directGroupMentions\` directly.`);
+    }
+    if (params.notifyAudience == null) {
+        return params;
+    }
+    if (!isNotifyAudience(params.notifyAudience)) {
+        throw new Error(`Invalid \`notifyAudience\` value "${String(params.notifyAudience)}". Expected one of: ${NOTIFY_AUDIENCES.join(', ')}.`);
+    }
+    const sentinel = NOTIFY_AUDIENCE_GROUP_IDS[params.notifyAudience];
+    const { notifyAudience: _stripped, groups, ...rest } = params;
+    return { ...rest, groups: [...(groups ?? []), sentinel] };
+}

package/dist/esm/clients/threads-client.js

@@ -5,6 +5,7 @@ import { CommentSchema, createCommentSchema, createThreadSchema, StatusOkSchema,
 import { resolveCreateId } from '../utils/uuidv7.js';
 import { addCommentRequest } from './add-comment-helper.js';
 import { BaseClient } from './base-client.js';
+import { applyNotifyAudience } from './notify-audience.js';
 export const ThreadListSchema = z.array(ThreadSchema);
 const GetUnreadResponseSchema = z.object({
     data: z.array(UnreadThreadSchema),
@@ -92,6 +93,11 @@ export class ThreadsClient extends BaseClient {
      * @param args.content - The thread content.
      * @param args.recipients - Optional array of user IDs to notify.
      * @param args.groups - Optional array of custom group IDs to notify.
+     * @param args.notifyAudience - Optional broader audience to notify in addition to
+     *   `recipients` and `groups`. `'channel'` notifies everyone in the channel;
+     *   `'thread'` notifies everyone who has interacted with the thread — but a
+     *   brand-new thread has no interactions yet, so the backend discards
+     *   `'thread'` at create time. It is only meaningful on replies (`createComment`).
      * @param args.attachments - Optional array of {@link Attachment}s (from `attachments.upload`).
      * @returns The created thread object.
      *
@@ -101,11 +107,13 @@ export class ThreadsClient extends BaseClient {
      *   channelId: '7YpL3oZ4kZ9vP7Q1tR2sX44',
      *   title: 'New Feature Discussion',
      *   content: 'Let\'s discuss the new feature...',
+     *   notifyAudience: 'channel', // tag "Everyone in channel"
      * })
      * ```
      */
     createThread(args) {
-        return this.simple('POST', 'add', { ...args, id: resolveCreateId(args.id) }, this.threadSchema);
+        const normalized = applyNotifyAudience(args);
+        return this.simple('POST', 'add', { ...normalized, id: resolveCreateId(args.id) }, this.threadSchema);
     }
     /**
      * Partial update of an existing thread.

package/dist/esm/testUtils/msw-setup.js

@@ -1,5 +1,19 @@
 import { setupServer } from 'msw/node';
-import { afterAll, afterEach, beforeAll } from 'vitest';
+import { afterAll, afterEach, beforeAll, vi } from 'vitest';
+// In production the transport uses undici's own `fetch` (paired with the
+// dispatcher) so the request client and dispatcher stay on one undici version.
+// MSW intercepts the *global* `fetch`, not that separate undici instance, so
+// force the transport onto the global `fetch` for every test in the suite;
+// MSW then intercepts requests as usual. The real undici transport is covered
+// directly by `http-dispatcher.test.ts` and `fetch-with-retry.test.ts`, which
+// opt out of this seam.
+vi.mock('../transport/http-dispatcher', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getDefaultTransport: vi.fn(async () => undefined),
+    };
+});
 // Create MSW server instance
 export const server = setupServer();
 // Start server before all tests

package/dist/esm/transport/fetch-with-retry.js

@@ -1,7 +1,7 @@
 import { CommsRequestError } from '../types/errors.js';
 import { camelCaseKeys } from '../utils/case-conversion.js';
 import { transformTimestamps } from '../utils/timestamp-conversion.js';
-import { getDefaultDispatcher } from './http-dispatcher.js';
+import { getDefaultTransport } from './http-dispatcher.js';
 export async function fetchWithRetry(url, options, maxRetries = 3, customFetch) {
     let lastError;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -59,15 +59,25 @@ export async function fetchWithRetry(url, options, maxRetries = 3, customFetch)
     throw new CommsRequestError(lastError?.message ?? 'Request failed');
 }
 async function fetchWithDefaultTransport(url, options, signal) {
-    const dispatcher = await getDefaultDispatcher();
-    const response = dispatcher
-        ? await fetch(url, {
+    // Read the dispatcher and its paired `fetch` as one value so they can never
+    // be mismatched. On Node, `fetch` is undici's own — paired with the
+    // dispatcher — so the request client and dispatcher stay on one undici
+    // version; otherwise the `decompress` interceptor terminates gzip responses
+    // when the global `fetch`'s bundled undici differs. Browser/edge (and Bun)
+    // have no paired `fetch` and fall back to the global one.
+    const transport = await getDefaultTransport();
+    // undici's `fetch` and the global `fetch` are the same function at runtime
+    // but carry different (undici vs DOM) `RequestInit`/`Response` types. Call
+    // through the global signature, which matches the global-typed `options`.
+    const fetchImpl = (transport?.fetch ?? fetch);
+    const response = transport?.dispatcher
+        ? await fetchImpl(url, {
             ...options,
             signal,
             // @ts-expect-error - dispatcher is valid for Node.js fetch but not in TS types
-            dispatcher,
+            dispatcher: transport.dispatcher,
         })
-        : await fetch(url, {
+        : await fetchImpl(url, {
             ...options,
             signal,
         });

package/dist/esm/transport/http-dispatcher.js

@@ -1,22 +1,30 @@
-let defaultDispatcher;
-let defaultDispatcherPromise;
-export async function getDefaultDispatcher() {
-    if (defaultDispatcher) {
-        return defaultDispatcher;
+let defaultTransport;
+let defaultTransportPromise;
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+export async function getDefaultTransport() {
+    if (defaultTransport) {
+        return defaultTransport;
     }
-    if (!defaultDispatcherPromise) {
-        defaultDispatcherPromise = createDefaultDispatcher()
-            .then((dispatcher) => {
-            defaultDispatcher = dispatcher;
-            return dispatcher;
+    if (!defaultTransportPromise) {
+        defaultTransportPromise = createDefaultTransport()
+            .then((transport) => {
+            defaultTransport = transport;
+            return transport;
         })
             .catch((error) => {
-            defaultDispatcher = undefined;
-            defaultDispatcherPromise = undefined;
+            defaultTransport = undefined;
+            defaultTransportPromise = undefined;
             throw error;
         });
     }
-    return defaultDispatcherPromise;
+    return defaultTransportPromise;
+}
+export async function getDefaultDispatcher() {
+    return (await getDefaultTransport())?.dispatcher;
 }
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -25,17 +33,17 @@ export async function getDefaultDispatcher() {
  */
 export async function closeDefaultDispatcher() {
     // Clear the singleton *before* awaiting init, so any concurrent
-    // `getDefaultDispatcher()` after this point creates a fresh dispatcher
+    // `getDefaultTransport()` after this point creates a fresh dispatcher
     // instead of receiving a reference to the one we're about to close.
-    const initPromise = defaultDispatcherPromise;
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    const initPromise = defaultTransportPromise;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
     if (!initPromise)
         return;
     try {
-        const dispatcher = await initPromise;
-        if (dispatcher) {
-            await dispatcher.close();
+        const transport = await initPromise;
+        if (transport) {
+            await transport.dispatcher.close();
         }
     }
     catch {
@@ -43,20 +51,39 @@ export async function closeDefaultDispatcher() {
     }
 }
 export function resetDefaultDispatcherForTests() {
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
+}
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+export function getDefaultFetch() {
+    return defaultTransport?.fetch;
 }
 function isNodeEnvironment() {
     return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
 }
-async function createDefaultDispatcher() {
+async function createDefaultTransport() {
     if (!isNodeEnvironment()) {
         return undefined;
     }
     // Dynamic import so non-Node consumers (browser, edge runtimes) don't pull
     // undici into their bundle. `isNodeEnvironment()` above already gated this
     // branch, so undici is safe to load when we get here.
-    const { EnvHttpProxyAgent, interceptors } = await import('undici');
+    const { EnvHttpProxyAgent, interceptors, fetch: undiciFetch } = await import('undici');
     // `EnvHttpProxyAgent` (with `allowH2`) and `interceptors.decompress()` both
     // emit an ExperimentalWarning on first use, so build the whole dispatcher
     // inside the suppression block.
@@ -73,14 +100,21 @@ async function createDefaultDispatcher() {
         // crashing on the missing API. Optional chaining also guards a runtime
         // that omits the `interceptors` export entirely.
         if (typeof interceptors?.decompress !== 'function') {
-            return agent;
+            // Bun: pair the agent with the global `fetch` (undefined), which
+            // decompresses natively.
+            return { dispatcher: agent, fetch: undefined };
         }
         // `interceptors.decompress()` decodes gzip/deflate/br/zstd bodies. On
         // Node 24+, attaching any custom dispatcher to global `fetch` strips
         // `content-encoding` without actually decompressing the body.
         // See https://github.com/Doist/todoist-cli/issues/318.
         const decompress = interceptors.decompress();
-        return agent.compose(decompress);
+        // Pair undici's own `fetch` with this dispatcher so the request client
+        // and the dispatcher stay on one undici version (see `getDefaultFetch`).
+        // The global `fetch` is backed by a different, Node-bundled undici;
+        // mixing the two makes the decompress interceptor terminate gzip
+        // responses on some Node versions.
+        return { dispatcher: agent.compose(decompress), fetch: undiciFetch };
     });
 }
 // `suppressExperimentalWarningsSync` is exported for direct unit testing —

package/dist/esm/types/requests.js

@@ -39,6 +39,7 @@ export const CreateThreadArgsSchema = z.object({
     id: z.string().optional(),
     recipients: z.array(z.number()).nullable().optional(),
     groups: z.array(z.string()).nullable().optional(),
+    notifyAudience: z.enum(NOTIFY_AUDIENCES).nullable().optional(),
     attachments: z.array(RequestAttachmentSchema).nullable().optional(),
 });
 export const UpdateThreadArgsSchema = z.object({

package/dist/types/clients/notify-audience.d.ts

@@ -0,0 +1,22 @@
+import { type NotifyAudience } from '../types/enums.js';
+/**
+ * Params bearing the group-targeting fields that can carry a `notifyAudience`.
+ * Shared by the comment-creating endpoints and thread creation.
+ */
+type NotifyAudienceParams = {
+    groups?: string[] | null;
+    directGroupMentions?: string[] | null;
+    notifyAudience?: NotifyAudience | null;
+};
+/**
+ * Normalizes a `notifyAudience` flag into a sentinel `groups` entry
+ * (`EVERYONE` / `EVERYONE_IN_THREAD`) and rejects callers who put those
+ * reserved markers directly into `groups` / `directGroupMentions`.
+ *
+ * When `notifyAudience` is set it is stripped and its sentinel is appended to
+ * `groups`; the backend only understands the marker in `groups`. When it is
+ * unset the params are returned unchanged, preserving any explicit
+ * `groups` / `directGroupMentions` (including a `null`) on the wire.
+ */
+export declare function applyNotifyAudience<T extends NotifyAudienceParams>(params: T): Omit<T, 'notifyAudience'>;
+export {};

package/dist/types/clients/threads-client.d.ts

@@ -336,6 +336,11 @@ export declare class ThreadsClient extends BaseClient {
      * @param args.content - The thread content.
      * @param args.recipients - Optional array of user IDs to notify.
      * @param args.groups - Optional array of custom group IDs to notify.
+     * @param args.notifyAudience - Optional broader audience to notify in addition to
+     *   `recipients` and `groups`. `'channel'` notifies everyone in the channel;
+     *   `'thread'` notifies everyone who has interacted with the thread — but a
+     *   brand-new thread has no interactions yet, so the backend discards
+     *   `'thread'` at create time. It is only meaningful on replies (`createComment`).
      * @param args.attachments - Optional array of {@link Attachment}s (from `attachments.upload`).
      * @returns The created thread object.
      *
@@ -345,6 +350,7 @@ export declare class ThreadsClient extends BaseClient {
      *   channelId: '7YpL3oZ4kZ9vP7Q1tR2sX44',
      *   title: 'New Feature Discussion',
      *   content: 'Let\'s discuss the new feature...',
+     *   notifyAudience: 'channel', // tag "Everyone in channel"
      * })
      * ```
      */

package/dist/types/transport/http-dispatcher.d.ts

@@ -1,4 +1,22 @@
 import type { Dispatcher } from 'undici';
+type UndiciFetch = typeof import('undici').fetch;
+/**
+ * A dispatcher and the `fetch` that must be used with it. `fetch` is undici's
+ * own `fetch` on the full-undici Node path, or `undefined` (meaning: use the
+ * global `fetch`) on the Bun path. The two are cached together so callers can
+ * never observe a dispatcher paired with a mismatched `fetch` — see
+ * {@link getDefaultFetch} for why the pairing matters.
+ */
+type DefaultTransport = {
+    dispatcher: Dispatcher;
+    fetch: UndiciFetch | undefined;
+};
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+export declare function getDefaultTransport(): Promise<DefaultTransport | undefined>;
 export declare function getDefaultDispatcher(): Promise<Dispatcher | undefined>;
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -7,4 +25,22 @@ export declare function getDefaultDispatcher(): Promise<Dispatcher | undefined>;
  */
 export declare function closeDefaultDispatcher(): Promise<void>;
 export declare function resetDefaultDispatcherForTests(): void;
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+export declare function getDefaultFetch(): UndiciFetch | undefined;
 export declare function suppressExperimentalWarningsSync<T>(fn: () => T): T;
+export {};

package/dist/types/types/requests.d.ts

@@ -40,6 +40,10 @@ export declare const CreateThreadArgsSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     recipients: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
     groups: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    notifyAudience: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        channel: "channel";
+        thread: "thread";
+    }>>>;
     attachments: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         attachmentId: z.ZodString;
         urlType: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/comms-sdk",
-    "version": "0.7.0",
+    "version": "0.8.0",
     "description": "A TypeScript wrapper for the Comms REST API.",
     "author": "Doist developers",
     "homepage": "https://doist.github.io/comms-sdk-typescript/",