@limitry/sdk 0.0.0-stage → 1.0.0-rc.1

package/dist/resources.gen.d.ts

@@ -0,0 +1,400 @@
+import { type Input, type RawClient, type RequestOptions } from "./resources.ts";
+/** The resource methods for a client (./resources.ts). */
+export declare function resources(client: RawClient): {
+    checks: {
+        create: (input: Input<"/checks", "post">, options?: RequestOptions) => Promise<{
+            allowed: boolean;
+            id: string;
+            reason: {
+                code: "limit_exceeded" | "too_many_reservations";
+                limit: string | null;
+            } | null;
+            remaining: import("./v1.gen.ts").components["schemas"]["CheckRemaining"][];
+            reservation?: {
+                expiresAt: string;
+                id: string;
+            };
+            retryAfterSeconds: number | null;
+        }>;
+    };
+    limits: {
+        archive: (limitId: string | number, options?: RequestOptions) => Promise<undefined>;
+        create: (input: Input<"/limits", "post">, options?: RequestOptions) => Promise<{
+            action: string;
+            amount: number;
+            archivedAt: string | null;
+            createdAt: string;
+            enabled: boolean;
+            every: number;
+            failMode: "open" | "closed";
+            id: string;
+            name: string;
+            rolling: boolean;
+            start: "calendar" | "anchor" | "first_use";
+            subject: import("./v1.gen.ts").components["schemas"]["LimitSubject"];
+            unit: string;
+            updatedAt: string;
+            version: number;
+            window: "minute" | "hour" | "day" | "week" | "month" | "year" | "total" | "concurrent";
+        }>;
+        get: (limitId: string | number, options?: RequestOptions) => Promise<{
+            action: string;
+            amount: number;
+            archivedAt: string | null;
+            createdAt: string;
+            enabled: boolean;
+            every: number;
+            failMode: "open" | "closed";
+            id: string;
+            name: string;
+            rolling: boolean;
+            start: "calendar" | "anchor" | "first_use";
+            subject: import("./v1.gen.ts").components["schemas"]["LimitSubject"];
+            unit: string;
+            updatedAt: string;
+            version: number;
+            window: "minute" | "hour" | "day" | "week" | "month" | "year" | "total" | "concurrent";
+        }>;
+        grants: {
+            create: (limitId: string | number, input: Input<"/limits/{limitId}/grants", "post">, options?: RequestOptions) => Promise<{
+                amount: number;
+                createdAt: string;
+                createdByUserId: string | null;
+                id: string;
+                limitId: string;
+                note: string;
+                subject: {
+                    id: string;
+                    kind: string;
+                };
+            }>;
+            list: (limitId: string | number, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["LimitGrant"][];
+            }>;
+        };
+        list: (input?: Input<"/limits", "get">, options?: RequestOptions) => Promise<{
+            items: import("./v1.gen.ts").components["schemas"]["Limit"][];
+            nextCursor: string | null;
+        }>;
+        restore: (limitId: string | number, options?: RequestOptions) => Promise<{
+            action: string;
+            amount: number;
+            archivedAt: string | null;
+            createdAt: string;
+            enabled: boolean;
+            every: number;
+            failMode: "open" | "closed";
+            id: string;
+            name: string;
+            rolling: boolean;
+            start: "calendar" | "anchor" | "first_use";
+            subject: import("./v1.gen.ts").components["schemas"]["LimitSubject"];
+            unit: string;
+            updatedAt: string;
+            version: number;
+            window: "minute" | "hour" | "day" | "week" | "month" | "year" | "total" | "concurrent";
+        }>;
+        sync: (input: Input<"/limits/sync", "post">, options?: RequestOptions) => Promise<{
+            archived: string[];
+            created: string[];
+            dryRun: boolean;
+            unchanged: string[];
+            updated: {
+                changes: {
+                    [key: string]: {
+                        from: string | number | boolean | null;
+                        to: string | number | boolean | null;
+                    };
+                };
+                name: string;
+            }[];
+        }>;
+        update: (limitId: string | number, input?: Input<"/limits/{limitId}", "patch">, options?: RequestOptions) => Promise<{
+            action: string;
+            amount: number;
+            archivedAt: string | null;
+            createdAt: string;
+            enabled: boolean;
+            every: number;
+            failMode: "open" | "closed";
+            id: string;
+            name: string;
+            rolling: boolean;
+            start: "calendar" | "anchor" | "first_use";
+            subject: import("./v1.gen.ts").components["schemas"]["LimitSubject"];
+            unit: string;
+            updatedAt: string;
+            version: number;
+            window: "minute" | "hour" | "day" | "week" | "month" | "year" | "total" | "concurrent";
+        }>;
+    };
+    reservations: {
+        commit: (reservationId: string | number, input: Input<"/reservations/{reservationId}/commit", "post">, options?: RequestOptions) => Promise<{
+            cost: number;
+            expiresAt: string;
+            id: string;
+            reserved: number;
+            status: "held" | "committed" | "released" | "expired";
+        }>;
+        extend: (reservationId: string | number, input?: Input<"/reservations/{reservationId}/extend", "post">, options?: RequestOptions) => Promise<{
+            cost: number;
+            expiresAt: string;
+            id: string;
+            reserved: number;
+            status: "held" | "committed" | "released" | "expired";
+        }>;
+        release: (reservationId: string | number, options?: RequestOptions) => Promise<{
+            cost: number;
+            expiresAt: string;
+            id: string;
+            reserved: number;
+            status: "held" | "committed" | "released" | "expired";
+        }>;
+    };
+    subjects: {
+        get: (subjectKind: string | number, subjectId: string | number, options?: RequestOptions) => Promise<{
+            anchor: string | null;
+            subject: import("./v1.gen.ts").components["schemas"]["SubjectRef"];
+        }>;
+        reset: (subjectKind: string | number, subjectId: string | number, input?: Input<"/subjects/{subjectKind}/{subjectId}/reset", "post">, options?: RequestOptions) => Promise<{
+            reset: string[];
+            subject: import("./v1.gen.ts").components["schemas"]["SubjectRef"];
+        }>;
+        update: (subjectKind: string | number, subjectId: string | number, input: Input<"/subjects/{subjectKind}/{subjectId}", "patch">, options?: RequestOptions) => Promise<{
+            anchor: string | null;
+            subject: import("./v1.gen.ts").components["schemas"]["SubjectRef"];
+        }>;
+    };
+    usage: {
+        query: (input: Input<"/usage", "get">, options?: RequestOptions) => Promise<{
+            granularity: "hour" | "day";
+            limitId: string;
+            points: {
+                allowed: number;
+                denied: number;
+                start: string;
+                used: number;
+            }[];
+        }>;
+        standing: (input: Input<"/usage/standing", "get">, options?: RequestOptions) => Promise<{
+            environment: string;
+            limits: {
+                action: string;
+                amount: number;
+                limit: string;
+                name: string;
+                remaining: number;
+                resetsAt: string | null;
+                rolling: boolean;
+                shared: boolean;
+                subject: {
+                    id: string;
+                    kind: string;
+                };
+                unit: string;
+                used: number;
+                window: "minute" | "hour" | "day" | "week" | "month" | "year" | "total" | "concurrent";
+            }[];
+            subject: {
+                id: string;
+                kind: string;
+            };
+        }>;
+        subjects: (input: Input<"/usage/subjects", "get">, options?: RequestOptions) => Promise<{
+            items: {
+                denied: number;
+                over: boolean;
+                remaining: number;
+                subject: {
+                    id: string;
+                    kind: string;
+                };
+                used: number;
+            }[];
+            limitId: string;
+            windowStart: string;
+        }>;
+    };
+    user: {
+        me: (options?: RequestOptions) => Promise<{
+            email: string;
+            id: string;
+            name: string;
+            workspaces: {
+                id: string;
+                name: string;
+                role: string;
+                slug: string;
+            }[];
+        }>;
+        revokeToken: (options?: RequestOptions) => Promise<undefined>;
+    };
+    workspace: {
+        approvalActions: {
+            list: (options?: RequestOptions) => Promise<{
+                items: {
+                    approverRoles: string[];
+                    createsSecret: boolean;
+                    id: string;
+                    input: {
+                        [key: string]: unknown;
+                    };
+                    title: string;
+                }[];
+            }>;
+        };
+        approvalRequests: {
+            create: (input: Input<"/workspace/approval-requests", "post">, options?: RequestOptions) => Promise<{
+                action: string;
+                approveUrl: string;
+                createdAt: string;
+                decidedAt: string | null;
+                expiresAt: string;
+                id: string;
+                input: {
+                    [key: string]: unknown;
+                };
+                reason: string;
+                requestedBy: string | null;
+                result: {
+                    [key: string]: unknown;
+                } | null;
+                secret: {
+                    envVar: string;
+                    name: string;
+                } | null;
+                status: "pending" | "approved" | "completed" | "denied" | "failed" | "expired";
+                summary: string;
+                title: string;
+            }>;
+            get: (requestId: string | number, options?: RequestOptions) => Promise<{
+                action: string;
+                approveUrl: string;
+                createdAt: string;
+                decidedAt: string | null;
+                expiresAt: string;
+                id: string;
+                input: {
+                    [key: string]: unknown;
+                };
+                reason: string;
+                requestedBy: string | null;
+                result: {
+                    [key: string]: unknown;
+                } | null;
+                secret: {
+                    envVar: string;
+                    name: string;
+                } | null;
+                status: "pending" | "approved" | "completed" | "denied" | "failed" | "expired";
+                summary: string;
+                title: string;
+            }>;
+            redeem: (requestId: string | number, options?: RequestOptions) => Promise<{
+                envVar: string | null;
+                request: import("./v1.gen.ts").components["schemas"]["ApprovalRequest"];
+                secret: string | null;
+            }>;
+        };
+        auditEvents: {
+            list: (input?: Input<"/workspace/audit-events", "get">, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["AuditEvent"][];
+                nextCursor: string | null;
+            }>;
+        };
+        eventTypes: {
+            list: (options?: RequestOptions) => Promise<{
+                items: {
+                    description: string;
+                    type: string;
+                }[];
+            }>;
+        };
+        get: (options?: RequestOptions) => Promise<{
+            id: string;
+            name: string;
+        }>;
+        invitations: {
+            list: (input?: Input<"/workspace/invitations", "get">, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["Invitation"][];
+                nextCursor: string | null;
+            }>;
+        };
+        members: {
+            list: (input?: Input<"/workspace/members", "get">, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["Member"][];
+                nextCursor: string | null;
+            }>;
+        };
+        teams: {
+            list: (input?: Input<"/workspace/teams", "get">, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["Team"][];
+                nextCursor: string | null;
+            }>;
+        };
+        usage: (options?: RequestOptions) => Promise<{
+            meters: {
+                description: string;
+                id: string;
+                limit: number | null;
+                used: number;
+            }[];
+            notices?: string[];
+            periodEnd: string;
+            periodStart: string;
+        }>;
+        webhookDeliveries: {
+            list: (endpointId: string | number, input?: Input<"/workspace/webhook-endpoints/{endpointId}/deliveries", "get">, options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["WebhookDelivery"][];
+                nextCursor: string | null;
+            }>;
+            redeliver: (endpointId: string | number, deliveryId: string | number, options?: RequestOptions) => Promise<{
+                deliveryId: string;
+                ok?: boolean;
+                queued: boolean;
+                status?: number | null;
+            }>;
+        };
+        webhookEndpoints: {
+            create: (input: Input<"/workspace/webhook-endpoints", "post">, options?: RequestOptions) => Promise<{
+                endpoint: import("./v1.gen.ts").components["schemas"]["WebhookEndpoint"];
+                secret: string;
+            }>;
+            delete: (endpointId: string | number, options?: RequestOptions) => Promise<undefined>;
+            enable: (endpointId: string | number, options?: RequestOptions) => Promise<{
+                consecutiveFailures: number;
+                createdAt: string;
+                description: string | null;
+                enabled: boolean;
+                environment: string | null;
+                eventTypes: string[] | null;
+                id: string;
+                lastAttemptAt: string | null;
+                lastStatus: number | null;
+                url: string;
+            }>;
+            get: (endpointId: string | number, options?: RequestOptions) => Promise<{
+                consecutiveFailures: number;
+                createdAt: string;
+                description: string | null;
+                enabled: boolean;
+                environment: string | null;
+                eventTypes: string[] | null;
+                id: string;
+                lastAttemptAt: string | null;
+                lastStatus: number | null;
+                url: string;
+            }>;
+            list: (options?: RequestOptions) => Promise<{
+                items: import("./v1.gen.ts").components["schemas"]["WebhookEndpoint"][];
+                nextCursor: string | null;
+            }>;
+            test: (endpointId: string | number, options?: RequestOptions) => Promise<{
+                deliveryId: string;
+                ok?: boolean;
+                queued: boolean;
+                status?: number | null;
+            }>;
+        };
+    };
+};

