toolcraft-openapi 0.0.39 → 0.0.40

package/dist/diagnose.js

@@ -0,0 +1,93 @@
+import { DIAGNOSTIC_CODES, createDiagnostic } from "./diagnostics.js";
+export function diagnose(config, document) {
+    const configuredMethods = collectConfiguredMethods(config.resources);
+    return [
+        ...diagnoseDuplicateMethods(configuredMethods),
+        ...diagnoseUnknownPagination(config, configuredMethods),
+        ...diagnoseUnmappedEndpoints(config, document, configuredMethods)
+    ];
+}
+function collectConfiguredMethods(resources) {
+    const methods = [];
+    function visit(resource, path) {
+        for (const [name, method] of Object.entries(resource.methods ?? {})) {
+            methods.push({
+                configPath: [...path, "methods", name].join("."),
+                method
+            });
+        }
+        for (const [name, child] of Object.entries(resource.subresources ?? {})) {
+            visit(child, [...path, "subresources", name]);
+        }
+    }
+    for (const [name, resource] of Object.entries(resources ?? {})) {
+        visit(resource, ["resources", name]);
+    }
+    return methods;
+}
+function diagnoseDuplicateMethods(methods) {
+    const seen = new Map();
+    const diagnostics = [];
+    for (const method of methods) {
+        const key = endpointKey(method.method.method, method.method.path);
+        const existing = seen.get(key);
+        if (existing === undefined) {
+            seen.set(key, method);
+            continue;
+        }
+        diagnostics.push(createDiagnostic({
+            code: DIAGNOSTIC_CODES.duplicateMethodPath,
+            severity: "error",
+            location: method.configPath,
+            message: `${method.configPath} and ${existing.configPath} both bind ${key}.`
+        }));
+    }
+    return diagnostics;
+}
+function diagnoseUnknownPagination(config, methods) {
+    const schemes = new Set(Object.keys(config.pagination ?? {}));
+    return methods
+        .filter((method) => method.method.pagination !== undefined && !schemes.has(method.method.pagination))
+        .map((method) => createDiagnostic({
+        code: DIAGNOSTIC_CODES.unknownPaginationScheme,
+        severity: "error",
+        location: method.configPath,
+        message: `${method.configPath} references undeclared pagination scheme ${JSON.stringify(method.method.pagination)}.`
+    }));
+}
+function diagnoseUnmappedEndpoints(config, document, methods) {
+    if (config.resources === undefined) {
+        return [];
+    }
+    const configured = new Set(methods.map((method) => endpointKey(method.method.method, method.method.path)));
+    const unspecified = new Set((config.unspecified_endpoints ?? []).map(normalizeEndpointText));
+    const diagnostics = [];
+    for (const [path, pathItem] of Object.entries(document.paths ?? {})) {
+        if (pathItem === undefined) {
+            continue;
+        }
+        for (const method of ["get", "post", "put", "patch", "delete", "head", "options"]) {
+            if (!Object.hasOwn(pathItem, method)) {
+                continue;
+            }
+            const key = endpointKey(method, path);
+            if (configured.has(key) || unspecified.has(key)) {
+                continue;
+            }
+            diagnostics.push(createDiagnostic({
+                code: DIAGNOSTIC_CODES.unmappedEndpoint,
+                severity: "error",
+                location: `paths.${path}.${method}`,
+                message: `${method.toUpperCase()} ${path} is not listed in resources or unspecified_endpoints.`
+            }));
+        }
+    }
+    return diagnostics;
+}
+function endpointKey(method, path) {
+    return `${method.toLowerCase()} ${path}`;
+}
+function normalizeEndpointText(value) {
+    const [method, requestPath] = value.trim().split(" ");
+    return `${(method ?? "").toLowerCase()} ${requestPath ?? ""}`;
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,19 @@
+export type DiagnosticSeverity = "error" | "warn";
+export interface Diagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    location?: string;
+}
+export declare const DIAGNOSTIC_CODES: {
+    readonly unmappedEndpoint: "TOOLCRAFT_OPENAPI_001";
+    readonly duplicateMethodPath: "TOOLCRAFT_OPENAPI_002";
+    readonly unknownPaginationScheme: "TOOLCRAFT_OPENAPI_003";
+    readonly specDrift: "TOOLCRAFT_OPENAPI_004";
+    readonly reservedMethodName: "TOOLCRAFT_OPENAPI_005";
+    readonly invalidEdition: "TOOLCRAFT_OPENAPI_006";
+    readonly invalidConfig: "TOOLCRAFT_OPENAPI_007";
+};
+export declare function createDiagnostic(args: Diagnostic): Diagnostic;
+export declare function formatDiagnostic(diagnostic: Diagnostic): string;
+export declare function formatDiagnostics(diagnostics: readonly Diagnostic[]): string;

