@renseiai/agentfactory-linear 0.8.0

package/dist/src/proxy-client.js

@@ -0,0 +1,191 @@
+/**
+ * Proxy Issue Tracker Client
+ *
+ * Drop-in replacement for LinearAgentClient that routes all calls
+ * through the centralized dashboard proxy endpoint instead of calling
+ * the issue tracker API directly.
+ *
+ * Used when `AGENTFACTORY_API_URL` env var is set.
+ *
+ * Benefits:
+ * - Zero direct API credentials needed on the agent side
+ * - Single shared rate limiter and circuit breaker on the proxy
+ * - OAuth token resolution stays server-side
+ * - Platform-agnostic: agents don't need to know Linear exists
+ */
+/**
+ * Issue tracker client that proxies all calls through the dashboard server.
+ *
+ * Implements the same public interface as LinearAgentClient but serializes
+ * calls as JSON and sends them to POST /api/issue-tracker-proxy.
+ *
+ * All returned objects are plain JSON (no lazy-loaded SDK relations).
+ */
+export class ProxyIssueTrackerClient {
+    apiUrl;
+    apiKey;
+    organizationId;
+    timeoutMs;
+    constructor(config) {
+        this.apiUrl = config.apiUrl.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+        this.organizationId = config.organizationId;
+        this.timeoutMs = config.timeoutMs ?? 30_000;
+    }
+    // =========================================================================
+    // Issue operations
+    // =========================================================================
+    async getIssue(issueIdOrIdentifier) {
+        return this.call('getIssue', [issueIdOrIdentifier]);
+    }
+    async updateIssue(issueId, data) {
+        return this.call('updateIssue', [issueId, data]);
+    }
+    async createIssue(input) {
+        return this.call('createIssue', [input]);
+    }
+    async unassignIssue(issueId) {
+        return this.call('unassignIssue', [issueId]);
+    }
+    // =========================================================================
+    // Status operations
+    // =========================================================================
+    async getTeamStatuses(teamId) {
+        return this.call('getTeamStatuses', [teamId]);
+    }
+    async updateIssueStatus(issueId, statusName) {
+        return this.call('updateIssueStatus', [issueId, statusName]);
+    }
+    // =========================================================================
+    // Comment operations
+    // =========================================================================
+    async createComment(issueId, body) {
+        return this.call('createComment', [issueId, body]);
+    }
+    async getIssueComments(issueId) {
+        return this.call('getIssueComments', [issueId]);
+    }
+    // =========================================================================
+    // Agent session operations
+    // =========================================================================
+    async createAgentActivity(input) {
+        return this.call('createAgentActivity', [input]);
+    }
+    async updateAgentSession(input) {
+        return this.call('updateAgentSession', [input]);
+    }
+    async createAgentSessionOnIssue(input) {
+        return this.call('createAgentSessionOnIssue', [input]);
+    }
+    // =========================================================================
+    // Relation operations
+    // =========================================================================
+    async createIssueRelation(input) {
+        return this.call('createIssueRelation', [input]);
+    }
+    async getIssueRelations(issueId) {
+        return this.call('getIssueRelations', [issueId]);
+    }
+    async deleteIssueRelation(relationId) {
+        return this.call('deleteIssueRelation', [relationId]);
+    }
+    // =========================================================================
+    // Sub-issue operations
+    // =========================================================================
+    async getSubIssues(issueIdOrIdentifier) {
+        return this.call('getSubIssues', [issueIdOrIdentifier]);
+    }
+    async getSubIssueStatuses(issueIdOrIdentifier) {
+        return this.call('getSubIssueStatuses', [issueIdOrIdentifier]);
+    }
+    async getSubIssueGraph(issueIdOrIdentifier) {
+        return this.call('getSubIssueGraph', [issueIdOrIdentifier]);
+    }
+    async isParentIssue(issueIdOrIdentifier) {
+        return this.call('isParentIssue', [issueIdOrIdentifier]);
+    }
+    async isChildIssue(issueIdOrIdentifier) {
+        return this.call('isChildIssue', [issueIdOrIdentifier]);
+    }
+    // =========================================================================
+    // Project operations
+    // =========================================================================
+    async listProjectIssues(project) {
+        return this.call('listProjectIssues', [project]);
+    }
+    async getProjectRepositoryUrl(projectId) {
+        return this.call('getProjectRepositoryUrl', [projectId]);
+    }
+    // =========================================================================
+    // Identity operations
+    // =========================================================================
+    async getViewer() {
+        return this.call('getViewer', []);
+    }
+    async getTeam(teamIdOrKey) {
+        return this.call('getTeam', [teamIdOrKey]);
+    }
+    // =========================================================================
+    // Core RPC method
+    // =========================================================================
+    async call(method, args) {
+        const body = {
+            method,
+            args,
+            organizationId: this.organizationId,
+        };
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(`${this.apiUrl}/api/issue-tracker-proxy`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const result = (await response.json());
+            if (!result.success) {
+                const error = result.error ?? { code: 'UNKNOWN', message: 'Unknown error', retryable: false };
+                const err = new Error(`[ProxyClient] ${error.code}: ${error.message}`);
+                err.code = error.code;
+                err.retryable = error.retryable;
+                err.status = response.status;
+                throw err;
+            }
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`[ProxyClient] Request timeout after ${this.timeoutMs}ms for ${method}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+/**
+ * Create a proxy client if AGENTFACTORY_API_URL is set, otherwise return null.
+ *
+ * @param fallbackApiKey - API key to use (default: WORKER_API_KEY env var)
+ * @param organizationId - Workspace ID for multi-tenant routing
+ */
+export function createProxyClientIfConfigured(fallbackApiKey, organizationId) {
+    const apiUrl = process.env.AGENTFACTORY_API_URL;
+    if (!apiUrl)
+        return null;
+    const apiKey = fallbackApiKey ?? process.env.WORKER_API_KEY;
+    if (!apiKey) {
+        console.warn('[ProxyClient] AGENTFACTORY_API_URL set but no WORKER_API_KEY — proxy disabled');
+        return null;
+    }
+    return new ProxyIssueTrackerClient({
+        apiUrl,
+        apiKey,
+        organizationId,
+    });
+}

package/dist/src/rate-limiter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Token Bucket Rate Limiter
+ *
+ * Proactive rate limiting for Linear API calls. Uses a token bucket algorithm
+ * to throttle requests below Linear's ~100 req/min limit.
+ *
+ * Default: 80 burst capacity, 1.5 tokens/sec refill (~90 req/min sustained).
+ */
+export interface TokenBucketConfig {
+    /** Maximum tokens (burst capacity). Default: 80 */
+    maxTokens: number;
+    /** Tokens added per second. Default: 1.5 (~90/min) */
+    refillRate: number;
+}
+export declare const DEFAULT_RATE_LIMIT_CONFIG: TokenBucketConfig;
+export declare class TokenBucket {
+    private tokens;
+    private readonly maxTokens;
+    private readonly refillRate;
+    private lastRefill;
+    private waitQueue;
+    constructor(config?: Partial<TokenBucketConfig>);
+    /** Refill tokens based on elapsed time since last refill. */
+    private refill;
+    /** Drain waiters that can be satisfied after a refill. */
+    private drainWaiters;
+    /**
+     * Acquire a single token. Resolves immediately if tokens are available,
+     * otherwise queues the caller until a token becomes available via refill.
+     */
+    acquire(): Promise<void>;
+    /** Schedule a timer to refill and drain waiters. */
+    private refillTimer;
+    private scheduleRefillDrain;
+    /**
+     * Penalize the bucket after receiving a 429 rate limit response.
+     *
+     * Drains all tokens to 0 and shifts the refill baseline forward by
+     * `seconds` so no new tokens appear until the penalty expires.
+     * Any already-queued waiters will wait for the penalty period plus
+     * normal refill time.
+     *
+     * @param seconds - How long to pause before tokens start refilling (from Retry-After header)
+     */
+    penalize(seconds: number): void;
+    /** Current number of available tokens (for testing/monitoring). */
+    get availableTokens(): number;
+    /** Number of callers waiting for tokens (for testing/monitoring). */
+    get pendingCount(): number;
+}
+/**
+ * Extract a Retry-After delay (in milliseconds) from an error thrown by
+ * the Linear SDK or a raw HTTP 429 response.
+ *
+ * Checks (in order):
+ * 1. `error.response.headers.get('retry-after')` (fetch Response)
+ * 2. `error.response.headers['retry-after']` (plain object headers)
+ * 3. `error.headers?.['retry-after']` (error-level headers)
+ *
+ * The Retry-After value is parsed as seconds (integer). If no valid value
+ * is found, returns `null`.
+ */
+export declare function extractRetryAfterMs(error: unknown): number | null;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/src/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,eAAO,MAAM,yBAAyB,EAAE,iBAGvC,CAAA;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,SAAS,CAAwB;gBAE7B,MAAM,GAAE,OAAO,CAAC,iBAAiB,CAAM;IAQnD,6DAA6D;IAC7D,OAAO,CAAC,MAAM;IAad,0DAA0D;IAC1D,OAAO,CAAC,YAAY;IAQpB;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAc9B,oDAAoD;IACpD,OAAO,CAAC,WAAW,CAA6C;IAEhE,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO/B,mEAAmE;IACnE,IAAI,eAAe,IAAI,MAAM,CAG5B;IAED,qEAAqE;IACrE,IAAI,YAAY,IAAI,MAAM,CAEzB;CACF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAwBjE"}

package/dist/src/rate-limiter.js

@@ -0,0 +1,163 @@
+/**
+ * Token Bucket Rate Limiter
+ *
+ * Proactive rate limiting for Linear API calls. Uses a token bucket algorithm
+ * to throttle requests below Linear's ~100 req/min limit.
+ *
+ * Default: 80 burst capacity, 1.5 tokens/sec refill (~90 req/min sustained).
+ */
+export const DEFAULT_RATE_LIMIT_CONFIG = {
+    maxTokens: 80,
+    refillRate: 1.5,
+};
+export class TokenBucket {
+    tokens;
+    maxTokens;
+    refillRate;
+    lastRefill;
+    waitQueue = [];
+    constructor(config = {}) {
+        const resolved = { ...DEFAULT_RATE_LIMIT_CONFIG, ...config };
+        this.maxTokens = resolved.maxTokens;
+        this.refillRate = resolved.refillRate;
+        this.tokens = this.maxTokens;
+        this.lastRefill = Date.now();
+    }
+    /** Refill tokens based on elapsed time since last refill. */
+    refill() {
+        const now = Date.now();
+        const elapsed = (now - this.lastRefill) / 1000;
+        // During a penalty period, lastRefill is in the future so elapsed is negative.
+        // Skip refill entirely until the penalty expires.
+        if (elapsed <= 0)
+            return;
+        const newTokens = elapsed * this.refillRate;
+        this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
+        this.lastRefill = now;
+    }
+    /** Drain waiters that can be satisfied after a refill. */
+    drainWaiters() {
+        while (this.waitQueue.length > 0 && this.tokens >= 1) {
+            this.tokens -= 1;
+            const resolve = this.waitQueue.shift();
+            resolve();
+        }
+    }
+    /**
+     * Acquire a single token. Resolves immediately if tokens are available,
+     * otherwise queues the caller until a token becomes available via refill.
+     */
+    async acquire() {
+        this.refill();
+        if (this.tokens >= 1 && this.waitQueue.length === 0) {
+            this.tokens -= 1;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waitQueue.push(resolve);
+            this.scheduleRefillDrain();
+        });
+    }
+    /** Schedule a timer to refill and drain waiters. */
+    refillTimer = null;
+    scheduleRefillDrain() {
+        if (this.refillTimer !== null)
+            return;
+        // Time until 1 token is available
+        const msPerToken = 1000 / this.refillRate;
+        this.refillTimer = setTimeout(() => {
+            this.refillTimer = null;
+            this.refill();
+            this.drainWaiters();
+            // If there are still waiters, schedule again
+            if (this.waitQueue.length > 0) {
+                this.scheduleRefillDrain();
+            }
+        }, msPerToken);
+    }
+    /**
+     * Penalize the bucket after receiving a 429 rate limit response.
+     *
+     * Drains all tokens to 0 and shifts the refill baseline forward by
+     * `seconds` so no new tokens appear until the penalty expires.
+     * Any already-queued waiters will wait for the penalty period plus
+     * normal refill time.
+     *
+     * @param seconds - How long to pause before tokens start refilling (from Retry-After header)
+     */
+    penalize(seconds) {
+        this.tokens = 0;
+        // Push lastRefill into the future so refill() computes negative elapsed
+        // time until the penalty expires, effectively freezing token generation.
+        this.lastRefill = Date.now() + seconds * 1000;
+    }
+    /** Current number of available tokens (for testing/monitoring). */
+    get availableTokens() {
+        this.refill();
+        return Math.floor(this.tokens);
+    }
+    /** Number of callers waiting for tokens (for testing/monitoring). */
+    get pendingCount() {
+        return this.waitQueue.length;
+    }
+}
+/**
+ * Extract a Retry-After delay (in milliseconds) from an error thrown by
+ * the Linear SDK or a raw HTTP 429 response.
+ *
+ * Checks (in order):
+ * 1. `error.response.headers.get('retry-after')` (fetch Response)
+ * 2. `error.response.headers['retry-after']` (plain object headers)
+ * 3. `error.headers?.['retry-after']` (error-level headers)
+ *
+ * The Retry-After value is parsed as seconds (integer). If no valid value
+ * is found, returns `null`.
+ */
+export function extractRetryAfterMs(error) {
+    if (typeof error !== 'object' || error === null)
+        return null;
+    const err = error;
+    // Check if this is a rate limit error (status 429)
+    const status = err.status ??
+        err.statusCode ??
+        err.response?.status;
+    if (status !== 429)
+        return null;
+    // Try to extract Retry-After from various locations
+    const headerValue = getRetryAfterHeader(err);
+    if (headerValue === null) {
+        // No Retry-After header — use a sensible default of 60s for Linear
+        return 60_000;
+    }
+    const seconds = parseInt(headerValue, 10);
+    if (Number.isNaN(seconds) || seconds <= 0)
+        return 60_000;
+    return seconds * 1000;
+}
+function getRetryAfterHeader(err) {
+    // error.response.headers.get('retry-after') — fetch-style Response
+    const response = err.response;
+    if (response) {
+        const headers = response.headers;
+        if (headers) {
+            // Headers object with .get() method (fetch API)
+            if (typeof headers.get === 'function') {
+                const val = headers.get('retry-after');
+                if (val)
+                    return val;
+            }
+            // Plain object headers
+            const val = headers['retry-after'];
+            if (val)
+                return val;
+        }
+    }
+    // error.headers['retry-after']
+    const errorHeaders = err.headers;
+    if (errorHeaders) {
+        const val = errorHeaders['retry-after'];
+        if (val)
+            return val;
+    }
+    return null;
+}

package/dist/src/rate-limiter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rate-limiter.test.d.ts.map

package/dist/src/rate-limiter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.test.d.ts","sourceRoot":"","sources":["../../src/rate-limiter.test.ts"],"names":[],"mappings":""}

package/dist/src/rate-limiter.test.js

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { TokenBucket, DEFAULT_RATE_LIMIT_CONFIG, extractRetryAfterMs } from './rate-limiter.js';
+describe('TokenBucket', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    // ========================================================================
+    // Construction & defaults
+    // ========================================================================
+    it('uses default config when none provided', () => {
+        const bucket = new TokenBucket();
+        expect(bucket.availableTokens).toBe(DEFAULT_RATE_LIMIT_CONFIG.maxTokens);
+    });
+    it('accepts custom config', () => {
+        const bucket = new TokenBucket({ maxTokens: 10, refillRate: 5 });
+        expect(bucket.availableTokens).toBe(10);
+    });
+    it('allows partial config overrides', () => {
+        const bucket = new TokenBucket({ maxTokens: 20 });
+        expect(bucket.availableTokens).toBe(20);
+    });
+    // ========================================================================
+    // Token acquisition
+    // ========================================================================
+    it('resolves immediately when tokens are available', async () => {
+        const bucket = new TokenBucket({ maxTokens: 5, refillRate: 1 });
+        await bucket.acquire();
+        expect(bucket.availableTokens).toBe(4);
+    });
+    it('depletes tokens with multiple acquires', async () => {
+        const bucket = new TokenBucket({ maxTokens: 3, refillRate: 1 });
+        await bucket.acquire();
+        await bucket.acquire();
+        await bucket.acquire();
+        expect(bucket.availableTokens).toBe(0);
+    });
+    // ========================================================================
+    // Waiting when depleted
+    // ========================================================================
+    it('queues callers when tokens are exhausted', async () => {
+        const bucket = new TokenBucket({ maxTokens: 1, refillRate: 1 });
+        // Use up the only token
+        await bucket.acquire();
+        expect(bucket.availableTokens).toBe(0);
+        // This should not resolve immediately
+        let resolved = false;
+        const promise = bucket.acquire().then(() => {
+            resolved = true;
+        });
+        // Give microtasks a chance to run
+        await vi.advanceTimersByTimeAsync(0);
+        expect(resolved).toBe(false);
+        expect(bucket.pendingCount).toBe(1);
+        // Advance time so a token refills (1 token/sec => 1000ms for 1 token)
+        await vi.advanceTimersByTimeAsync(1000);
+        await promise;
+        expect(resolved).toBe(true);
+        expect(bucket.pendingCount).toBe(0);
+    });
+    it('drains multiple waiters as tokens refill', async () => {
+        const bucket = new TokenBucket({ maxTokens: 1, refillRate: 2 }); // 2 tokens/sec
+        await bucket.acquire();
+        const results = [];
+        const p1 = bucket.acquire().then(() => results.push(1));
+        const p2 = bucket.acquire().then(() => results.push(2));
+        expect(bucket.pendingCount).toBe(2);
+        // At 2 tokens/sec, each token takes 500ms
+        // First timer fires at 500ms, drains waiter 1, schedules next
+        await vi.advanceTimersByTimeAsync(500);
+        await Promise.resolve(); // let microtasks run
+        expect(results).toEqual([1]);
+        // Second timer fires at 1000ms total
+        await vi.advanceTimersByTimeAsync(500);
+        await Promise.resolve();
+        expect(results).toEqual([1, 2]);
+        await Promise.all([p1, p2]);
+        expect(bucket.pendingCount).toBe(0);
+    });
+    // ========================================================================
+    // Refill behavior
+    // ========================================================================
+    it('refills tokens over time', async () => {
+        const bucket = new TokenBucket({ maxTokens: 10, refillRate: 5 });
+        // Drain 5 tokens
+        for (let i = 0; i < 5; i++) {
+            await bucket.acquire();
+        }
+        expect(bucket.availableTokens).toBe(5);
+        // Advance 1 second => 5 new tokens refilled
+        vi.advanceTimersByTime(1000);
+        expect(bucket.availableTokens).toBe(10);
+    });
+    it('does not exceed maxTokens on refill', async () => {
+        const bucket = new TokenBucket({ maxTokens: 10, refillRate: 100 });
+        // Even after a long time, tokens should not exceed max
+        vi.advanceTimersByTime(10_000);
+        expect(bucket.availableTokens).toBe(10);
+    });
+    // ========================================================================
+    // penalize
+    // ========================================================================
+    it('penalize drains tokens to 0', () => {
+        const bucket = new TokenBucket({ maxTokens: 10, refillRate: 5 });
+        expect(bucket.availableTokens).toBe(10);
+        bucket.penalize(5);
+        expect(bucket.availableTokens).toBe(0);
+    });
+    it('penalize freezes token generation for the penalty period', () => {
+        const bucket = new TokenBucket({ maxTokens: 10, refillRate: 10 });
+        bucket.penalize(3); // 3 second penalty
+        // After 2 seconds (still within penalty), no tokens should be available
+        vi.advanceTimersByTime(2000);
+        expect(bucket.availableTokens).toBe(0);
+        // After 3 seconds total (penalty expired), refill should resume
+        vi.advanceTimersByTime(1000);
+        // Now tokens start refilling from 0 at 10/sec, but elapsed since penalty end is ~0
+        expect(bucket.availableTokens).toBe(0);
+        // After 4 seconds total (1 second of refill after penalty), 10 tokens
+        vi.advanceTimersByTime(1000);
+        expect(bucket.availableTokens).toBe(10);
+    });
+    // ========================================================================
+    // DEFAULT_RATE_LIMIT_CONFIG
+    // ========================================================================
+    it('exports sensible defaults', () => {
+        expect(DEFAULT_RATE_LIMIT_CONFIG.maxTokens).toBe(80);
+        expect(DEFAULT_RATE_LIMIT_CONFIG.refillRate).toBe(1.5);
+    });
+});
+// ===========================================================================
+// extractRetryAfterMs
+// ===========================================================================
+describe('extractRetryAfterMs', () => {
+    it('returns null for non-object errors', () => {
+        expect(extractRetryAfterMs(null)).toBeNull();
+        expect(extractRetryAfterMs(undefined)).toBeNull();
+        expect(extractRetryAfterMs('string')).toBeNull();
+        expect(extractRetryAfterMs(42)).toBeNull();
+    });
+    it('returns null for non-429 errors', () => {
+        expect(extractRetryAfterMs({ status: 500 })).toBeNull();
+        expect(extractRetryAfterMs({ statusCode: 400 })).toBeNull();
+        expect(extractRetryAfterMs({ response: { status: 200 } })).toBeNull();
+    });
+    it('returns 60s default when 429 but no Retry-After header', () => {
+        expect(extractRetryAfterMs({ status: 429 })).toBe(60_000);
+    });
+    it('parses Retry-After from response.headers plain object', () => {
+        const error = {
+            status: 429,
+            response: {
+                status: 429,
+                headers: { 'retry-after': '30' },
+            },
+        };
+        expect(extractRetryAfterMs(error)).toBe(30_000);
+    });
+    it('parses Retry-After from response.headers.get() (fetch-style)', () => {
+        const headers = new Map([['retry-after', '45']]);
+        const error = {
+            status: 429,
+            response: {
+                status: 429,
+                headers: {
+                    get: (name) => headers.get(name) ?? null,
+                },
+            },
+        };
+        expect(extractRetryAfterMs(error)).toBe(45_000);
+    });
+    it('parses Retry-After from error.headers', () => {
+        const error = {
+            status: 429,
+            headers: { 'retry-after': '10' },
+        };
+        expect(extractRetryAfterMs(error)).toBe(10_000);
+    });
+    it('detects 429 from response.status when top-level status is missing', () => {
+        const error = {
+            response: {
+                status: 429,
+                headers: { 'retry-after': '20' },
+            },
+        };
+        expect(extractRetryAfterMs(error)).toBe(20_000);
+    });
+    it('detects 429 from statusCode property', () => {
+        const error = {
+            statusCode: 429,
+            headers: { 'retry-after': '15' },
+        };
+        expect(extractRetryAfterMs(error)).toBe(15_000);
+    });
+    it('falls back to 60s for invalid Retry-After value', () => {
+        const error = {
+            status: 429,
+            response: {
+                status: 429,
+                headers: { 'retry-after': 'not-a-number' },
+            },
+        };
+        expect(extractRetryAfterMs(error)).toBe(60_000);
+    });
+    it('falls back to 60s for zero Retry-After', () => {
+        const error = {
+            status: 429,
+            response: {
+                status: 429,
+                headers: { 'retry-after': '0' },
+            },
+        };
+        expect(extractRetryAfterMs(error)).toBe(60_000);
+    });
+});