package/dist/resources.gen.js

@@ -0,0 +1,83 @@
+// GENERATED from apps/api/src/routes/v1 by `pnpm sdk:generate` — gitignored,
+// regenerated by `pnpm generate` and by this package's typecheck / test /
+// build. Do not edit; do not commit.
+import { call } from "./resources.js";
+/** The resource methods for a client (./resources.ts). */
+export function resources(client) {
+    return {
+        checks: {
+            create: /** Check whether a subject may act */ (input, options) => call(client, { "method": "post", "path": "/checks", "query": [], "hasBody": true }, {}, input, options),
+        },
+        limits: {
+            archive: /** Archive a limit */ (limitId, options) => call(client, { "method": "post", "path": "/limits/{limitId}/archive", "query": [], "hasBody": false }, { "limitId": limitId }, undefined, options),
+            create: /** Create a limit */ (input, options) => call(client, { "method": "post", "path": "/limits", "query": [], "hasBody": true }, {}, input, options),
+            get: /** Get a limit */ (limitId, options) => call(client, { "method": "get", "path": "/limits/{limitId}", "query": [], "hasBody": false }, { "limitId": limitId }, undefined, options),
+            grants: {
+                create: /** Add credits to a balance */ (limitId, input, options) => call(client, { "method": "post", "path": "/limits/{limitId}/grants", "query": [], "hasBody": true }, { "limitId": limitId }, input, options),
+                list: /** List a balance's grants */ (limitId, options) => call(client, { "method": "get", "path": "/limits/{limitId}/grants", "query": [], "hasBody": false }, { "limitId": limitId }, undefined, options),
+            },
+            list: /** List limits */ (input, options) => call(client, { "method": "get", "path": "/limits", "query": ["limit", "cursor", "subjectKind", "action", "archived"], "hasBody": false }, {}, input, options),
+            restore: /** Restore an archived limit */ (limitId, options) => call(client, { "method": "post", "path": "/limits/{limitId}/restore", "query": [], "hasBody": false }, { "limitId": limitId }, undefined, options),
+            sync: /** Sync limits from a list */ (input, options) => call(client, { "method": "post", "path": "/limits/sync", "query": [], "hasBody": true }, {}, input, options),
+            update: /** Change a limit */ (limitId, input, options) => call(client, { "method": "patch", "path": "/limits/{limitId}", "query": [], "hasBody": true }, { "limitId": limitId }, input, options),
+        },
+        reservations: {
+            commit: /** Commit a reservation */ (reservationId, input, options) => call(client, { "method": "post", "path": "/reservations/{reservationId}/commit", "query": [], "hasBody": true }, { "reservationId": reservationId }, input, options),
+            extend: /** Extend a reservation */ (reservationId, input, options) => call(client, { "method": "post", "path": "/reservations/{reservationId}/extend", "query": [], "hasBody": true }, { "reservationId": reservationId }, input, options),
+            release: /** Release a reservation */ (reservationId, options) => call(client, { "method": "post", "path": "/reservations/{reservationId}/release", "query": [], "hasBody": false }, { "reservationId": reservationId }, undefined, options),
+        },
+        subjects: {
+            get: /** Get a subject */ (subjectKind, subjectId, options) => call(client, { "method": "get", "path": "/subjects/{subjectKind}/{subjectId}", "query": [], "hasBody": false }, { "subjectKind": subjectKind, "subjectId": subjectId }, undefined, options),
+            reset: /** Reset a subject's limits */ (subjectKind, subjectId, input, options) => call(client, { "method": "post", "path": "/subjects/{subjectKind}/{subjectId}/reset", "query": [], "hasBody": true }, { "subjectKind": subjectKind, "subjectId": subjectId }, input, options),
+            update: /** Set a subject's anchor */ (subjectKind, subjectId, input, options) => call(client, { "method": "patch", "path": "/subjects/{subjectKind}/{subjectId}", "query": [], "hasBody": true }, { "subjectKind": subjectKind, "subjectId": subjectId }, input, options),
+        },
+        usage: {
+            query: /** Get a limit's usage over time */ (input, options) => call(client, { "method": "get", "path": "/usage", "query": ["limitId", "subjectKind", "subjectId", "from", "to", "granularity"], "hasBody": false }, {}, input, options),
+            standing: /** Get where a subject stands */ (input, options) => call(client, { "method": "get", "path": "/usage/standing", "query": ["kind", "id", "shared"], "hasBody": false }, {}, input, options),
+            subjects: /** List who is using a limit now */ (input, options) => call(client, { "method": "get", "path": "/usage/subjects", "query": ["limitId", "limit"], "hasBody": false }, {}, input, options),
+        },
+        user: {
+            me: /** Get the current user */ (options) => call(client, { "method": "get", "path": "/user/me", "query": [], "hasBody": false }, {}, undefined, options),
+            revokeToken: /** Revoke the token making this request */ (options) => call(client, { "method": "delete", "path": "/user/token", "query": [], "hasBody": false }, {}, undefined, options),
+        },
+        workspace: {
+            approvalActions: {
+                list: /** List the actions you can ask approval for */ (options) => call(client, { "method": "get", "path": "/workspace/approval-actions", "query": [], "hasBody": false }, {}, undefined, options),
+            },
+            approvalRequests: {
+                create: /** Ask a person to approve an action */ (input, options) => call(client, { "method": "post", "path": "/workspace/approval-requests", "query": [], "hasBody": true }, {}, input, options),
+                get: /** Check an approval request */ (requestId, options) => call(client, { "method": "get", "path": "/workspace/approval-requests/{requestId}", "query": [], "hasBody": false }, { "requestId": requestId }, undefined, options),
+                redeem: /** Redeem an approved request */ (requestId, options) => call(client, { "method": "post", "path": "/workspace/approval-requests/{requestId}/redeem", "query": [], "hasBody": false }, { "requestId": requestId }, undefined, options),
+            },
+            auditEvents: {
+                list: /** List workspace audit events */ (input, options) => call(client, { "method": "get", "path": "/workspace/audit-events", "query": ["limit", "cursor"], "hasBody": false }, {}, input, options),
+            },
+            eventTypes: {
+                list: /** List event types */ (options) => call(client, { "method": "get", "path": "/workspace/event-types", "query": [], "hasBody": false }, {}, undefined, options),
+            },
+            get: /** Get the current workspace */ (options) => call(client, { "method": "get", "path": "/workspace", "query": [], "hasBody": false }, {}, undefined, options),
+            invitations: {
+                list: /** List pending invitations */ (input, options) => call(client, { "method": "get", "path": "/workspace/invitations", "query": ["limit", "cursor"], "hasBody": false }, {}, input, options),
+            },
+            members: {
+                list: /** List workspace members */ (input, options) => call(client, { "method": "get", "path": "/workspace/members", "query": ["limit", "cursor"], "hasBody": false }, {}, input, options),
+            },
+            teams: {
+                list: /** List teams */ (input, options) => call(client, { "method": "get", "path": "/workspace/teams", "query": ["limit", "cursor"], "hasBody": false }, {}, input, options),
+            },
+            usage: /** Get your plan's usage this period */ (options) => call(client, { "method": "get", "path": "/workspace/usage", "query": [], "hasBody": false }, {}, undefined, options),
+            webhookDeliveries: {
+                list: /** List an endpoint's deliveries */ (endpointId, input, options) => call(client, { "method": "get", "path": "/workspace/webhook-endpoints/{endpointId}/deliveries", "query": ["limit", "cursor"], "hasBody": false }, { "endpointId": endpointId }, input, options),
+                redeliver: /** Redeliver an event */ (endpointId, deliveryId, options) => call(client, { "method": "post", "path": "/workspace/webhook-endpoints/{endpointId}/deliveries/{deliveryId}/redeliver", "query": [], "hasBody": false }, { "endpointId": endpointId, "deliveryId": deliveryId }, undefined, options),
+            },
+            webhookEndpoints: {
+                create: /** Add a webhook endpoint */ (input, options) => call(client, { "method": "post", "path": "/workspace/webhook-endpoints", "query": [], "hasBody": true }, {}, input, options),
+                delete: /** Remove a webhook endpoint */ (endpointId, options) => call(client, { "method": "delete", "path": "/workspace/webhook-endpoints/{endpointId}", "query": [], "hasBody": false }, { "endpointId": endpointId }, undefined, options),
+                enable: /** Re-enable a webhook endpoint */ (endpointId, options) => call(client, { "method": "post", "path": "/workspace/webhook-endpoints/{endpointId}/enable", "query": [], "hasBody": false }, { "endpointId": endpointId }, undefined, options),
+                get: /** Get a webhook endpoint */ (endpointId, options) => call(client, { "method": "get", "path": "/workspace/webhook-endpoints/{endpointId}", "query": [], "hasBody": false }, { "endpointId": endpointId }, undefined, options),
+                list: /** List webhook endpoints */ (options) => call(client, { "method": "get", "path": "/workspace/webhook-endpoints", "query": [], "hasBody": false }, {}, undefined, options),
+                test: /** Send a test event */ (endpointId, options) => call(client, { "method": "post", "path": "/workspace/webhook-endpoints/{endpointId}/test", "query": [], "hasBody": false }, { "endpointId": endpointId }, undefined, options),
+            },
+        },
+    };
+}