package/dist/diagnostics.js

@@ -0,0 +1,19 @@
+export const DIAGNOSTIC_CODES = {
+    unmappedEndpoint: "TOOLCRAFT_OPENAPI_001",
+    duplicateMethodPath: "TOOLCRAFT_OPENAPI_002",
+    unknownPaginationScheme: "TOOLCRAFT_OPENAPI_003",
+    specDrift: "TOOLCRAFT_OPENAPI_004",
+    reservedMethodName: "TOOLCRAFT_OPENAPI_005",
+    invalidEdition: "TOOLCRAFT_OPENAPI_006",
+    invalidConfig: "TOOLCRAFT_OPENAPI_007"
+};
+export function createDiagnostic(args) {
+    return args;
+}
+export function formatDiagnostic(diagnostic) {
+    const location = diagnostic.location === undefined ? "" : ` ${diagnostic.location}`;
+    return `${diagnostic.code} ${diagnostic.severity}${location}: ${diagnostic.message}`;
+}
+export function formatDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => `${formatDiagnostic(diagnostic)}\n`).join("");
+}

package/dist/generate.d.ts

@@ -1,4 +1,5 @@
 import { type HttpMethod } from "./naming.js";
+import type { ToolcraftConfig } from "./config.js";
 type OpenApiOperation = OpenApiOperationObject | OpenApiReferenceObject;
 type OpenApiOperationMap = Partial<Record<HttpMethod, OpenApiOperation>>;
 type OpenApiParameterLocation = "path" | "query" | "header" | "cookie";
@@ -12,6 +13,7 @@ export interface OpenApiDocument {
         title?: string;
         version?: string;
     };
