@masonlandcattle/servicetitan-sdk 0.9.0 → 0.9.1

package/README.md

@@ -5,7 +5,7 @@ A pragmatic ServiceTitan API client with:
 - Robust auth (Client Credentials)
 - **Retries** with exponential backoff + jitter
 - Honors **Retry-After**, handles 429/5xx
-- **Rate limiting** with Bottleneck (concurrency + minTime)
+- **Built-in rate limiting** with queued waiting in the client transport
 - URL builder and **pagination** helpers (`getAll`)
 - Broad tenant API namespace coverage across the current ServiceTitan developer portal
 - Exported TypeScript helper types for better IntelliSense when using the SDK
@@ -70,8 +70,8 @@ const st = createClient({
   clientSecret: process.env.SECRET_KEY!,
   environment: (process.env.ENVIRONMENT as any) || "production",
   retries: 3,
-  maxConcurrent: 5,
-  minTimeMs: 100,
+  apiRateLimitPerSecond: 45,
+  maxConcurrent: 20,
 });
 
 // List jobs (single page)
@@ -91,6 +91,11 @@ const materials = await st.pricebook.listMaterials({}, { all: true, pageSize: 50
 
 - Local OpenAPI JSON files in [`ServiceTitanOpenAPIJson`](./ServiceTitanOpenAPIJson) are the source of truth for this SDK.
 - Breaking changes are allowed when the documented ServiceTitan contract and the previous SDK surface disagree.
+- Requests are throttled inside [`src/client.ts`](./src/client.ts), so callers do not need to add their own queueing to use helpers like `client.request(...)` or `client.getAll(...)`.
+- Normal tenant API traffic is queued at `45` requests per second per tenant by default. You can lower it or raise it during client creation, but the SDK clamps `apiRateLimitPerSecond` to `55` max.
+- Reporting runs made through `st.reporting.getReportData(...)` are additionally queued at `5` runs per minute for the same `tenant + report category + report id`.
+- When a limit is exceeded, the SDK waits in an in-memory queue instead of failing immediately. This means large `getAll()` calls or bursts of individual requests may take longer to complete under load.
+- If ServiceTitan still responds with `429`, the client honors `Retry-After` when present and retries with exponential backoff as a fallback.
 - Export feeds generally use `{ from, includeRecentChanges }` continuation params and return `{ data, hasMore, continueFrom }`.
 - Binary telecom media endpoints return `ArrayBuffer`.
 - `options.all` is only used on endpoints with safe paginated `data` plus `hasMore` behavior.

package/dist/index.cjs

@@ -65,8 +65,125 @@ module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
 var import_axios = __toESM(require("axios"), 1);
-var import_bottleneck = __toESM(require("bottleneck"), 1);
 var import_qs = __toESM(require("qs"), 1);
+
+// src/transport/request-context.ts
+function createRequestContext(options) {
+  const { method, endpoint, defaultTenantId } = options;
+  const tenantMatch = endpoint.match(/\/tenant\/([^/]+)/i);
+  const categoryMatch = endpoint.match(/^\/([^/]+)\/v\d+\//i);
+  const reportMatch = method === "post" ? endpoint.match(/\/reporting\/v\d+\/tenant\/([^/]+)\/report-category\/([^/]+)\/reports\/([^/]+)\/data$/i) : null;
+  return {
+    method,
+    endpoint,
+    tenantId: tenantMatch?.[1] || defaultTenantId,
+    category: categoryMatch?.[1],
+    reportCategory: reportMatch?.[2],
+    reportId: reportMatch?.[3],
+    isReportDataRequest: Boolean(reportMatch)
+  };
+}
+
+// src/transport/rate-limit-manager.ts
+var import_bottleneck = __toESM(require("bottleneck"), 1);
+var RateLimitManager = class {
+  constructor(options) {
+    this.options = options;
+    this.tenantLimiters = /* @__PURE__ */ new Map();
+    this.reportLimiters = /* @__PURE__ */ new Map();
+  }
+  createLimiter(options) {
+    return new import_bottleneck.default({
+      maxConcurrent: options.maxConcurrent,
+      minTime: options.minTime,
+      reservoir: options.reservoir,
+      reservoirRefreshAmount: options.reservoirRefreshAmount,
+      reservoirRefreshInterval: options.reservoirRefreshInterval
+    });
+  }
+  getTenantLimiter(tenantId) {
+    const tenantKey = `tenant:${tenantId}`;
+    let limiter = this.tenantLimiters.get(tenantKey);
+    if (!limiter) {
+      limiter = this.createLimiter({
+        maxConcurrent: this.options.maxConcurrent,
+        minTime: this.options.minTimeMs,
+        reservoir: this.options.apiRateLimitPerSecond,
+        reservoirRefreshAmount: this.options.apiRateLimitPerSecond,
+        reservoirRefreshInterval: 1e3
+      });
+      this.tenantLimiters.set(tenantKey, limiter);
+    }
+    return limiter;
+  }
+  getReportLimiter(context) {
+    if (!context.isReportDataRequest || !context.reportCategory || !context.reportId) {
+      return null;
+    }
+    const reportKey = `report:${context.tenantId}:${context.reportCategory}:${context.reportId}`;
+    let limiter = this.reportLimiters.get(reportKey);
+    if (!limiter) {
+      limiter = this.createLimiter({
+        maxConcurrent: this.options.maxConcurrent,
+        minTime: this.options.minTimeMs,
+        reservoir: this.options.reportingRunsPerMinute,
+        reservoirRefreshAmount: this.options.reportingRunsPerMinute,
+        reservoirRefreshInterval: 6e4
+      });
+      this.reportLimiters.set(reportKey, limiter);
+    }
+    return limiter;
+  }
+  async schedule(context, fn) {
+    const tenantLimiter = this.getTenantLimiter(context.tenantId);
+    const reportLimiter = this.getReportLimiter(context);
+    if (!reportLimiter) {
+      return tenantLimiter.schedule(fn);
+    }
+    return reportLimiter.schedule(() => tenantLimiter.schedule(fn));
+  }
+};
+
+// src/transport/retry-policy.ts
+var RetryPolicy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  computeBackoff(attempt) {
+    const exp = this.options.retryInitialDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * this.options.retryInitialDelayMs;
+    return Math.min(3e4, exp + jitter);
+  }
+  isRetryable(error) {
+    const status = error?.response?.status;
+    if (!status) return true;
+    if (status === 429) return true;
+    return status >= 500;
+  }
+  parseRetryAfterMs(retryAfter) {
+    if (!retryAfter) return null;
+    const seconds = Number(retryAfter);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+    const retryAt = Date.parse(retryAfter);
+    if (Number.isNaN(retryAt)) return null;
+    return Math.max(0, retryAt - Date.now());
+  }
+  async waitBeforeRetry(attempt, retryAfter) {
+    let delayMs = this.computeBackoff(attempt);
+    const retryAfterMs = this.parseRetryAfterMs(retryAfter);
+    if (retryAfterMs != null) delayMs = Math.max(delayMs, retryAfterMs);
+    await this.delay(delayMs);
+  }
+  shouldRetry(error, attempt, retriesOverride) {
+    const maxRetries = retriesOverride ?? this.options.retries;
+    return attempt < maxRetries && this.isRetryable(error);
+  }
+};
+
+// src/client.ts
 var ServiceTitanClient = class {
   constructor(opts = {}) {
     this.token = null;
@@ -75,6 +192,8 @@ var ServiceTitanClient = class {
     const env = opts.environment || process.env.ENVIRONMENT || "production";
     const authUrl = opts.authUrl || (env === "production" ? "https://auth.servicetitan.io/connect/token" : "https://auth-integration.servicetitan.io/connect/token");
     const apiBaseUrl = opts.apiBaseUrl || (env === "production" ? "https://api.servicetitan.io" : "https://api-integration.servicetitan.io");
+    const apiRateLimitPerSecond = this.normalizeApiRateLimit(opts.apiRateLimitPerSecond);
+    const reportingRunsPerMinute = this.normalizePositiveRateLimit(opts.reportingRunsPerMinute, 5);
     const defaults = {
       tenantId: opts.tenantId || process.env.TENANT_ID || "",
       appKey: opts.appKey || process.env.APP_KEY || "",
@@ -86,17 +205,25 @@ var ServiceTitanClient = class {
       timeoutMs: opts.timeoutMs ?? 3e4,
       retries: opts.retries ?? 3,
       retryInitialDelayMs: opts.retryInitialDelayMs ?? 1e3,
-      maxConcurrent: opts.maxConcurrent ?? 5,
-      minTimeMs: opts.minTimeMs ?? 100,
+      apiRateLimitPerSecond,
+      reportingRunsPerMinute,
+      maxConcurrent: opts.maxConcurrent ?? 20,
+      minTimeMs: opts.minTimeMs ?? 0,
       logger: opts.logger || console
     };
     if (!defaults.tenantId || !defaults.appKey || !defaults.clientId || !defaults.clientSecret) {
       throw new Error("Missing required configuration: TENANT_ID, APP_KEY, CLIENT_ID, SECRET_KEY");
     }
     this.options = defaults;
-    this.limiter = new import_bottleneck.default({
+    this.rateLimitManager = new RateLimitManager({
+      apiRateLimitPerSecond: this.options.apiRateLimitPerSecond,
+      reportingRunsPerMinute: this.options.reportingRunsPerMinute,
       maxConcurrent: this.options.maxConcurrent,
-      minTime: this.options.minTimeMs
+      minTimeMs: this.options.minTimeMs
+    });
+    this.retryPolicy = new RetryPolicy({
+      retries: this.options.retries,
+      retryInitialDelayMs: this.options.retryInitialDelayMs
     });
     this.axiosInstance = import_axios.default.create({
       baseURL: this.options.apiBaseUrl,
@@ -127,6 +254,16 @@ var ServiceTitanClient = class {
       }
     );
   }
+  normalizeApiRateLimit(value) {
+    if (value == null) return 45;
+    if (!Number.isFinite(value)) return 45;
+    return Math.max(1, Math.min(55, Math.floor(value)));
+  }
+  normalizePositiveRateLimit(value, fallback) {
+    if (value == null) return fallback;
+    if (!Number.isFinite(value)) return fallback;
+    return Math.max(1, Math.floor(value));
+  }
   async refreshToken() {
     if (this.refreshing) return this.refreshing;
     this.refreshing = (async () => {
@@ -159,24 +296,13 @@ var ServiceTitanClient = class {
       throw err;
     }
   }
-  async delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  computeBackoff(base, attempt) {
-    const exp = base * Math.pow(2, attempt);
-    const jitter = Math.random() * base;
-    return Math.min(3e4, exp + jitter);
-  }
-  isRetryable(error) {
-    if (!error) return true;
-    const status = error.response?.status;
-    if (!status) return true;
-    if (status === 429) return true;
-    if (status >= 500) return true;
-    return false;
-  }
-  async schedule(fn) {
-    return this.limiter.schedule(fn);
+  async schedule(method, endpoint, fn) {
+    const context = createRequestContext({
+      method,
+      endpoint,
+      defaultTenantId: this.options.tenantId
+    });
+    return this.rateLimitManager.schedule(context, fn);
   }
   async request(method, endpoint, options = {}) {
     await this.authenticate();
@@ -185,23 +311,17 @@ var ServiceTitanClient = class {
     let attempt = 0;
     while (true) {
       try {
-        const result = await this.schedule(async () => {
+        const result = await this.schedule(method, endpoint, async () => {
           const resp = await this.axiosInstance.request({ method, url: endpoint, params, data, headers, responseType });
           return resp.data;
         });
         return result;
       } catch (error) {
         this.options.logger.warn?.("ServiceTitan API error", error.response?.status, error.response?.data || error.message);
-        if (attempt >= maxRetries || !this.isRetryable(error)) {
+        if (!this.retryPolicy.shouldRetry(error, attempt, maxRetries)) {
           throw error.response?.data || error;
         }
-        let delayMs = this.computeBackoff(this.options.retryInitialDelayMs, attempt);
-        const retryAfter = error.response?.headers?.["retry-after"];
-        if (retryAfter) {
-          const parsed = Number(retryAfter);
-          if (!Number.isNaN(parsed)) delayMs = Math.max(delayMs, parsed * 1e3);
-        }
-        await this.delay(delayMs);
+        await this.retryPolicy.waitBeforeRetry(attempt, error.response?.headers?.["retry-after"]);
         attempt += 1;
       }
     }

package/dist/index.d.cts

@@ -18,6 +18,8 @@ interface ServiceTitanClientOptions {
     timeoutMs?: number;
     retries?: number;
     retryInitialDelayMs?: number;
+    apiRateLimitPerSecond?: number;
+    reportingRunsPerMinute?: number;
     maxConcurrent?: number;
     minTimeMs?: number;
     logger?: Logger;
@@ -30,17 +32,17 @@ type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
 
 declare class ServiceTitanClient {
     private axiosInstance;
-    private limiter;
     private options;
+    private rateLimitManager;
+    private retryPolicy;
     private token;
     private tokenExpiry;
     private refreshing;
     constructor(opts?: ServiceTitanClientOptions);
+    private normalizeApiRateLimit;
+    private normalizePositiveRateLimit;
     private refreshToken;
     authenticate(): Promise<string>;
-    private delay;
-    private computeBackoff;
-    private isRetryable;
     private schedule;
     request<T = any>(method: HttpMethod, endpoint: string, options?: {
         params?: Record<string, any>;

package/dist/index.d.ts

@@ -18,6 +18,8 @@ interface ServiceTitanClientOptions {
     timeoutMs?: number;
     retries?: number;
     retryInitialDelayMs?: number;
+    apiRateLimitPerSecond?: number;
+    reportingRunsPerMinute?: number;
     maxConcurrent?: number;
     minTimeMs?: number;
     logger?: Logger;
@@ -30,17 +32,17 @@ type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
 
 declare class ServiceTitanClient {
     private axiosInstance;
-    private limiter;
     private options;
+    private rateLimitManager;
+    private retryPolicy;
     private token;
     private tokenExpiry;
     private refreshing;
     constructor(opts?: ServiceTitanClientOptions);
+    private normalizeApiRateLimit;
+    private normalizePositiveRateLimit;
     private refreshToken;
     authenticate(): Promise<string>;
-    private delay;
-    private computeBackoff;
-    private isRetryable;
     private schedule;
     request<T = any>(method: HttpMethod, endpoint: string, options?: {
         params?: Record<string, any>;

package/dist/index.js

@@ -6,8 +6,125 @@ var __export = (target, all) => {
 
 // src/client.ts
 import axios from "axios";
-import Bottleneck from "bottleneck";
 import qs from "qs";
+
+// src/transport/request-context.ts
+function createRequestContext(options) {
+  const { method, endpoint, defaultTenantId } = options;
+  const tenantMatch = endpoint.match(/\/tenant\/([^/]+)/i);
+  const categoryMatch = endpoint.match(/^\/([^/]+)\/v\d+\//i);
+  const reportMatch = method === "post" ? endpoint.match(/\/reporting\/v\d+\/tenant\/([^/]+)\/report-category\/([^/]+)\/reports\/([^/]+)\/data$/i) : null;
+  return {
+    method,
+    endpoint,
+    tenantId: tenantMatch?.[1] || defaultTenantId,
+    category: categoryMatch?.[1],
+    reportCategory: reportMatch?.[2],
+    reportId: reportMatch?.[3],
+    isReportDataRequest: Boolean(reportMatch)
+  };
+}
+
+// src/transport/rate-limit-manager.ts
+import Bottleneck from "bottleneck";
+var RateLimitManager = class {
+  constructor(options) {
+    this.options = options;
+    this.tenantLimiters = /* @__PURE__ */ new Map();
+    this.reportLimiters = /* @__PURE__ */ new Map();
+  }
+  createLimiter(options) {
+    return new Bottleneck({
+      maxConcurrent: options.maxConcurrent,
+      minTime: options.minTime,
+      reservoir: options.reservoir,
+      reservoirRefreshAmount: options.reservoirRefreshAmount,
+      reservoirRefreshInterval: options.reservoirRefreshInterval
+    });
+  }
+  getTenantLimiter(tenantId) {
+    const tenantKey = `tenant:${tenantId}`;
+    let limiter = this.tenantLimiters.get(tenantKey);
+    if (!limiter) {
+      limiter = this.createLimiter({
+        maxConcurrent: this.options.maxConcurrent,
+        minTime: this.options.minTimeMs,
+        reservoir: this.options.apiRateLimitPerSecond,
+        reservoirRefreshAmount: this.options.apiRateLimitPerSecond,
+        reservoirRefreshInterval: 1e3
+      });
+      this.tenantLimiters.set(tenantKey, limiter);
+    }
+    return limiter;
+  }
+  getReportLimiter(context) {
+    if (!context.isReportDataRequest || !context.reportCategory || !context.reportId) {
+      return null;
+    }
+    const reportKey = `report:${context.tenantId}:${context.reportCategory}:${context.reportId}`;
+    let limiter = this.reportLimiters.get(reportKey);
+    if (!limiter) {
+      limiter = this.createLimiter({
+        maxConcurrent: this.options.maxConcurrent,
+        minTime: this.options.minTimeMs,
+        reservoir: this.options.reportingRunsPerMinute,
+        reservoirRefreshAmount: this.options.reportingRunsPerMinute,
+        reservoirRefreshInterval: 6e4
+      });
+      this.reportLimiters.set(reportKey, limiter);
+    }
+    return limiter;
+  }
+  async schedule(context, fn) {
+    const tenantLimiter = this.getTenantLimiter(context.tenantId);
+    const reportLimiter = this.getReportLimiter(context);
+    if (!reportLimiter) {
+      return tenantLimiter.schedule(fn);
+    }
+    return reportLimiter.schedule(() => tenantLimiter.schedule(fn));
+  }
+};
+
+// src/transport/retry-policy.ts
+var RetryPolicy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  computeBackoff(attempt) {
+    const exp = this.options.retryInitialDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * this.options.retryInitialDelayMs;
+    return Math.min(3e4, exp + jitter);
+  }
+  isRetryable(error) {
+    const status = error?.response?.status;
+    if (!status) return true;
+    if (status === 429) return true;
+    return status >= 500;
+  }
+  parseRetryAfterMs(retryAfter) {
+    if (!retryAfter) return null;
+    const seconds = Number(retryAfter);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+    const retryAt = Date.parse(retryAfter);
+    if (Number.isNaN(retryAt)) return null;
+    return Math.max(0, retryAt - Date.now());
+  }
+  async waitBeforeRetry(attempt, retryAfter) {
+    let delayMs = this.computeBackoff(attempt);
+    const retryAfterMs = this.parseRetryAfterMs(retryAfter);
+    if (retryAfterMs != null) delayMs = Math.max(delayMs, retryAfterMs);
+    await this.delay(delayMs);
+  }
+  shouldRetry(error, attempt, retriesOverride) {
+    const maxRetries = retriesOverride ?? this.options.retries;
+    return attempt < maxRetries && this.isRetryable(error);
+  }
+};
+
+// src/client.ts
 var ServiceTitanClient = class {
   constructor(opts = {}) {
     this.token = null;
@@ -16,6 +133,8 @@ var ServiceTitanClient = class {
     const env = opts.environment || process.env.ENVIRONMENT || "production";
     const authUrl = opts.authUrl || (env === "production" ? "https://auth.servicetitan.io/connect/token" : "https://auth-integration.servicetitan.io/connect/token");
     const apiBaseUrl = opts.apiBaseUrl || (env === "production" ? "https://api.servicetitan.io" : "https://api-integration.servicetitan.io");
+    const apiRateLimitPerSecond = this.normalizeApiRateLimit(opts.apiRateLimitPerSecond);
+    const reportingRunsPerMinute = this.normalizePositiveRateLimit(opts.reportingRunsPerMinute, 5);
     const defaults = {
       tenantId: opts.tenantId || process.env.TENANT_ID || "",
       appKey: opts.appKey || process.env.APP_KEY || "",
@@ -27,17 +146,25 @@ var ServiceTitanClient = class {
       timeoutMs: opts.timeoutMs ?? 3e4,
       retries: opts.retries ?? 3,
       retryInitialDelayMs: opts.retryInitialDelayMs ?? 1e3,
-      maxConcurrent: opts.maxConcurrent ?? 5,
-      minTimeMs: opts.minTimeMs ?? 100,
+      apiRateLimitPerSecond,
+      reportingRunsPerMinute,
+      maxConcurrent: opts.maxConcurrent ?? 20,
+      minTimeMs: opts.minTimeMs ?? 0,
       logger: opts.logger || console
     };
     if (!defaults.tenantId || !defaults.appKey || !defaults.clientId || !defaults.clientSecret) {
       throw new Error("Missing required configuration: TENANT_ID, APP_KEY, CLIENT_ID, SECRET_KEY");
     }
     this.options = defaults;
-    this.limiter = new Bottleneck({
+    this.rateLimitManager = new RateLimitManager({
+      apiRateLimitPerSecond: this.options.apiRateLimitPerSecond,
+      reportingRunsPerMinute: this.options.reportingRunsPerMinute,
       maxConcurrent: this.options.maxConcurrent,
-      minTime: this.options.minTimeMs
+      minTimeMs: this.options.minTimeMs
+    });
+    this.retryPolicy = new RetryPolicy({
+      retries: this.options.retries,
+      retryInitialDelayMs: this.options.retryInitialDelayMs
     });
     this.axiosInstance = axios.create({
       baseURL: this.options.apiBaseUrl,
@@ -68,6 +195,16 @@ var ServiceTitanClient = class {
       }
     );
   }
+  normalizeApiRateLimit(value) {
+    if (value == null) return 45;
+    if (!Number.isFinite(value)) return 45;
+    return Math.max(1, Math.min(55, Math.floor(value)));
+  }
+  normalizePositiveRateLimit(value, fallback) {
+    if (value == null) return fallback;
+    if (!Number.isFinite(value)) return fallback;
+    return Math.max(1, Math.floor(value));
+  }
   async refreshToken() {
     if (this.refreshing) return this.refreshing;
     this.refreshing = (async () => {
@@ -100,24 +237,13 @@ var ServiceTitanClient = class {
       throw err;
     }
   }
-  async delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  computeBackoff(base, attempt) {
-    const exp = base * Math.pow(2, attempt);
-    const jitter = Math.random() * base;
-    return Math.min(3e4, exp + jitter);
-  }
-  isRetryable(error) {
-    if (!error) return true;
-    const status = error.response?.status;
-    if (!status) return true;
-    if (status === 429) return true;
-    if (status >= 500) return true;
-    return false;
-  }
-  async schedule(fn) {
-    return this.limiter.schedule(fn);
+  async schedule(method, endpoint, fn) {
+    const context = createRequestContext({
+      method,
+      endpoint,
+      defaultTenantId: this.options.tenantId
+    });
+    return this.rateLimitManager.schedule(context, fn);
   }
   async request(method, endpoint, options = {}) {
     await this.authenticate();
@@ -126,23 +252,17 @@ var ServiceTitanClient = class {
     let attempt = 0;
     while (true) {
       try {
-        const result = await this.schedule(async () => {
+        const result = await this.schedule(method, endpoint, async () => {
           const resp = await this.axiosInstance.request({ method, url: endpoint, params, data, headers, responseType });
           return resp.data;
         });
         return result;
       } catch (error) {
         this.options.logger.warn?.("ServiceTitan API error", error.response?.status, error.response?.data || error.message);
-        if (attempt >= maxRetries || !this.isRetryable(error)) {
+        if (!this.retryPolicy.shouldRetry(error, attempt, maxRetries)) {
           throw error.response?.data || error;
         }
-        let delayMs = this.computeBackoff(this.options.retryInitialDelayMs, attempt);
-        const retryAfter = error.response?.headers?.["retry-after"];
-        if (retryAfter) {
-          const parsed = Number(retryAfter);
-          if (!Number.isNaN(parsed)) delayMs = Math.max(delayMs, parsed * 1e3);
-        }
-        await this.delay(delayMs);
+        await this.retryPolicy.waitBeforeRetry(attempt, error.response?.headers?.["retry-after"]);
         attempt += 1;
       }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@masonlandcattle/servicetitan-sdk",
   "author": "Mason Land & Cattle (https://github.com/MasonLandCattle)",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "ServiceTitan API SDK for Node.js and TypeScript with retries, rate limiting, pagination, and broad tenant API coverage.",
   "keywords": [
     "servicetitan",