@bbradar/mcp 0.1.19 → 0.1.20

package/dist/bbradarClient.js

@@ -2,12 +2,19 @@ import { randomUUID } from "node:crypto";
 import { TtlCache } from "./cache.js";
 import { stableStringify } from "./json.js";
 import { encodeProgramIdPath } from "./url.js";
+const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 60_000;
+const TARGET_CHANGES_CONCURRENCY_LIMIT = 3;
+const UPSTREAM_KEY_IP_REQUEST_LIMIT = 60;
+const UPSTREAM_KEY_IP_WINDOW_MS = 60_000;
 export class BBRadarApiError extends Error {
     requestId;
     upstreamRequestId;
     status;
     detail;
     errors;
+    cached;
+    coalesced;
+    cacheExpiresAt;
     constructor(params) {
         super(params.message, { cause: params.cause });
         this.name = "BBRadarApiError";
@@ -16,23 +23,75 @@ export class BBRadarApiError extends Error {
         this.status = params.status;
         this.detail = params.detail;
         this.errors = params.errors;
+        this.cached = params.cached ?? false;
+        this.coalesced = params.coalesced ?? false;
+        this.cacheExpiresAt = params.cacheExpiresAt;
     }
 }
 export class BBRadarClient {
     config;
     cache;
+    negativeCache;
     inFlight = new Map();
+    endpointMetrics = new Map();
+    requestQueue = [];
+    endpointRequestQueues = new Map();
+    endpointActiveRequests = new Map();
+    upstreamRateLimits = new Map();
+    upstreamRequestTimestampsMs = [];
+    activeRequests = 0;
+    globalBlockedUntilMs;
     constructor(config) {
         this.config = config;
         this.cache = new TtlCache(config.cacheMaxEntries, config.cacheTtlMs);
+        this.negativeCache = new TtlCache(config.cacheMaxEntries, config.negativeCacheTtlMs);
     }
     diagnostics() {
+        const endpointEntries = [...this.endpointMetrics.entries()];
+        const totalRequests = endpointEntries.reduce((total, [, metric]) => total + metric.requests, 0);
+        const totalErrors = endpointEntries.reduce((total, [, metric]) => total + metric.errors, 0);
+        const totalMs = endpointEntries.reduce((total, [, metric]) => total + metric.totalMs, 0);
         return {
             response_cache: {
                 enabled: this.config.cacheTtlMs > 0 && this.config.cacheMaxEntries > 0,
                 ...this.cache.stats()
             },
-            in_flight_requests: this.inFlight.size
+            negative_response_cache: {
+                enabled: this.config.negativeCacheTtlMs > 0 && this.config.cacheMaxEntries > 0,
+                ...this.negativeCache.stats()
+            },
+            in_flight_requests: this.inFlight.size,
+            request_concurrency: {
+                limit: this.config.maxConcurrentRequests,
+                active: this.activeRequests,
+                queued: this.requestQueue.length,
+                endpoint_limits: {
+                    target_changes: {
+                        limit: TARGET_CHANGES_CONCURRENCY_LIMIT,
+                        active: this.endpointActiveRequests.get("target_changes") ?? 0,
+                        queued: this.endpointRequestQueues.get("target_changes")?.length ?? 0
+                    }
+                }
+            },
+            upstream_request_window: this.upstreamRequestWindowDiagnostics(),
+            upstream_rate_limit: this.upstreamRateLimitDiagnostics(),
+            upstream_requests: {
+                actual_requests: totalRequests,
+                errors: totalErrors,
+                avg_ms: totalRequests > 0 ? Math.round(totalMs / totalRequests) : 0,
+                max_ms: endpointEntries.reduce((maximum, [, metric]) => Math.max(maximum, metric.maxMs), 0),
+                by_endpoint: Object.fromEntries(endpointEntries.map(([endpoint, metric]) => [
+                    endpoint,
+                    {
+                        requests: metric.requests,
+                        errors: metric.errors,
+                        avg_ms: metric.requests > 0 ? Math.round(metric.totalMs / metric.requests) : 0,
+                        max_ms: metric.maxMs,
+                        last_ms: metric.lastMs,
+                        statuses: Object.fromEntries(metric.statuses)
+                    }
+                ]))
+            }
         };
     }
     async validateKey() {
@@ -116,6 +175,10 @@ export class BBRadarClient {
             body: options.body ?? null
         });
         const cacheable = method === "GET" && (options.cache ?? true) && this.config.cacheTtlMs > 0 && this.config.cacheMaxEntries > 0;
+        const negativeCacheable = method === "GET" &&
+            (options.cache ?? true) &&
+            this.config.negativeCacheTtlMs > 0 &&
+            this.config.cacheMaxEntries > 0;
         const coalesceable = method === "GET" && (options.coalesce ?? true);
         if (cacheable) {
             const cached = this.cache.get(requestKey);
@@ -128,6 +191,17 @@ export class BBRadarClient {
                 };
             }
         }
+        if (negativeCacheable) {
+            const cachedError = this.negativeCache.get(requestKey);
+            if (cachedError) {
+                throw new BBRadarApiError({
+                    ...cachedError.value,
+                    requestId,
+                    cached: true,
+                    cacheExpiresAt: new Date(cachedError.expiresAt).toISOString()
+                });
+            }
+        }
         if (coalesceable) {
             const pending = this.inFlight.get(requestKey);
             if (pending) {
@@ -141,7 +215,7 @@ export class BBRadarClient {
                     };
                 }
                 catch (error) {
-                    throw cloneApiError(error, requestId);
+                    throw cloneApiError(error, requestId, true);
                 }
             }
         }