+    servers?: OpenApiServerObject[];
     security?: OpenApiSecurityRequirementObject[];
     paths?: Record<string, OpenApiPathItemObject | undefined>;
     components?: {
@@ -98,6 +100,7 @@ type OpenApiSecurityRequirementObject = Record<string, string[]>;
 export interface GenerateOptions {
     specSha: string;
     brand?: string;
+    config?: ToolcraftConfig;
 }
 export interface GeneratedFile {
     path: string;
@@ -110,6 +113,7 @@ export interface GeneratedCommand {
     filePath: string;
     operationId: string;
     description?: string;
+    examples?: GeneratedCommandExample[];
     method: string;
     path: string;
     auth: "required" | "none";
@@ -119,6 +123,8 @@ export interface GeneratedCommand {
     bodyMode?: "json" | "form" | "raw" | "base64" | "multipart";
     contentType?: string;
     multipartBinaryFields?: readonly string[];
+    idempotencyHeader?: string;
+    rawResponse?: boolean;
     confirm: boolean;
     params: GeneratedParam[];
     paramsSchemaOptions?: GeneratedObjectSchemaOptions;
@@ -132,12 +138,17 @@ export interface GeneratedParam {
     sourceName: string;
     location: "path" | "query" | "header" | "body" | "transport";
     description?: string;
+    longAliases?: string[];
     shortFlag?: string;
     scope?: readonly [GeneratedParamScope, ...GeneratedParamScope[]];
     global?: boolean;
     optional: boolean;
     definition: GeneratedParamDefinition;
 }
+interface GeneratedCommandExample {
+    title: string;
+    params: Record<string, unknown>;
+}
 interface GeneratedParamDefinitionMetadata {
     defaultValue?: unknown;
     format?: string;
@@ -202,6 +213,7 @@ export interface GeneratedObjectSchemaOptions {
 interface RenderSchemaOptionsInput {
     definition: GeneratedParamDefinition;
     description?: string;
+    longAliases?: string[];
     shortFlag?: string;
     scope?: readonly [GeneratedParamScope, ...GeneratedParamScope[]];
     global?: boolean;
@@ -226,7 +238,7 @@ interface SchemaOptionEntry {
 }
 type QueryArraySerialization = "repeat" | "brackets" | "comma" | "pipe";
 export declare function generate(document: OpenApiDocument, options: GenerateOptions): GeneratedFile[];
-export declare function collectGeneratedCommands(document: OpenApiDocument): GeneratedCommand[];
+export declare function collectGeneratedCommands(document: OpenApiDocument, config?: ToolcraftConfig): GeneratedCommand[];
 export declare function collectGeneratedCommand(document: OpenApiDocument, path: string, method: HttpMethod): GeneratedCommand;
 export declare function collectSchemaOptionEntries(param: RenderSchemaOptionsInput): SchemaOptionEntry[];
 export {};

package/dist/generate.js

@@ -65,6 +65,10 @@ const SCHEMA_OPTION_SOURCES = [
         key: "short",
         get: (param) => param.shortFlag
     },
+    {
+        key: "cliAliases",
+        get: (param) => param.longAliases
+    },
     {
         key: "scope",
         get: (param) => param.scope
@@ -120,7 +124,7 @@ const SCHEMA_OPTION_SOURCES = [
 ];
 export function generate(document, options) {
     const normalizedDocument = normalizeOpenApiDocument(document);
-    const commands = collectGeneratedCommands(normalizedDocument);
+    const commands = collectGeneratedCommands(normalizedDocument, options.config);
     const brand = options.brand ?? "blue";
     const label = normalizedDocument.info?.title ?? "Toolcraft";
     return [
@@ -135,17 +139,102 @@ export function generate(document, options) {
         createCliFile({ brand, label })
     ];
 }
-export function collectGeneratedCommands(document) {
+export function collectGeneratedCommands(document, config) {
     const normalizedDocument = normalizeOpenApiDocument(document);
     const paths = normalizedDocument.paths;
     if (paths === undefined) {
         throw new UserError('OpenAPI document must define a top-level "paths" object.');
     }
     const commands = collectOperations(paths).map((entry) => createGeneratedCommand(normalizedDocument, entry));
+    applyConfiguredCommandShape(commands, config);
     disambiguateCommandPaths(commands);
     assertUniqueCommandPaths(commands);
     return commands.slice().sort((left, right) => compareGeneratedCommandPaths(left, right));
 }
+function applyConfiguredCommandShape(commands, config) {
+    const configured = collectConfiguredCommandShapes(config?.resources);
+    if (configured.length === 0) {
+        return;
+    }
+    for (const command of commands) {
+        const match = configured.find((candidate) => candidate.method.method.toUpperCase() === command.method && candidate.method.path === command.path);
+        if (match === undefined) {
+            continue;
+        }
+        command.noun = createSafeGeneratedNoun(match.noun);
+        command.verb = createSafeGeneratedVerb(match.verb);
+        command.examples = config?.readme?.examples?.[match.exampleKey];
+        applyConfiguredRawResponse(command);
+        applyConfiguredIdempotency(command, match.method, config);
+        refreshGeneratedCommandNames(command);
+    }
+}
+function applyConfiguredRawResponse(command) {
+    command.rawResponse = true;
+    if (command.params.some((param) => param.paramName === "rawResponse")) {
+        return;
+    }
+    command.params.push({
+        paramName: "rawResponse",
+        sourceName: "rawResponse",
+        location: "transport",
+        description: "Return parsed data with the raw HTTP Response.",
+        longAliases: ["raw"],
+        scope: ["cli", "sdk"],
+        optional: true,
+        definition: { kind: "boolean" }
+    });
+}
+function applyConfiguredIdempotency(command, method, config) {
+    const header = config?.client_settings?.idempotency_header;
+    if (method.idempotent !== true || header === undefined || command.method === "GET") {
+        return;
+    }
+    command.idempotencyHeader = header;
+    if (command.params.some((param) => param.paramName === "idempotencyKey")) {
+        return;
+    }
+    command.params.push({
+        paramName: "idempotencyKey",
+        sourceName: "idempotencyKey",
+        location: "transport",
+        description: "Set an idempotency key to retry this request safely.",
+        scope: ["cli", "mcp", "sdk"],
+        optional: true,
+        definition: { kind: "string" }
+    });
+}
+function collectConfiguredCommandShapes(resources) {
+    const shapes = [];
+    function visit(resourceName, resource, resourcePath) {
+        for (const [methodName, method] of Object.entries(resource.methods ?? {})) {
+            shapes.push({
+                exampleKey: [...resourcePath, methodName].join("."),
+                noun: resourceName,
+                verb: methodName,
+                method
+            });
+        }
+        for (const [childName, childResource] of Object.entries(resource.subresources ?? {})) {
+            visit(childName, childResource, [...resourcePath, childName]);
+        }
+    }
+    for (const [resourceName, resource] of Object.entries(resources ?? {})) {
+        visit(resourceName, resource, [resourceName]);
+    }
+    return shapes;
+}
+function createSafeGeneratedVerb(value) {
+    const verb = toCamelCase(value);
+    if (!isIdentifierName(verb)) {
+        throw new UserError(`Configured method ${JSON.stringify(value)} must map to a valid command name.`);
+    }
+    return verb;
+}
+function refreshGeneratedCommandNames(command) {
+    command.exportName = `${toCamelCase(command.noun)}${toPascalCase(command.verb)}Command`;
+    command.filePath = `${command.noun}/${command.verb}.ts`;
+}
 export function collectGeneratedCommand(document, path, method) {
     const normalizedDocument = normalizeOpenApiDocument(document);
     const pathItem = normalizedDocument.paths?.[path];
@@ -1315,6 +1404,9 @@ function createCommandFile(options) {
     if (options.description !== undefined) {
         lines.push(`  description: ${JSON.stringify(options.description)},`);
     }
+    if (options.examples !== undefined && options.examples.length > 0) {
+        lines.push(`  examples: ${JSON.stringify(options.examples)},`);
+    }
     lines.push('  scope: ["cli", "mcp", "sdk"] as const,');
     if (options.confirm) {
         lines.push("  confirm: true,");
@@ -1382,6 +1474,16 @@ function createCommandFile(options) {
     lines.push("      fetch,");
     lines.push("      dryRun: params.dryRun,");
     lines.push("      verbose: params.verbose,");
+    if (options.rawResponse === true) {
+        lines.push("      rawResponse: params.rawResponse,");
+    }
+    if (options.idempotencyHeader !== undefined) {
+        lines.push("      idempotency: {");
+        lines.push(`        header: ${JSON.stringify(options.idempotencyHeader)},`);
+        lines.push("        enabled: true,");
+        lines.push("        key: params.idempotencyKey,");
+        lines.push("      },");
+    }
     if (usesRequestShapeVariable) {
         lines.push("      ...preparedRequestShape,");
     }
@@ -1455,14 +1557,15 @@ function renderParamLines(params) {
     return params.map((param) => `    ${renderObjectKey(param.paramName)}: ${renderParamSchema(param)},`);
 }
 function renderParamSchema(param) {
-    const schema = renderDefinition(param.definition, param.description, param.shortFlag, param.scope, param.global);
+    const schema = renderDefinition(param.definition, param.description, param.shortFlag, param.longAliases, param.scope, param.global);
     return param.optional ? `S.Optional(${schema})` : schema;
 }
-function renderDefinition(definition, description, shortFlag, scope, global) {
+function renderDefinition(definition, description, shortFlag, longAliases, scope, global) {
     const options = renderSchemaOptions({
         definition,
         description,
         shortFlag,
+        longAliases,
         scope,
         global
     });

package/dist/http.d.ts

@@ -1,5 +1,7 @@
-import { type HandlerEnv, type HandlerFs } from "toolcraft";
+import { HttpError, type HandlerEnv, type HandlerFs, type HttpErrorRequest, type HttpErrorResponse } from "toolcraft";
 import type { TokenSource } from "./auth/types.js";
+export { HttpError };
+export type { HttpErrorRequest, HttpErrorResponse };
 type QueryScalar = string | number | boolean | null | undefined;
 type QueryObject = {
     readonly [key: string]: QueryValue;
@@ -25,21 +27,23 @@ export interface HttpRequestOptions {
     dryRun?: boolean;
     verbose?: boolean;
     signal?: AbortSignal;
+    rawResponse?: boolean;
+    retries?: {
+        max: number;
+        backoff: "exponential";
+        retryOn: number[];
+        sleep?: (ms: number) => Promise<void>;
+        random?: () => number;
+    };
+    idempotency?: {
+        header: string;
+        enabled: boolean;
+        key?: string;
+        createKey?: () => string;
+    };
     writeStdout?: (chunk: string) => void;
     writeStderr?: (chunk: string) => void;
 }
-export interface HttpErrorRequest {
-    method: string;
-    url: string;
-    headers: Record<string, string>;
-    body?: unknown;
-}
-export interface HttpErrorResponse {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: unknown;
-}
 export interface BinaryHttpResponse {
     contentType: string;
     encoding: "base64";
@@ -49,18 +53,6 @@ export interface BinaryHttpResponse {
 type RuntimeFileSystem = Pick<HandlerFs, "exists" | "readFile" | "writeFile">;
 type RuntimeEnvironment = Pick<HandlerEnv, "get">;
 type RequestShape = Partial<Pick<HttpRequestOptions, "pathParams" | "query" | "headers" | "body">>;
-export declare class HttpError extends Error {
-    readonly status: number;
-    readonly statusText: string;
-    readonly request: HttpErrorRequest;
-    readonly response: HttpErrorResponse;
-    get body(): unknown;
-    constructor(args: {
-        request: HttpErrorRequest;
-        response: HttpErrorResponse;
-        message?: string;
-    });
-}
 export declare function requestJson<TResult = unknown>(options: HttpRequestOptions): Promise<TResult | undefined>;
 export declare function prepareMultipartFileInputs(requestShape: RequestShape, options: {
     bodyMode?: HttpRequestOptions["bodyMode"];
@@ -72,4 +64,3 @@ export declare function writeBinaryResponseOutput(result: unknown, outputPath: u
     fs?: RuntimeFileSystem;
     env?: RuntimeEnvironment;
 }): Promise<unknown>;
-export {};

package/dist/http.js

@@ -1,27 +1,11 @@
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { text as designText } from "toolcraft-design";
-import { UserError } from "toolcraft";
+import { HttpError, UserError, createHttpError } from "toolcraft";
 import { classifyNetworkError } from "./network-error.js";
 import { redactHeaders, redactHeaderValue, redactSensitiveQueryValues } from "./redaction.js";
+export { HttpError };
 const TRANSCRIPT_BODY_BYTE_LIMIT = 4 * 1024;
-export class HttpError extends Error {
-    status;
-    statusText;
-    request;
-    response;
-    get body() {
-        return this.response.body;
-    }
-    constructor(args) {
-        super(args.message ??
-            `${args.request.method} ${args.request.url} → ${args.response.status} ${args.response.statusText}`);
-        this.name = "HttpError";
-        this.status = args.response.status;
-        this.statusText = args.response.statusText;
-        this.request = args.request;
-        this.response = args.response;
-    }
-}
 export async function requestJson(options) {
     const token = options.auth === "none" ? undefined : await options.tokenSource.getToken();
     const method = options.method.toUpperCase();
@@ -38,7 +22,12 @@ export async function requestJson(options) {
                         : JSON.stringify(options.body)
         : undefined;
     const url = buildRequestUrl(options);
-    const headers = createHeaders(token, hasBody, options.headers, options.accept, options.bodyMode, options.contentType);
+    const idempotencyHeader = options.idempotency?.enabled === true && method !== "GET"
+        ? {
+            [options.idempotency.header]: options.idempotency.key ?? options.idempotency.createKey?.() ?? randomUUID()
+        }
+        : {};
+    const headers = createHeaders(token, hasBody, { ...options.headers, ...idempotencyHeader }, options.accept, options.bodyMode, options.contentType);
     const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
     const requestLine = `${method} ${redactSensitiveQueryValues(url)}`;
@@ -49,18 +38,12 @@ export async function requestJson(options) {
     if (options.verbose) {
         writeStderr(formatTranscriptLines(formatVerboseRequestTranscript(method, url, headers, options.body)));
     }
-    let response;
-    try {
-        response = await (options.fetch ?? globalThis.fetch)(url, {
-            method,
-            headers,
-            body: serializedBody,
-            signal: options.signal
-        });
-    }
-    catch (error) {
-        throw classifyNetworkError(error, url) ?? error;
-    }
+    const response = await fetchWithRetries(options, url, {
+        method,
+        headers,
+        body: serializedBody,
+        signal: options.signal
+    });
     const contentType = response.headers.get("content-type");
     const request = createHttpErrorRequest(method, url, headers, options.body);
     const responseHeaders = redactHeaders(serializeHeaders(response.headers));
@@ -70,7 +53,7 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
             }
-            return undefined;
+            return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         const body = {
             contentType: contentType ?? options.accept ?? "application/octet-stream",
@@ -81,7 +64,7 @@ export async function requestJson(options) {
         if (options.verbose) {
             writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
         }
-        return body;
+        return formatRawResponseResult(body, response, options.rawResponse);
     }
     const text = await response.text();
     if (response.ok) {
@@ -89,19 +72,19 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders)));
             }
-            return undefined;
+            return formatRawResponseResult(undefined, response, options.rawResponse);
         }
         if (options.responseMode === "text") {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            return text;
+            return formatRawResponseResult(text, response, options.rawResponse);
         }
         if (!isJsonContentType(contentType)) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            throw new HttpError({
+            throw createHttpError({
                 request,
                 response: {
                     status: response.status,
@@ -120,7 +103,7 @@ export async function requestJson(options) {
             if (options.verbose) {
                 writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, text)));
             }
-            throw new HttpError({
+            throw createHttpError({
                 request,
                 response: {
                     status: response.status,
@@ -134,7 +117,7 @@ export async function requestJson(options) {
         if (options.verbose) {
             writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
         }
-        return body;
+        return formatRawResponseResult(body, response, options.rawResponse);
     }
     if (response.status === 401 && options.auth === "required") {
         await options.tokenSource.invalidate?.(token).catch(() => undefined);
@@ -143,16 +126,76 @@ export async function requestJson(options) {
     if (options.verbose) {
         writeStderr(formatTranscriptLines(formatVerboseResponseTranscript(response, responseHeaders, body)));
     }
-    throw new HttpError({
+    throw createHttpError({
         request,
         response: {
             status: response.status,
             statusText: response.statusText,
             headers: responseHeaders,
             body
-        }
+        },
+        code: extractErrorCode(body),
+        requestId: response.headers.get("x-request-id") ?? response.headers.get("x-requestid") ?? undefined
     });
 }
+async function fetchWithRetries(options, url, init) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const retries = options.retries;
+    const maxRetries = retries?.max ?? 0;
+    let attempt = 0;
+    while (true) {
+        try {
+            const response = await fetchImpl(url, init);
+            if (retries === undefined ||
+                attempt >= maxRetries ||
+                !shouldRetryStatus(response.status, retries.retryOn)) {
+                return response;
+            }
+            await sleepBeforeRetry(response, retries, attempt);
+            attempt += 1;
+        }
+        catch (error) {
+            const classified = classifyNetworkError(error, url) ?? error;
+            if (attempt >= maxRetries || retries === undefined) {
+                throw classified;
+            }
+            await sleepBeforeRetry(undefined, retries, attempt);
+            attempt += 1;
+        }
+    }
+}
+function shouldRetryStatus(status, retryOn) {
+    return retryOn?.includes(status) === true;
+}
+async function sleepBeforeRetry(response, retries, attempt) {
+    const retryAfter = response?.headers.get("retry-after");
+    const delay = parseRetryAfter(retryAfter) ?? calculateBackoffDelay(attempt, retries.random);
+    await (retries.sleep ?? defaultSleep)(delay);
+}
+function parseRetryAfter(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const timestamp = Date.parse(value);
+    if (!Number.isNaN(timestamp)) {
+        return Math.max(0, timestamp - Date.now());
+    }
+    return undefined;
+}
+function calculateBackoffDelay(attempt, random) {
+    const base = 100 * 2 ** attempt;
+    return Math.floor(base * (random ?? Math.random)());
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatRawResponseResult(data, response, rawResponse) {
+    return rawResponse === true ? { data, response } : data;
+}
 export async function prepareMultipartFileInputs(requestShape, options) {
     if (options.bodyMode !== "multipart" ||
         options.multipartBinaryFields === undefined ||
@@ -442,6 +485,21 @@ function parseResponseBody(text, contentType) {
     }
     return JSON.parse(text);
 }
+function extractErrorCode(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        return undefined;
+    }
+    const directCode = body.code;
+    if (typeof directCode === "string") {
+        return directCode;
+    }
+    const error = body.error;
+    if (error !== null && typeof error === "object" && !Array.isArray(error)) {
+        const nestedCode = error.code;
+        return typeof nestedCode === "string" ? nestedCode : undefined;
+    }
+    return undefined;
+}
 function isJsonContentType(contentType) {
     if (contentType === null) {
         return false;