doover-js 0.6.8 → 0.6.9

package/dist/auth/doover-auth.d.ts

@@ -41,6 +41,12 @@ export declare abstract class DooverAuth {
      * Called before every HTTP request and before opening a websocket.
      */
     abstract ensureReady(): Promise<void>;
+    /**
+     * Called after an authenticated HTTP request receives a 401. Return true when
+     * the auth layer recovered (for example by forcing a token refresh) and the
+     * request should be retried once.
+     */
+    handleUnauthorized(): Promise<boolean>;
     /** Attach a profile and optional config manager for refresh persistence. */
     attachProfile(profile: AuthProfile, configManager?: AuthProfileStore): void;
 }

package/dist/auth/doover-auth.js

@@ -13,6 +13,14 @@ class DooverAuth {
         this.profile = null;
         this.configManager = null;
     }
+    /**
+     * Called after an authenticated HTTP request receives a 401. Return true when
+     * the auth layer recovered (for example by forcing a token refresh) and the
+     * request should be retried once.
+     */
+    async handleUnauthorized() {
+        return false;
+    }
     /** Attach a profile and optional config manager for refresh persistence. */
     attachProfile(profile, configManager) {
         this.profile = profile;

package/dist/auth/doover-token-auth.d.ts

@@ -10,6 +10,7 @@ export declare class DooverTokenAuth extends DooverAuth {
     private authServerClientId;
     private fetchImpl;
     private refreshInFlight;
+    private authInvalid;
     constructor(options: {
         token?: string | null;
         tokenExpires?: Date | number | null;
@@ -28,9 +29,11 @@ export declare class DooverTokenAuth extends DooverAuth {
     setToken(token: string | null, tokenExpires?: Date | number | null): void;
     setRefreshToken(refreshToken: string | null): void;
     ensureReady(): Promise<void>;
+    handleUnauthorized(): Promise<boolean>;
     attachProfile(profile: AuthProfile, configManager?: AuthProfileStore): void;
     private needsRefresh;
     private refresh;
     private persistToProfile;
+    private markAuthInvalid;
     private resolveExpiry;
 }

package/dist/auth/doover-token-auth.js

@@ -10,6 +10,7 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
     constructor(options) {
         super();
         this.refreshInFlight = null;
+        this.authInvalid = false;
         this.token = options.token ?? null;
         this.tokenExpires = this.resolveExpiry(options.tokenExpires, options.token ?? null);
         this.refreshToken = options.refreshToken ?? null;
@@ -48,13 +49,22 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
     setToken(token, tokenExpires) {
         this.token = token;
         this.tokenExpires = this.resolveExpiry(tokenExpires, token);
+        if (token) {
+            this.authInvalid = false;
+        }
         this.persistToProfile();
     }
     setRefreshToken(refreshToken) {
         this.refreshToken = refreshToken;
+        if (refreshToken) {
+            this.authInvalid = false;
+        }
         this.persistToProfile();
     }
     async ensureReady() {
+        if (this.authInvalid) {
+            throw new errors_1.DooverAuthError("Authentication is invalid; sign in again");
+        }
         if (!this.needsRefresh()) {
             return;
         }
@@ -66,6 +76,23 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
         }
         return this.refreshInFlight;
     }
+    async handleUnauthorized() {
+        if (this.authInvalid) {
+            return false;
+        }
+        if (!this.refreshInFlight) {
+            this.refreshInFlight = this.refresh().finally(() => {
+                this.refreshInFlight = null;
+            });
+        }
+        try {
+            await this.refreshInFlight;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     // ------------------------------------------------------------------
     // Profile attachment override — load refresh metadata from profile
     // ------------------------------------------------------------------
@@ -110,6 +137,7 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
         if (!this.authServerUrl ||
             !this.refreshToken ||
             !this.authServerClientId) {
+            this.markAuthInvalid();
             throw new errors_1.DooverAuthError("Cannot refresh token: missing authServerUrl, refreshToken, or authServerClientId");
         }
         const url = new URL(`${this.authServerUrl}/oauth2/token`);
@@ -129,12 +157,17 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
             throw new errors_1.DooverAuthError(`Token refresh request failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         if (!response.ok) {
+            if (response.status >= 400 && response.status < 500) {
+                this.markAuthInvalid();
+            }
             throw new errors_1.DooverAuthError(`Token refresh failed with status ${response.status}`);
         }
         const body = (await response.json());
         if (!body.access_token) {
+            this.markAuthInvalid();
             throw new errors_1.DooverAuthError("Token refresh response did not contain an access_token");
         }
+        this.authInvalid = false;
         this.token = body.access_token;
         this.tokenExpires =
             typeof body.expires_in === "number"
@@ -154,9 +187,7 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
         this.profile.tokenExpires = this.tokenExpires
             ? this.tokenExpires.toISOString()
             : null;
-        if (this.refreshToken) {
-            this.profile.refreshToken = this.refreshToken;
-        }
+        this.profile.refreshToken = this.refreshToken;
         if (this.configManager) {
             try {
                 this.configManager.create(this.profile);
@@ -167,6 +198,13 @@ class DooverTokenAuth extends doover_auth_1.DooverAuth {
             }
         }
     }
+    markAuthInvalid() {
+        this.authInvalid = true;
+        this.token = null;
+        this.tokenExpires = null;
+        this.refreshToken = null;
+        this.persistToProfile();
+    }
     resolveExpiry(explicit, token) {
         if (explicit instanceof Date) {
             return explicit;

package/dist/client/multiplex-client.js

@@ -554,7 +554,23 @@ class MultiplexClient {
                 }
                 const responses = await Promise.all(members.map((m) => m.client.agents.getMultiAgentMessages(...args)));
                 const merged = (0, multiplex_merge_1.mergeMessages)(responses.map((r) => r.results), { order: "desc" });
-                return { results: merged, count: merged.length };
+                // Union each member's per-agent resume cursors so a paginating caller
+                // keeps walking. If one agent lives in two members with different
+                // cursors, keep the lexically-highest (newest) — resuming from the
+                // older one would skip the newer member's tail; resuming from the
+                // newer just re-fetches a few messages that dedupe by id downstream.
+                const nextCursors = {};
+                for (const r of responses) {
+                    for (const [id, cursor] of Object.entries(r.next_cursors ?? {})) {
+                        if (!(id in nextCursors) || cursor > nextCursors[id])
+                            nextCursors[id] = cursor;
+                    }
+                }
+                return {
+                    results: merged,
+                    count: merged.length,
+                    ...(Object.keys(nextCursors).length > 0 ? { next_cursors: nextCursors } : {}),
+                };
             },
             async getMultiAgentAggregates(channelName, ...rest) {
                 const { args, sources } = self.splitSourcesOption([channelName, ...rest]);

package/dist/gateway/gateway-client.d.ts

@@ -71,6 +71,7 @@ export declare class GatewayClient {
     private send;
     private emit;
     private scheduleReconnect;
+    private connectInBackground;
     /** Exponential backoff with full-jitter, capped at RECONNECT_CAP_MS. */
     private computeReconnectDelay;
     private installLifecycleListeners;

package/dist/gateway/gateway-client.js

@@ -142,7 +142,7 @@ class GatewayClient {
             diff_only: options?.diff_only ?? false,
         });
         if (!this.isConnected()) {
-            void this.connect();
+            this.connectInBackground();
             return;
         }
         this.send({
@@ -222,7 +222,7 @@ class GatewayClient {
     }
     syncChannel(channel) {
         if (!this.isConnected()) {
-            void this.connect();
+            this.connectInBackground();
             return;
         }
         this.send({
@@ -235,7 +235,7 @@ class GatewayClient {
     }
     sendOneShotMessage(channel, data) {
         if (!this.isConnected()) {
-            void this.connect();
+            this.connectInBackground();
             return;
         }
         this.send({
@@ -382,9 +382,16 @@ class GatewayClient {
         this.reconnectAttempts += 1;
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
-            void this.connect();
+            this.connectInBackground();
         }, delay);
     }
+    connectInBackground() {
+        void this.connect().catch((err) => {
+            this.emit("wssError", {
+                message: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
     /** Exponential backoff with full-jitter, capped at RECONNECT_CAP_MS. */
     computeReconnectDelay() {
         const exp = Math.min(RECONNECT_CAP_MS, RECONNECT_BASE_MS * 2 ** this.reconnectAttempts);
@@ -413,7 +420,7 @@ class GatewayClient {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
-        void this.connect();
+        this.connectInBackground();
     }
     channelKey(channel) {
         return `${channel.agent_id}/${channel.name}`;

package/dist/http/rest-client.d.ts

@@ -46,6 +46,9 @@ export declare class RestClient {
     setStats(stats: DooverStatsCollector | null): void;
     request<T>(options: RequestOptions): Promise<T>;
     private doRequest;
+    private prepareAuth;
+    private prepareRequest;
+    private sendRequest;
     get<T>(path: string, query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
     post<T>(path: string, body?: RequestOptions["body"], query?: RequestOptions["query"], baseUrl?: string): Promise<T>;
     put<T>(path: string, body?: RequestOptions["body"], query?: RequestOptions["query"], baseUrl?: string): Promise<T>;

package/dist/http/rest-client.js

@@ -30,20 +30,45 @@ class RestClient {
         }
     }
     async doRequest(options) {
+        await this.prepareAuth();
+        const request = this.prepareRequest(options);
+        let response = await this.sendRequest(request);
+        let payload = await this.parseResponse(response);
+        if (response.status === 401 && this.auth) {
+            const recovered = await this.auth.handleUnauthorized();
+            if (recovered) {
+                await this.prepareAuth();
+                const retryRequest = this.prepareRequest(options);
+                response = await this.sendRequest(retryRequest);
+                payload = await this.parseResponse(response);
+            }
+        }
+        if (!response.ok) {
+            throw new errors_1.DooverApiError({
+                status: response.status,
+                body: payload,
+                url: request.url,
+                method: request.method,
+                message: typeof payload === "object" &&
+                    payload !== null &&
+                    "message" in payload &&
+                    typeof payload.message === "string"
+                    ? payload.message
+                    : undefined,
+            });
+        }
+        return payload;
+    }
+    async prepareAuth() {
         if (this.auth) {
             await this.auth.ensureReady();
         }
+    }
+    prepareRequest(options) {
         const method = options.method ?? "GET";
         const url = this.buildUrl(options.baseUrl ?? this.config.dataRestUrl, options.path, options.query);
         const headers = new Headers(options.headers);
         const body = this.normalizeBody(options.body, headers);
-        // Merge auth headers.
-        if (this.auth) {
-            const authHeaders = await this.auth.getHttpHeaders();
-            for (const [key, value] of Object.entries(authHeaders)) {
-                headers.set(key, value);
-            }
-        }
         if (!options.omitSharingHeader) {
             headers.set("X-Doover-Sharing", this.config.sharing);
         }
@@ -57,29 +82,24 @@ class RestClient {
         const credentials = this.auth
             ? this.auth.getFetchCredentials()
             : "include";
+        return { url, method, headers, body, credentials };
+    }
+    async sendRequest(request) {
+        // Merge auth headers immediately before fetch so a retry can use refreshed
+        // credentials without mutating the first request's Headers instance.
+        if (this.auth) {
+            const authHeaders = await this.auth.getHttpHeaders();
+            for (const [key, value] of Object.entries(authHeaders)) {
+                request.headers.set(key, value);
+            }
+        }
         const fetchImpl = this.config.fetchImpl ?? fetch;
-        const response = await fetchImpl(url, {
-            method,
-            headers,
-            body,
-            credentials,
+        return fetchImpl(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            credentials: request.credentials,
         });
-        const payload = await this.parseResponse(response);
-        if (!response.ok) {
-            throw new errors_1.DooverApiError({
-                status: response.status,
-                body: payload,
-                url,
-                method,
-                message: typeof payload === "object" &&
-                    payload !== null &&
-                    "message" in payload &&
-                    typeof payload.message === "string"
-                    ? payload.message
-                    : undefined,
-            });
-        }
-        return payload;
     }
     get(path, query, baseUrl) {
         return this.request({ path, query, baseUrl });

package/dist/react/useMultiAgentChannelMessages.d.ts

@@ -27,6 +27,21 @@ export interface UseMultiAgentChannelMessagesOptions {
     fields?: string[];
     /** Optional first-page `before` cursor (snowflake id). */
     initialBefore?: string;
+    /**
+     * Keep paging older automatically until `hasNextPage` is false. Each page
+     * resumes only the agents that hit `agentMessageLimit`, using their own
+     * cursors, so a noisy agent doesn't drag the quiet ones back through
+     * messages they've already returned. Almost always combined with `after`
+     * — without a lower bound this walks every agent's channel back to its
+     * first message. `maxPages` caps the walk.
+     */
+    autoPaginate?: boolean;
+    /**
+     * Hard cap on pages fetched when `autoPaginate` is set. Defaults to 20.
+     * Guards against a window that's wider than `agentMessageLimit × maxPages`
+     * messages turning into an unbounded fetch loop.
+     */
+    maxPages?: number;
     /**
      * Optional lower-bound snowflake id. Forwarded server-side so each
      * agent's pagination stops on its own once it walks past the bound —
@@ -45,7 +60,16 @@ export interface UseMultiAgentChannelMessagesOptions {
 }
 interface Page<TData> {
     results: MessageStructure<TData>[];
-    next?: string;
+    /**
+     * Per-agent resume cursors, keyed by agent id. Present (and non-empty)
+     * only for agents that hit the per-agent limit before draining the
+     * window. This is the canonical "there is more" signal.
+     */
+    next_cursors?: Record<string, string>;
+    /** Legacy single-cursor signal, for servers predating `next_cursors`. */
+    next?: string | null;
+    /** Legacy: agent ids that may have more older messages. */
+    at_limit_agent_ids?: string[];
 }
 export interface UseMultiAgentChannelMessagesResult<TData> extends Omit<UseInfiniteQueryResult<InfiniteData<Page<TData>>>, "data"> {
     messages: MessageStructure<TData>[];

package/dist/react/useMultiAgentChannelMessages.js

@@ -30,6 +30,33 @@ function multiAgentChannelMessagesQueryKey(channelName, agentIds, sources, scope
         ? [...base, scopeKey]
         : base;
 }
+function nextPageParam(lastPage) {
+    if (!lastPage)
+        return undefined;
+    const cursors = lastPage.next_cursors;
+    if (cursors) {
+        const entries = Object.entries(cursors);
+        // Present-but-empty means every agent drained its window: we're done.
+        if (entries.length === 0)
+            return undefined;
+        return {
+            agentIds: entries.map(([id]) => id),
+            agentBefore: entries.map(([, cursor]) => cursor),
+        };
+    }
+    // Legacy server: one global `before` for whichever agents were at limit.
+    // Those agents whose own cursor is older than `next` re-return a few
+    // messages we already hold — harmless, since we dedupe by id below.
+    if (typeof lastPage.next === "string" && lastPage.next) {
+        return {
+            before: lastPage.next,
+            ...(lastPage.at_limit_agent_ids?.length
+                ? { agentIds: lastPage.at_limit_agent_ids }
+                : {}),
+        };
+    }
+    return undefined;
+}
 function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const client = (0, context_1.useDooverClient)();
     const queryClient = (0, react_query_1.useQueryClient)();
@@ -40,6 +67,8 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const initialBefore = options?.initialBefore;
     const sources = options?.sources;
     const after = options?.after;
+    const autoPaginate = options?.autoPaginate ?? false;
+    const maxPages = options?.maxPages ?? 20;
     const key = multiAgentChannelMessagesQueryKey(channelName, agentIds, sources, {
         after,
         fields,
@@ -86,12 +115,13 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
         queryKey: key,
         enabled: agentIds.length > 0,
         staleTime: Infinity,
-        initialPageParam: initialBefore,
-        getNextPageParam: (lastPage) => lastPage?.next,
+        initialPageParam: (initialBefore ? { before: initialBefore } : {}),
+        getNextPageParam: nextPageParam,
         queryFn: async ({ pageParam }) => {
             const params = {
-                agent_id: agentIds,
-                ...(typeof pageParam === "string" ? { before: pageParam } : {}),
+                agent_id: pageParam.agentIds ?? agentIds,
+                ...(pageParam.before ? { before: pageParam.before } : {}),
+                ...(pageParam.agentBefore ? { agent_before: pageParam.agentBefore } : {}),
                 ...(limit !== undefined ? { limit } : {}),
                 ...(agentMessageLimit !== undefined
                     ? { agent_message_limit: agentMessageLimit }
@@ -108,6 +138,36 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
             return page;
         },
     });
-    const messages = (0, react_1.useMemo)(() => (query.data?.pages ?? []).flatMap((p) => p.results), [query.data]);
+    (0, react_1.useEffect)(() => {
+        if (!autoPaginate)
+            return;
+        if (query.isFetching || !query.hasNextPage)
+            return;
+        if ((query.data?.pages.length ?? 0) >= maxPages)
+            return;
+        query.fetchNextPage();
+    }, [
+        autoPaginate,
+        maxPages,
+        query.isFetching,
+        query.hasNextPage,
+        query.fetchNextPage,
+        query.data?.pages.length,
+    ]);
+    const messages = (0, react_1.useMemo)(() => {
+        // The legacy single-cursor path (and a live push that races a page
+        // fetch) can hand us the same message twice; keep the first copy.
+        const seen = new Set();
+        const out = [];
+        for (const page of query.data?.pages ?? []) {
+            for (const message of page.results) {
+                if (seen.has(message.id))
+                    continue;
+                seen.add(message.id);
+                out.push(message);
+            }
+        }
+        return out;
+    }, [query.data]);
     return { ...query, messages };
 }

package/dist/test/gateway-client.test.js

@@ -6,9 +6,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
 const mocha_1 = require("mocha");
 const sinon_1 = __importDefault(require("sinon"));
+const doover_auth_1 = require("../auth/doover-auth");
+const errors_1 = require("../auth/errors");
 const gateway_client_1 = require("../gateway/gateway-client");
 const snowflake_1 = require("../utils/snowflake");
 const helpers_1 = require("./helpers");
+class RejectingAuth extends doover_auth_1.DooverAuth {
+    async getHttpHeaders() {
+        return {};
+    }
+    getFetchCredentials() {
+        return "omit";
+    }
+    async prepareWebSocket(url) {
+        return { url };
+    }
+    setToken() {
+        // no-op for test
+    }
+    setRefreshToken() {
+        // no-op for test
+    }
+    async ensureReady() {
+        throw new errors_1.DooverAuthError("Authentication is invalid; sign in again");
+    }
+}
 (0, mocha_1.describe)("GatewayClient", () => {
     (0, mocha_1.beforeEach)(() => {
         helpers_1.MockWebSocket.reset();
@@ -229,6 +251,27 @@ const helpers_1 = require("./helpers");
         (0, chai_1.expect)(cancelled.calledOnce).to.equal(true);
         (0, chai_1.expect)(client.getSession()).to.equal(null);
     });
+    (0, mocha_1.it)("reports background connect auth failures without creating a socket", async () => {
+        const client = new gateway_client_1.GatewayClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            webSocketImpl: helpers_1.MockWebSocket,
+        }, new RejectingAuth());
+        const wssError = sinon_1.default.spy();
+        client.on("wssError", wssError);
+        client.subscribe({ agent_id: "a1", name: "c1" });
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+        (0, chai_1.expect)(helpers_1.MockWebSocket.instances).to.have.length(0);
+        (0, chai_1.expect)(wssError.calledOnce).to.equal(true);
+        (0, chai_1.expect)(wssError.firstCall.args[0]).to.deep.equal({
+            message: "Authentication is invalid; sign in again",
+        });
+    });
     (0, mocha_1.it)("reconnects with exponential backoff + jitter on unexpected close", () => {
         // Make jitter deterministic: Math.random() → 1 means "wait the full backoff window".
         const randomStub = sinon_1.default.stub(Math, "random").returns(1);

package/dist/test/rest-client.test.js

@@ -6,9 +6,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
 const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
 const mocha_1 = require("mocha");
+const doover_auth_1 = require("../auth/doover-auth");
 const rest_client_1 = require("../http/rest-client");
 const helpers_1 = require("./helpers");
 (0, chai_1.use)(chai_as_promised_1.default);
+class RefreshableAuth extends doover_auth_1.DooverAuth {
+    constructor() {
+        super(...arguments);
+        this.refreshCount = 0;
+    }
+    async getHttpHeaders() {
+        return { Authorization: `Bearer token-${this.refreshCount}` };
+    }
+    getFetchCredentials() {
+        return "omit";
+    }
+    async prepareWebSocket(url) {
+        return { url };
+    }
+    setToken() {
+        // no-op for test
+    }
+    setRefreshToken() {
+        // no-op for test
+    }
+    async ensureReady() {
+        // no-op for test
+    }
+    async handleUnauthorized() {
+        this.refreshCount += 1;
+        return true;
+    }
+}
 (0, mocha_1.describe)("RestClient", () => {
     (0, mocha_1.beforeEach)(() => {
         (0, helpers_1.installSessionStorageMock)();
@@ -119,6 +148,42 @@ const helpers_1 = require("./helpers");
             (0, chai_1.expect)(error.method).to.equal("GET");
         });
     });
+    (0, mocha_1.it)("refreshes auth once and retries after a 401 response", async () => {
+        const auth = new RefreshableAuth();
+        const fetchMock = (0, helpers_1.createFetchMock)(() => {
+            if (fetchMock.callCount === 1) {
+                return (0, helpers_1.createJsonResponse)({ message: "expired" }, { status: 401 });
+            }
+            return (0, helpers_1.createJsonResponse)({ ok: true });
+        });
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        }, auth);
+        await (0, chai_1.expect)(client.get("/needs-auth")).to.eventually.deep.equal({ ok: true });
+        (0, chai_1.expect)(auth.refreshCount).to.equal(1);
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(2);
+        (0, chai_1.expect)((fetchMock.getCall(0).args[1]?.headers).get("Authorization")).to.equal("Bearer token-0");
+        (0, chai_1.expect)((fetchMock.getCall(1).args[1]?.headers).get("Authorization")).to.equal("Bearer token-1");
+    });
+    (0, mocha_1.it)("does not retry a 401 response when auth refresh cannot recover", async () => {
+        const auth = new RefreshableAuth();
+        auth.handleUnauthorized = async () => false;
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)({ message: "expired" }, { status: 401 }));
+        const client = new rest_client_1.RestClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+        }, auth);
+        await (0, chai_1.expect)(client.get("/needs-auth")).to.be.rejected.then((error) => {
+            (0, chai_1.expect)(error.status).to.equal(401);
+            (0, chai_1.expect)(error.message).to.equal("expired");
+        });
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(1);
+    });
     (0, mocha_1.it)("returns text bodies when the response is not JSON", async () => {
         const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createTextResponse)("plain text"));
         const client = new rest_client_1.RestClient({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",