@@ -154,12 +228,30 @@ export class BBRadarClient {
             if (cacheable) {
                 this.cache.set(requestKey, result);
             }
+            if (negativeCacheable) {
+                this.negativeCache.delete(requestKey);
+            }
             return {
                 ...result,
                 requestId,
                 cached: false
             };
         }
+        catch (error) {
+            if (negativeCacheable &&
+                error instanceof BBRadarApiError &&
+                error.status !== undefined &&
+                isNegativeCacheStatus(error.status)) {
+                this.negativeCache.set(requestKey, {
+                    message: error.message,
+                    upstreamRequestId: error.upstreamRequestId,
+                    status: error.status,
+                    detail: error.detail,
+                    errors: error.errors
+                });
+            }
+            throw error;
+        }
         finally {
             if (coalesceable) {
                 this.inFlight.delete(requestKey);
@@ -167,57 +259,304 @@ export class BBRadarClient {
         }
     }
     async fetchFromApi(options, method, url, requestId) {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
-        try {
-            const init = {
-                method,
-                headers: this.headers(options.body),
-                cache: "no-store",
-                signal: controller.signal
-            };
-            if (options.body !== undefined) {
-                init.body = JSON.stringify(options.body);
-            }
-            const response = await fetch(url, init);
-            const upstreamRequestId = extractRequestId(response.headers);
-            const data = await parseResponseBody(response);
-            if (!response.ok) {
-                const params = {
-                    message: formatApiErrorMessage(response.status, data),
-                    requestId,
+        return this.withRequestSlot(options.path, async () => {
+            const rateLimitBucket = rateLimitEndpointGroup(options.path);
+            this.reserveUpstreamRequest(requestId, rateLimitBucket);
+            const startedAt = Date.now();
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
+            let status;
+            let failed = true;
+            try {
+                const init = {
+                    method,
+                    headers: this.headers(options.body),
+                    signal: controller.signal
+                };
+                if (options.body !== undefined) {
+                    init.body = JSON.stringify(options.body);
+                }
+                const response = await fetch(url, init);
+                status = response.status;
+                this.observeUpstreamRateLimit(rateLimitBucket, response.headers, response.status);
+                const upstreamRequestId = extractRequestId(response.headers);
+                const data = await parseResponseBody(response);
+                if (!response.ok) {
+                    const params = {
+                        message: formatApiErrorMessage(response.status, data),
+                        requestId,
+                        status: response.status,
+                        detail: extractObjectField(data, "detail"),
+                        errors: extractObjectField(data, "errors")
+                    };
+                    if (upstreamRequestId) {
+                        params.upstreamRequestId = upstreamRequestId;
+                    }
+                    throw new BBRadarApiError(params);
+                }
+                const result = {
+                    data: data,
                     status: response.status,
-                    detail: extractObjectField(data, "detail"),
-                    errors: extractObjectField(data, "errors")
+                    fetchedAt: new Date().toISOString()
                 };
                 if (upstreamRequestId) {
-                    params.upstreamRequestId = upstreamRequestId;
+                    result.upstreamRequestId = upstreamRequestId;
                 }
-                throw new BBRadarApiError(params);
+                failed = false;
+                return result;
             }
-            const result = {
-                data: data,
-                status: response.status,
-                fetchedAt: new Date().toISOString()
-            };
-            if (upstreamRequestId) {
-                result.upstreamRequestId = upstreamRequestId;
+            catch (error) {
+                if (error instanceof BBRadarApiError) {
+                    throw error;
+                }
+                throw new BBRadarApiError({
+                    message: error instanceof Error && error.name === "AbortError" ? "BBRadar API request timed out." : "BBRadar API request failed.",
+                    requestId,
+                    cause: error
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+                this.recordEndpointMetric(options.path, Date.now() - startedAt, status, failed);
             }
-            return result;
+        });
+    }
+    async withRequestSlot(path, callback) {
+        const endpointGroup = rateLimitEndpointGroup(path);
+        const endpointLimit = endpointConcurrencyLimit(endpointGroup);
+        if (endpointLimit === undefined) {
+            return this.withGlobalRequestSlot(callback);
         }
-        catch (error) {
-            if (error instanceof BBRadarApiError) {
-                throw error;
+        return this.withEndpointRequestSlot(endpointGroup, endpointLimit, () => this.withGlobalRequestSlot(callback));
+    }
+    async withGlobalRequestSlot(callback) {
+        const limit = Math.max(1, this.config.maxConcurrentRequests);
+        if (this.activeRequests >= limit) {
+            await new Promise((resolve) => this.requestQueue.push(resolve));
+        }
+        else {
+            this.activeRequests += 1;
+        }
+        try {
+            return await callback();
+        }
+        finally {
+            const next = this.requestQueue.shift();
+            if (next) {
+                next();
             }
-            throw new BBRadarApiError({
-                message: error instanceof Error && error.name === "AbortError" ? "BBRadar API request timed out." : "BBRadar API request failed.",
-                requestId,
-                cause: error
+            else {
+                this.activeRequests -= 1;
+            }
+        }
+    }
+    async withEndpointRequestSlot(endpointGroup, limit, callback) {
+        const active = this.endpointActiveRequests.get(endpointGroup) ?? 0;
+        if (active >= limit) {
+            const queue = this.endpointRequestQueues.get(endpointGroup) ?? [];
+            await new Promise((resolve) => {
+                queue.push(resolve);
+                this.endpointRequestQueues.set(endpointGroup, queue);
             });
         }
+        else {
+            this.endpointActiveRequests.set(endpointGroup, active + 1);
+        }
+        try {
+            return await callback();
+        }
         finally {
-            clearTimeout(timeout);
+            const queue = this.endpointRequestQueues.get(endpointGroup);
+            const next = queue?.shift();
+            if (next) {
+                next();
+            }
+            else {
+                this.endpointActiveRequests.set(endpointGroup, Math.max(0, (this.endpointActiveRequests.get(endpointGroup) ?? 1) - 1));
+            }
+            if (queue?.length === 0) {
+                this.endpointRequestQueues.delete(endpointGroup);
+            }
+        }
+    }
+    recordEndpointMetric(path, durationMs, status, failed) {
+        const endpoint = metricEndpoint(path);
+        const metric = this.endpointMetrics.get(endpoint) ??
+            {
+                requests: 0,
+                errors: 0,
+                totalMs: 0,
+                maxMs: 0,
+                lastMs: 0,
+                statuses: new Map()
+            };
+        const statusKey = status === undefined ? "network_error" : String(status);
+        metric.requests += 1;
+        metric.errors += failed ? 1 : 0;
+        metric.totalMs += durationMs;
+        metric.maxMs = Math.max(metric.maxMs, durationMs);
+        metric.lastMs = durationMs;
+        metric.statuses.set(statusKey, (metric.statuses.get(statusKey) ?? 0) + 1);
+        this.endpointMetrics.set(endpoint, metric);
+    }
+    reserveUpstreamRequest(requestId, bucket) {
+        const now = Date.now();
+        const state = this.rateLimitState(bucket);
+        this.refreshUpstreamRateLimitWindow(state, now);
+        this.refreshUpstreamRequestWindow(now);
+        if ((this.globalBlockedUntilMs ?? 0) > now || (state.blockedUntilMs ?? 0) > now) {
+            throw localRateLimitError(requestId, bucket, state, this.globalBlockedUntilMs, this.upstreamRequestTimestampsMs.length);
+        }
+        if (this.shouldEnforceSharedRequestWindow() &&
+            this.upstreamRequestTimestampsMs.length >= UPSTREAM_KEY_IP_REQUEST_LIMIT) {
+            this.globalBlockedUntilMs =
+                (this.upstreamRequestTimestampsMs[0] ?? now) + UPSTREAM_KEY_IP_WINDOW_MS;
+            throw localRateLimitError(requestId, bucket, state, this.globalBlockedUntilMs, this.upstreamRequestTimestampsMs.length);
+        }
+        if (state.remaining !== undefined) {
+            if (state.remaining <= 0) {
+                state.blockedUntilMs =
+                    state.resetAtMs && state.resetAtMs > now
+                        ? state.resetAtMs
+                        : now + DEFAULT_RATE_LIMIT_COOLDOWN_MS;
+                throw localRateLimitError(requestId, bucket, state, this.globalBlockedUntilMs, this.upstreamRequestTimestampsMs.length);
+            }
+            state.remaining -= 1;
+        }
+        this.upstreamRequestTimestampsMs.push(now);
+    }
+    observeUpstreamRateLimit(bucket, headers, status) {
+        const now = Date.now();
+        const state = this.rateLimitState(bucket);
+        const limit = readRateLimitNumber(headers, ["x-ratelimit-limit", "ratelimit-limit"]);
+        const remaining = readRateLimitNumber(headers, ["x-ratelimit-remaining", "ratelimit-remaining"]);
+        const resetAtMs = parseRateLimitReset(headers, now);
+        const retryAtMs = parseRetryAfter(headers, now);
+        const previousResetAtMs = state.resetAtMs;
+        const sameWindow = resetAtMs === undefined ||
+            previousResetAtMs === undefined ||
+            Math.abs(resetAtMs - previousResetAtMs) < 1_000;
+        if (limit !== undefined) {
+            state.limit = limit;
+        }
+        if (remaining !== undefined) {
+            state.remaining =
+                sameWindow && state.remaining !== undefined
+                    ? Math.min(state.remaining, remaining)
+                    : remaining;
+        }
+        if (resetAtMs !== undefined) {
+            state.resetAtMs = resetAtMs;
         }
+        state.observedAtMs = now;
+        state.lastStatus = status;
+        if (status === 429) {
+            const advertisedBlockUntil = Math.max(retryAtMs ?? 0, resetAtMs && resetAtMs > now ? resetAtMs : 0);
+            const blockedUntil = advertisedBlockUntil > now ? advertisedBlockUntil : now + DEFAULT_RATE_LIMIT_COOLDOWN_MS;
+            state.remaining = 0;
+            state.blockedUntilMs = blockedUntil;
+            this.globalBlockedUntilMs = Math.max(this.globalBlockedUntilMs ?? 0, blockedUntil);
+            return;
+        }
+        if (remaining === 0) {
+            state.blockedUntilMs =
+                resetAtMs && resetAtMs > now ? resetAtMs : now + DEFAULT_RATE_LIMIT_COOLDOWN_MS;
+        }
+        else if ((state.blockedUntilMs ?? 0) <= now) {
+            state.blockedUntilMs = undefined;
+        }
+    }
+    rateLimitState(bucket) {
+        const state = this.upstreamRateLimits.get(bucket) ?? {};
+        this.upstreamRateLimits.set(bucket, state);
+        return state;
+    }
+    refreshUpstreamRequestWindow(now) {
+        const cutoff = now - UPSTREAM_KEY_IP_WINDOW_MS;
+        while (this.upstreamRequestTimestampsMs.length > 0 &&
+            (this.upstreamRequestTimestampsMs[0] ?? now) <= cutoff) {
+            this.upstreamRequestTimestampsMs.shift();
+        }
+    }
+    upstreamRequestWindowDiagnostics() {
+        const now = Date.now();
+        this.refreshUpstreamRequestWindow(now);
+        const enforced = this.shouldEnforceSharedRequestWindow();
+        return {
+            enforced,
+            limit: UPSTREAM_KEY_IP_REQUEST_LIMIT,
+            window_ms: UPSTREAM_KEY_IP_WINDOW_MS,
+            used: this.upstreamRequestTimestampsMs.length,
+            remaining: enforced
+                ? Math.max(0, UPSTREAM_KEY_IP_REQUEST_LIMIT - this.upstreamRequestTimestampsMs.length)
+                : undefined,
+            resets_at: toIsoString(this.upstreamRequestTimestampsMs.length > 0
+                ? (this.upstreamRequestTimestampsMs[0] ?? now) + UPSTREAM_KEY_IP_WINDOW_MS
+                : undefined)
+        };
+    }
+    shouldEnforceSharedRequestWindow() {
+        try {
+            const hostname = new URL(this.config.apiBaseUrl).hostname.toLowerCase();
+            if (hostname === "bbradar.io" || hostname.endsWith(".bbradar.io")) {
+                return true;
+            }
+        }
+        catch {
+            // Invalid base URLs fail when a request URL is constructed.
+        }
+        return [...this.upstreamRateLimits.values()].some((state) => state.limit !== undefined ||
+            state.remaining !== undefined ||
+            state.resetAtMs !== undefined);
+    }
+    refreshUpstreamRateLimitWindow(state, now) {
+        if (state.resetAtMs !== undefined && state.resetAtMs <= now) {
+            state.remaining = undefined;
+            state.resetAtMs = undefined;
+        }
+        if (state.blockedUntilMs !== undefined && state.blockedUntilMs <= now) {
+            state.blockedUntilMs = undefined;
+        }
+    }
+    upstreamRateLimitDiagnostics() {
+        const now = Date.now();
+        const entries = [...this.upstreamRateLimits.entries()];
+        for (const [, state] of entries) {
+            this.refreshUpstreamRateLimitWindow(state, now);
+        }
+        if (this.globalBlockedUntilMs !== undefined && this.globalBlockedUntilMs <= now) {
+            this.globalBlockedUntilMs = undefined;
+        }
+        const observedEntries = entries.filter(([, state]) => state.observedAtMs !== undefined);
+        const latest = [...observedEntries].sort((left, right) => (right[1].observedAtMs ?? 0) - (left[1].observedAtMs ?? 0))[0];
+        const latestState = latest?.[1];
+        const globallyBlocked = (this.globalBlockedUntilMs ?? 0) > now;
+        const anyBucketBlocked = observedEntries.some(([, state]) => (state.blockedUntilMs ?? 0) > now);
+        const blockedUntil = Math.max(this.globalBlockedUntilMs ?? 0, ...observedEntries.map(([, state]) => state.blockedUntilMs ?? 0));
+        return {
+            observed: observedEntries.length > 0,
+            bucket: latest?.[0],
+            limit: latestState?.limit,
+            remaining: latestState?.remaining,
+            reset_at: toIsoString(latestState?.resetAtMs),
+            blocked: globallyBlocked || anyBucketBlocked,
+            globally_blocked: globallyBlocked,
+            blocked_until: toIsoString(blockedUntil > 0 ? blockedUntil : undefined),
+            observed_at: toIsoString(latestState?.observedAtMs),
+            last_status: latestState?.lastStatus,
+            buckets: Object.fromEntries(observedEntries.map(([bucket, state]) => [
+                bucket,
+                {
+                    limit: state.limit,
+                    remaining: state.remaining,
+                    reset_at: toIsoString(state.resetAtMs),
+                    blocked: (state.blockedUntilMs ?? 0) > now,
+                    blocked_until: toIsoString(state.blockedUntilMs),
+                    observed_at: toIsoString(state.observedAtMs),
+                    last_status: state.lastStatus
+                }
+            ]))
+        };
     }
     buildUrl(path, query) {
         const url = new URL(`${this.config.apiBaseUrl}${path}`);
@@ -227,20 +566,19 @@ export class BBRadarClient {
             }
             if (Array.isArray(value)) {
                 if (value.length > 0) {
-                    url.searchParams.set(key, value.join(","));
+                    url.searchParams.set(key, [...value].map(String).sort().join(","));
                 }
                 continue;
             }
             url.searchParams.set(key, String(value));
         }
+        url.searchParams.sort();
         return url;
     }
     headers(body) {
         const headers = {
             authorization: `Bearer ${this.config.apiKey}`,
             accept: "application/json",
-            "cache-control": "no-cache, no-store, max-age=0",
-            pragma: "no-cache",
             "user-agent": "@bbradar/mcp"
         };
         if (body !== undefined) {
@@ -249,6 +587,110 @@ export class BBRadarClient {
         return headers;
     }
 }
+function localRateLimitError(requestId, bucket, state, globalBlockedUntilMs, upstreamWindowUsed) {
+    return new BBRadarApiError({
+        message: "BBRadar API quota is temporarily exhausted; no upstream request was sent.",
+        requestId,
+        status: 429,
+        detail: {
+            source: "local_rate_limit_guard",
+            bucket,
+            limit: state.limit,
+            remaining: state.remaining,
+            reset_at: toIsoString(state.resetAtMs),
+            retry_at: toIsoString(Math.max(state.blockedUntilMs ?? 0, globalBlockedUntilMs ?? 0)),
+            shared_key_ip_window: {
+                limit: UPSTREAM_KEY_IP_REQUEST_LIMIT,
+                used: upstreamWindowUsed,
+                remaining: Math.max(0, UPSTREAM_KEY_IP_REQUEST_LIMIT - upstreamWindowUsed)
+            }
+        }
+    });
+}
+function readRateLimitNumber(headers, names) {
+    for (const name of names) {
+        const value = headers.get(name);
+        if (value === null) {
+            continue;
+        }
+        const parsed = Number(value.trim());
+        if (Number.isFinite(parsed) && parsed >= 0) {
+            return Math.floor(parsed);
+        }
+    }
+    return undefined;
+}
+function parseRateLimitReset(headers, now) {
+    const value = headers.get("x-ratelimit-reset") ?? headers.get("ratelimit-reset");
+    if (!value) {
+        return undefined;
+    }
+    const numeric = Number(value.trim());
+    if (Number.isFinite(numeric) && numeric >= 0) {
+        if (numeric >= 1_000_000_000_000) {
+            return numeric;
+        }
+        if (numeric >= 1_000_000_000) {
+            return numeric * 1_000;
+        }
+        return now + numeric * 1_000;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function parseRetryAfter(headers, now) {
+    const value = headers.get("retry-after");
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number(value.trim());
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return now + seconds * 1_000;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function toIsoString(timestamp) {
+    return timestamp === undefined || !Number.isFinite(timestamp) ? undefined : new Date(timestamp).toISOString();
+}
+function metricEndpoint(path) {
+    if (/^\/pro\/programs\/.+\/targets$/.test(path)) {
+        return "/pro/programs/:program_id/targets";
+    }
+    if (/^\/pro\/programs\/.+/.test(path)) {
+        return "/pro/programs/:program_id";
+    }
+    if (/^\/pro\/opportunities\/[^/]+$/.test(path)) {
+        return "/pro/opportunities/:level";
+    }
+    return path;
+}
+function rateLimitEndpointGroup(path) {
+    if (path === "/pro/targets/changes") {
+        return "target_changes";
+    }
+    if (/^\/pro\/programs\/.+\/targets$/.test(path)) {
+        return "program_targets";
+    }
+    if (path === "/pro/programs" ||
+        /^\/pro\/programs\/.+/.test(path) ||
+        /^\/pro\/opportunities\/[^/]+$/.test(path)) {
+        return "programs_and_opportunities";
+    }
+    if (path === "/pro/targets/search") {
+        return "target_search";
+    }
+    if (path === "/pro/targets/export") {
+        return "target_export";
+    }
+    return "other";
+}
+function endpointConcurrencyLimit(endpointGroup) {
+    return endpointGroup === "target_changes" ? TARGET_CHANGES_CONCURRENCY_LIMIT : undefined;
+}
+function isNegativeCacheStatus(status) {
+    return status === 404 || status === 405;
+}
 async function parseResponseBody(response) {
     if (response.status === 204) {
         return null;
@@ -290,7 +732,7 @@ function formatApiErrorMessage(status, data) {
             : "Request was rejected.";
     return `BBRadar API returned ${status}: ${suffix}`;
 }
-function cloneApiError(error, requestId) {
+function cloneApiError(error, requestId, coalesced = error instanceof BBRadarApiError && error.coalesced) {
     if (!(error instanceof BBRadarApiError)) {
         return error;
     }
@@ -301,6 +743,9 @@ function cloneApiError(error, requestId) {
         status: error.status,
         detail: error.detail,
         errors: error.errors,
+        cached: error.cached,
+        coalesced,
+        cacheExpiresAt: error.cacheExpiresAt,
         cause: error
     });
 }