package/dist/resources.js

@@ -0,0 +1,40 @@
+import { apiErrorFrom } from "./errors.js";
+/** Makes the call; the data, or throws ApiError. */
+export async function call(client, op, pathParams, input, options = {}, content) {
+    const query = {};
+    const body = {};
+    for (const [name, value] of Object.entries(input ?? {})) {
+        if (value === undefined)
+            continue;
+        (op.query.includes(name) ? query : body)[name] = value;
+    }
+    const headers = {
+        ...options.headers,
+        ...(options.idempotencyKey
+            ? { "idempotency-key": options.idempotencyKey }
+            : {}),
+    };
+    const request = client.request;
+    // Raw bytes go as they are, typed by the Blob (else the route's type).
+    const raw = op.rawBody
+        ? content instanceof Blob
+            ? content
+            : new Blob([content])
+        : undefined;
+    const { data, error, response } = await request(op.method, op.path, {
+        params: { path: pathParams, query },
+        ...(op.hasBody ? { body } : {}),
+        ...(raw
+            ? {
+                body: raw,
+                bodySerializer: (value) => value,
+                headers: { "content-type": raw.type || op.rawBody, ...headers },
+            }
+            : { headers }),
+        ...(op.rawResponse ? { parseAs: "blob" } : {}),
+    });
+    if (error !== undefined || !response.ok) {
+        throw apiErrorFrom(error, response);
+    }
+    return data;
+}

package/dist/retry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Safe retries, one rule for every client (the SDK, the CLI, the MCP
+ * server; docs/architecture.md "Idempotency"): a WRITE gets one
+ * Idempotency-Key per logical call, and every automatic retry of that
+ * call sends the same key, so the API runs it once however many times
+ * it is sent. Without a key a timed-out create that actually ran would
+ * run again on retry; with a fresh key per attempt it would too.
+ *
+ * Retried: a network failure, 408, 429, 500, 502, 503, 504, and 409
+ * `idempotency_in_progress` (the first attempt is still running). Waits
+ * the response's Retry-After when it gives one, else a jittered backoff
+ * (0.5s, 1s, … capped at 8s); a Retry-After longer than MAX_WAIT_MS is
+ * handed back to the caller rather than slept through. A request whose
+ * own signal aborted (a caller's timeout) is never retried: the caller
+ * decided.
+ */
+export declare const DEFAULT_MAX_RETRIES = 2;
+export declare const MAX_WAIT_MS = 20000;
+/** The longest key a caller may pass where a client derives keys from it. */
+export declare const MAX_BASE_KEY = 200;
+type Fetch = (request: Request) => Promise<Response>;
+export type RetryOptions = {
+    /** Retries after the first attempt (default 2; 0 = never retry). */
+    maxRetries?: number;
+    /** The key for a write that has none (default: a random UUID). */
+    key?: (method: string, path: string) => string | Promise<string>;
+    /** Waits (tests pass a fake). */
+    sleep?: (ms: number) => Promise<void>;
+};
+/** `fetch` with the rule above. Each request is one logical call. */
+export declare function withRetries(fetch: Fetch, options?: RetryOptions): Fetch;
+/**
+ * Keys for a command or tool call that may make several writes, from
+ * one key its caller chose (`--idempotency-key`, an MCP tool's
+ * `idempotencyKey`): each write gets `<key>:<16 hex>`, a digest of its
+ * method, path and how many times the call wrote there before — so the
+ * same call run again sends the same keys, write for write, and a write
+ * it skips the second time shifts no other write's key. Without a key,
+ * a fresh UUID per write.
+ */
+export declare function keysFrom(base: string | undefined): (method: string, path: string) => Promise<string>;
+export {};