@apifuse/provider-sdk 2.1.0-beta.1 → 2.1.0-beta.10

package/dist/runtime/http.js

@@ -0,0 +1,706 @@
+import { resolveProxyConfigAsync } from "../config/loader";
+import { ProviderError, TransportError } from "../errors";
+import { parseSseStream, readableBytes, readableLines, readableTextChunks, } from "../stream";
+import { HttpRetryAfterPolicy, HttpRetryDelayStrategy, HttpRetryJitter, HttpRetryPreset, HttpRetryUnsafeMethodPolicy, } from "../types";
+import { appendQueryParams, normalizeHttpRequestBody } from "./request-options";
+const DEFAULT_HTTP_BASE_URL = "http://localhost";
+function isHttpStatusOutcome(outcome) {
+    return "kind" in outcome && outcome.kind === "http-status";
+}
+const DEFAULT_RETRY_METHODS = ["GET", "HEAD", "OPTIONS"];
+const DEFAULT_RETRY_ERROR_CODES = [
+    "transport_network_error",
+    "transport_timeout",
+];
+const SAFE_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+const RATE_LIMIT_RETRY_STATUS_CODES = [429, 503];
+const KNOWN_RETRY_METHODS = new Set([
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "TRACE",
+    "PATCH",
+]);
+const UNSAFE_RETRY_METHODS = new Set([
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "TRACE",
+]);
+const MAX_RETRY_ATTEMPTS = 8;
+const MAX_RETRY_DELAY_MS = 30_000;
+function hasOwnValue(values, value) {
+    if (typeof value !== "string")
+        return false;
+    return Object.values(values).some((candidate) => candidate === value);
+}
+function createInvalidRetryPolicyError(message) {
+    return new ProviderError(message, { code: "retry_invalid_policy" });
+}
+function createRetryOptions(preset) {
+    switch (preset) {
+        case HttpRetryPreset.Off:
+            return {
+                preset,
+                attempts: 1,
+                methods: DEFAULT_RETRY_METHODS,
+                statusCodes: [],
+                errorCodes: DEFAULT_RETRY_ERROR_CODES,
+                delayStrategy: HttpRetryDelayStrategy.Exponential,
+                baseDelayMs: 100,
+                maxDelayMs: 1_000,
+                jitter: HttpRetryJitter.Full,
+                retryAfter: HttpRetryAfterPolicy.Ignore,
+                unsafeMethodPolicy: HttpRetryUnsafeMethodPolicy.Reject,
+            };
+        case HttpRetryPreset.SafeRead:
+            return {
+                preset,
+                attempts: 3,
+                methods: DEFAULT_RETRY_METHODS,
+                statusCodes: SAFE_RETRY_STATUS_CODES,
+                errorCodes: DEFAULT_RETRY_ERROR_CODES,
+                delayStrategy: HttpRetryDelayStrategy.Exponential,
+                baseDelayMs: 100,
+                maxDelayMs: 2_000,
+                jitter: HttpRetryJitter.Full,
+                retryAfter: HttpRetryAfterPolicy.Cap,
+                unsafeMethodPolicy: HttpRetryUnsafeMethodPolicy.Reject,
+            };
+        case HttpRetryPreset.AggressiveRead:
+            return {
+                preset,
+                attempts: 4,
+                methods: DEFAULT_RETRY_METHODS,
+                statusCodes: SAFE_RETRY_STATUS_CODES,
+                errorCodes: DEFAULT_RETRY_ERROR_CODES,
+                delayStrategy: HttpRetryDelayStrategy.Exponential,
+                baseDelayMs: 150,
+                maxDelayMs: 5_000,
+                jitter: HttpRetryJitter.Full,
+                retryAfter: HttpRetryAfterPolicy.Cap,
+                unsafeMethodPolicy: HttpRetryUnsafeMethodPolicy.Reject,
+            };
+        case HttpRetryPreset.RateLimitAware:
+            return {
+                preset,
+                attempts: 3,
+                methods: DEFAULT_RETRY_METHODS,
+                statusCodes: RATE_LIMIT_RETRY_STATUS_CODES,
+                errorCodes: ["transport_timeout"],
+                delayStrategy: HttpRetryDelayStrategy.Exponential,
+                baseDelayMs: 250,
+                maxDelayMs: 5_000,
+                jitter: HttpRetryJitter.Equal,
+                retryAfter: HttpRetryAfterPolicy.Respect,
+                unsafeMethodPolicy: HttpRetryUnsafeMethodPolicy.Reject,
+            };
+        case HttpRetryPreset.TransportTransient:
+            return {
+                preset,
+                attempts: 3,
+                methods: DEFAULT_RETRY_METHODS,
+                statusCodes: [],
+                errorCodes: DEFAULT_RETRY_ERROR_CODES,
+                delayStrategy: HttpRetryDelayStrategy.Exponential,
+                baseDelayMs: 100,
+                maxDelayMs: 1_000,
+                jitter: HttpRetryJitter.Full,
+                retryAfter: HttpRetryAfterPolicy.Ignore,
+                unsafeMethodPolicy: HttpRetryUnsafeMethodPolicy.Reject,
+            };
+    }
+    throw createInvalidRetryPolicyError(`Unknown HTTP retry preset: ${preset}`);
+}
+function clampPositiveInteger(value, fallback, max) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value) || value < 1)
+        return fallback;
+    return Math.min(Math.floor(value), max);
+}
+function clampDelay(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isFinite(value) || value < 0)
+        return fallback;
+    return Math.min(Math.floor(value), MAX_RETRY_DELAY_MS);
+}
+function normalizeRetryOptions(retry) {
+    if (retry === undefined || retry === false) {
+        return undefined;
+    }
+    if (retry === true) {
+        return createRetryOptions(HttpRetryPreset.TransportTransient);
+    }
+    if (typeof retry === "string") {
+        if (!hasOwnValue(HttpRetryPreset, retry)) {
+            throw createInvalidRetryPolicyError(`Unknown HTTP retry preset: ${retry}`);
+        }
+        return createRetryOptions(retry);
+    }
+    if (typeof retry !== "object" || retry === null) {
+        throw createInvalidRetryPolicyError("HTTP retry policy must be an object");
+    }
+    if (Array.isArray(retry)) {
+        throw createInvalidRetryPolicyError("HTTP retry policy must be a plain object");
+    }
+    validateRetryOptionsShape(retry);
+    const base = createRetryOptions(retry.preset ?? HttpRetryPreset.TransportTransient);
+    const maxDelayMs = clampDelay(retry.maxDelayMs, base.maxDelayMs);
+    const normalized = {
+        preset: retry.preset ?? base.preset,
+        attempts: clampPositiveInteger(retry.attempts, base.attempts, MAX_RETRY_ATTEMPTS),
+        methods: retry.methods?.map((method) => method.toUpperCase()) ?? base.methods,
+        statusCodes: retry.statusCodes?.filter((status) => Number.isInteger(status)) ??
+            base.statusCodes,
+        errorCodes: retry.errorCodes ?? base.errorCodes,
+        delayStrategy: retry.delayStrategy ?? base.delayStrategy,
+        baseDelayMs: clampDelay(retry.baseDelayMs, base.baseDelayMs),
+        maxDelayMs,
+        jitter: retry.jitter ?? base.jitter,
+        retryAfter: retry.retryAfter ?? base.retryAfter,
+        unsafeMethodPolicy: retry.unsafeMethodPolicy ?? base.unsafeMethodPolicy,
+    };
+    return normalized;
+}
+function validateRetryOptionsShape(retry) {
+    if (retry.preset !== undefined &&
+        !hasOwnValue(HttpRetryPreset, retry.preset)) {
+        throw createInvalidRetryPolicyError(`Unknown HTTP retry preset: ${String(retry.preset)}`);
+    }
+    if (retry.delayStrategy !== undefined &&
+        !hasOwnValue(HttpRetryDelayStrategy, retry.delayStrategy)) {
+        throw createInvalidRetryPolicyError(`Unknown HTTP retry delay strategy: ${String(retry.delayStrategy)}`);
+    }
+    if (retry.jitter !== undefined &&
+        !hasOwnValue(HttpRetryJitter, retry.jitter)) {
+        throw createInvalidRetryPolicyError(`Unknown HTTP retry jitter policy: ${String(retry.jitter)}`);
+    }
+    if (retry.retryAfter !== undefined &&
+        !hasOwnValue(HttpRetryAfterPolicy, retry.retryAfter)) {
+        throw createInvalidRetryPolicyError(`Unknown HTTP retry-after policy: ${String(retry.retryAfter)}`);
+    }
+    if (retry.unsafeMethodPolicy !== undefined &&
+        !hasOwnValue(HttpRetryUnsafeMethodPolicy, retry.unsafeMethodPolicy)) {
+        throw createInvalidRetryPolicyError(`Unknown HTTP retry unsafe method policy: ${String(retry.unsafeMethodPolicy)}`);
+    }
+    if (retry.methods !== undefined) {
+        if (!Array.isArray(retry.methods)) {
+            throw createInvalidRetryPolicyError("HTTP retry methods must be an array");
+        }
+        const nonStringMethods = retry.methods.filter((method) => typeof method !== "string");
+        if (nonStringMethods.length > 0) {
+            throw createInvalidRetryPolicyError("HTTP retry methods must contain only strings");
+        }
+        const unknownMethods = retry.methods
+            .map((method) => method.toUpperCase())
+            .filter((method) => !KNOWN_RETRY_METHODS.has(method));
+        if (unknownMethods.length > 0) {
+            throw createInvalidRetryPolicyError(`Unknown HTTP retry method(s): ${unknownMethods.join(", ")}`);
+        }
+    }
+    if (retry.statusCodes !== undefined) {
+        if (!Array.isArray(retry.statusCodes)) {
+            throw createInvalidRetryPolicyError("HTTP retry statusCodes must be an array");
+        }
+        const invalidStatusCodes = retry.statusCodes.filter((status) => !Number.isInteger(status) ||
+            Number(status) < 100 ||
+            Number(status) > 599);
+        if (invalidStatusCodes.length > 0) {
+            throw createInvalidRetryPolicyError("HTTP retry statusCodes must contain HTTP status integers in [100, 599]");
+        }
+    }
+    if (retry.errorCodes !== undefined) {
+        if (!Array.isArray(retry.errorCodes)) {
+            throw createInvalidRetryPolicyError("HTTP retry errorCodes must be an array");
+        }
+        const nonStringErrorCodes = retry.errorCodes.filter((errorCode) => typeof errorCode !== "string");
+        if (nonStringErrorCodes.length > 0) {
+            throw createInvalidRetryPolicyError("HTTP retry errorCodes must contain only strings");
+        }
+    }
+    if (retry.preset === HttpRetryPreset.Off &&
+        ((retry.attempts !== undefined && retry.attempts > 1) ||
+            (retry.statusCodes !== undefined && retry.statusCodes.length > 0))) {
+        throw createInvalidRetryPolicyError("HTTP retry preset off cannot be combined with retry-enabling overrides");
+    }
+}
+function validateUnsafeRetryMethods(options) {
+    if (options.unsafeMethodPolicy ===
+        HttpRetryUnsafeMethodPolicy.AllowExplicitUnsafe) {
+        return;
+    }
+    const unsafeMethods = options.methods.filter((method) => UNSAFE_RETRY_METHODS.has(method.toUpperCase()));
+    if (unsafeMethods.length === 0)
+        return;
+    throw new ProviderError(`HTTP retry methods include unsafe method(s): ${unsafeMethods.join(", ")}`, { code: "retry_unsafe_method" });
+}
+function isMethodRetryable(method, options) {
+    return options.methods
+        .map((allowedMethod) => allowedMethod.toUpperCase())
+        .includes(method.toUpperCase());
+}
+function retryErrorCode(error) {
+    if (error instanceof TransportError) {
+        return error.code;
+    }
+    if (error && typeof error === "object" && "code" in error) {
+        const code = Reflect.get(error, "code");
+        return typeof code === "string" ? code : undefined;
+    }
+    return undefined;
+}
+function retryErrorStatus(error) {
+    if (error instanceof TransportError) {
+        return error.status ?? error.upstreamStatus;
+    }
+    return undefined;
+}
+function shouldRetryTransportError(error, options) {
+    const code = retryErrorCode(error);
+    return Boolean(code && options.errorCodes.includes(code));
+}
+function retryAfterHeader(headers) {
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === "retry-after")
+            return value;
+    }
+    return undefined;
+}
+function parseRetryAfterMs(headers, now = Date.now()) {
+    const value = retryAfterHeader(headers);
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, Math.floor(seconds * 1_000));
+    }
+    const dateMs = Date.parse(value);
+    if (!Number.isNaN(dateMs)) {
+        return Math.max(0, dateMs - now);
+    }
+    return undefined;
+}
+function computeRetryDelayMs(options, attemptIndex, headers) {
+    const multiplier = options.delayStrategy === HttpRetryDelayStrategy.Exponential
+        ? 2 ** Math.max(0, attemptIndex - 1)
+        : 1;
+    const configuredDelay = Math.min(options.baseDelayMs * multiplier, options.maxDelayMs);
+    const retryAfterMs = options.retryAfter === HttpRetryAfterPolicy.Ignore
+        ? undefined
+        : headers
+            ? parseRetryAfterMs(headers)
+            : undefined;
+    if (retryAfterMs !== undefined) {
+        const boundedRetryAfterMs = Math.min(retryAfterMs, options.maxDelayMs);
+        if (options.retryAfter === HttpRetryAfterPolicy.Cap) {
+            return Math.min(boundedRetryAfterMs, configuredDelay);
+        }
+        return boundedRetryAfterMs;
+    }
+    switch (options.jitter) {
+        case HttpRetryJitter.None:
+            return configuredDelay;
+        case HttpRetryJitter.Equal:
+            return Math.floor(configuredDelay / 2 + Math.random() * (configuredDelay / 2));
+        case HttpRetryJitter.Full:
+            return Math.floor(Math.random() * configuredDelay);
+    }
+}
+async function sleep(ms) {
+    if (ms <= 0)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toUpstreamHttpError(status) {
+    return new TransportError(`Upstream request failed with status ${status}`, {
+        code: "upstream_http_error",
+        status,
+        upstreamStatus: status,
+    });
+}
+function hasHeader(headers, name) {
+    const needle = name.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === needle);
+}
+function withClientHeaders(options, clientOptions, body) {
+    const headers = {
+        ...(clientOptions.userAgent
+            ? { "User-Agent": clientOptions.userAgent }
+            : {}),
+        ...options?.headers,
+    };
+    if (body !== undefined && !hasHeader(headers, "Content-Type")) {
+        headers["Content-Type"] = "application/json";
+    }
+    return {
+        ...options,
+        headers,
+    };
+}
+function parseHttpData(body, headers) {
+    const contentType = headers["content-type"] ??
+        headers["Content-Type"] ??
+        headers["CONTENT-TYPE"];
+    if (contentType?.includes("application/json")) {
+        return body ? JSON.parse(body) : null;
+    }
+    return body;
+}
+function parseJson(body) {
+    return JSON.parse(body);
+}
+function isTimeoutMessage(message) {
+    return /\b(timed out|timeout|deadline exceeded)\b/i.test(message);
+}
+function toHttpTransportError(error) {
+    if (error instanceof TransportError) {
+        if (error.code) {
+            return error;
+        }
+        if (isTimeoutMessage(error.message)) {
+            return new TransportError("Request timed out", {
+                code: "transport_timeout",
+                status: error.status ?? 0,
+                cause: error,
+            });
+        }
+        if ((error.status ?? 0) === 0) {
+            return new TransportError(error.message || "Network error", {
+                code: "transport_network_error",
+                status: 0,
+                cause: error,
+            });
+        }
+        return error;
+    }
+    if (error instanceof Error) {
+        const timeout = error.name === "AbortError" ||
+            error.name === "TimeoutError" ||
+            isTimeoutMessage(error.message);
+        return new TransportError(timeout ? "Request timed out" : "Network error", {
+            code: timeout ? "transport_timeout" : "transport_network_error",
+            status: 0,
+            cause: error,
+        });
+    }
+    return new TransportError("Network error", {
+        code: "transport_network_error",
+        status: 0,
+    });
+}
+async function toNativeHttpResponse(response) {
+    const headers = Object.fromEntries(response.headers.entries());
+    const rawText = await response.text();
+    const data = parseHttpData(rawText, headers);
+    return {
+        data,
+        headers,
+        json: async () => {
+            const contentType = headers["content-type"] ??
+                headers["Content-Type"] ??
+                headers["CONTENT-TYPE"];
+            return parseJson(contentType?.includes("application/json") && !rawText
+                ? "null"
+                : rawText);
+        },
+        ok: response.status >= 200 && response.status < 300,
+        status: response.status,
+        text: async () => rawText,
+    };
+}
+async function drainNativeResponseBody(response) {
+    try {
+        await response.arrayBuffer();
+    }
+    catch {
+        await response.body?.cancel().catch(() => undefined);
+    }
+}
+function requireNativeResponseBody(response) {
+    if (!response.body) {
+        throw new TransportError("Response body stream is unavailable", {
+            code: "transport_stream_unavailable",
+            status: response.status,
+        });
+    }
+    return response.body;
+}
+function toNativeHttpStreamResponse(response) {
+    const headers = Object.fromEntries(response.headers.entries());
+    const body = requireNativeResponseBody(response);
+    return {
+        body,
+        headers,
+        ok: response.status >= 200 && response.status < 300,
+        status: response.status,
+        bytes: () => readableBytes(body),
+        textChunks: () => readableTextChunks(body),
+        lines: () => readableLines(body),
+    };
+}
+function normalizeHttpMethod(method) {
+    switch (method.toUpperCase()) {
+        case "HEAD":
+            return "HEAD";
+        case "GET":
+            return "GET";
+        case "POST":
+            return "POST";
+        case "PUT":
+            return "PUT";
+        case "DELETE":
+            return "DELETE";
+        case "OPTIONS":
+            return "OPTIONS";
+        case "TRACE":
+            return "TRACE";
+        case "PATCH":
+            return "PATCH";
+        default:
+            throw new TransportError(`Unsupported HTTP method: ${method}`, {
+                code: "transport_invalid_method",
+            });
+    }
+}
+function isAbsoluteUrl(url) {
+    return /^[a-z][a-z\d+\-.]*:/i.test(url);
+}
+function resolveHttpUrl(baseUrl, url) {
+    return new URL(url, baseUrl ?? DEFAULT_HTTP_BASE_URL).toString();
+}
+async function resolveNativeProxy(options, clientOptions, warn) {
+    const resolvedProxy = await resolveProxyConfigAsync({
+        proxy: options.proxy ?? clientOptions.proxy,
+        upstream: clientOptions.upstream,
+        apifuseConfig: clientOptions.apifuseConfig,
+        affinityKey: clientOptions.affinityKey,
+        telemetry: clientOptions.telemetry,
+    });
+    if (resolvedProxy.shouldWarn) {
+        warn("[provider-sdk] Provider requested proxy routing, but no proxy URL was configured. Continuing without proxy.");
+    }
+    return resolvedProxy.url;
+}
+function assertNoHttpTransportOverrides(options) {
+    if ("profile" in options || "stealth" in options) {
+        throw new ProviderError("ctx.http does not accept stealth transport options. Use ctx.stealth.fetch() for browser-like impersonation.", { code: "http_transport_override_unsupported" });
+    }
+}
+function normalizeNativeFetchBody(body) {
+    const normalized = normalizeHttpRequestBody(body);
+    if (!Buffer.isBuffer(normalized)) {
+        return normalized;
+    }
+    const copied = new Uint8Array(normalized.byteLength);
+    copied.set(normalized);
+    return copied.buffer;
+}
+async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, warn, statusRetryCodes) {
+    const requestUrl = appendQueryParams(resolveHttpUrl(baseUrl, url), options.params);
+    const controller = options.timeout ? new AbortController() : undefined;
+    const timeoutHandle = options.timeout
+        ? setTimeout(() => controller?.abort(), options.timeout)
+        : undefined;
+    try {
+        const proxy = await resolveNativeProxy(options, clientOptions, warn);
+        const requestInit = {
+            headers: options.headers,
+            method,
+            ...(proxy ? { proxy } : {}),
+            signal: controller?.signal,
+        };
+        if (options.body !== undefined) {
+            requestInit.body = normalizeNativeFetchBody(options.body);
+        }
+        const response = await fetch(requestUrl, {
+            ...requestInit,
+        });
+        const headers = Object.fromEntries(response.headers.entries());
+        if (statusRetryCodes && response.status >= 400) {
+            await drainNativeResponseBody(response);
+            return {
+                kind: "http-status",
+                status: response.status,
+                headers,
+                retryable: statusRetryCodes.includes(response.status),
+            };
+        }
+        if (response.status >= 400 && options.throwOnHttpError !== false) {
+            await drainNativeResponseBody(response);
+            throw new TransportError(`Upstream request failed with status ${response.status}`, {
+                code: "upstream_http_error",
+                status: response.status,
+            });
+        }
+        return toNativeHttpResponse(response);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw error;
+        }
+        throw toHttpTransportError(error);
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+}
+async function fetchNativeHttpStream(baseUrl, url, method, options, clientOptions, warn) {
+    const requestUrl = appendQueryParams(resolveHttpUrl(baseUrl, url), options.params);
+    const controller = options.timeout ? new AbortController() : undefined;
+    const timeoutHandle = options.timeout
+        ? setTimeout(() => controller?.abort(), options.timeout)
+        : undefined;
+    try {
+        const proxy = await resolveNativeProxy(options, clientOptions, warn);
+        const requestInit = {
+            headers: options.headers,
+            method,
+            ...(proxy ? { proxy } : {}),
+            signal: controller?.signal,
+        };
+        if (options.body !== undefined) {
+            requestInit.body = normalizeNativeFetchBody(options.body);
+        }
+        const response = await fetch(requestUrl, {
+            ...requestInit,
+        });
+        if (response.status >= 400 && options.throwOnHttpError !== false) {
+            await drainNativeResponseBody(response);
+            throw new TransportError(`Upstream request failed with status ${response.status}`, {
+                code: "upstream_http_error",
+                status: response.status,
+            });
+        }
+        return toNativeHttpStreamResponse(response);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw error;
+        }
+        throw toHttpTransportError(error);
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+}
+export function createHttpClient(baseUrl, clientOptions = {}) {
+    const warnedMessages = new Set();
+    const warn = clientOptions.warn ?? console.warn;
+    const warnOnce = (message) => {
+        if (warnedMessages.has(message)) {
+            return;
+        }
+        warnedMessages.add(message);
+        warn(message);
+    };
+    async function request(url, method, options = {}) {
+        if (!baseUrl && !isAbsoluteUrl(url)) {
+            throw new TransportError("ctx.http requires an absolute URL when provider.upstream.baseUrl is not declared", { code: "transport_invalid_url" });
+        }
+        assertNoHttpTransportOverrides(options);
+        const headersOptions = withClientHeaders(options, clientOptions, options.body);
+        const methodName = normalizeHttpMethod(method);
+        const retryOptions = normalizeRetryOptions(headersOptions.retry);
+        if (retryOptions)
+            validateUnsafeRetryMethods(retryOptions);
+        const retryEnabled = Boolean(retryOptions &&
+            retryOptions.attempts > 1 &&
+            isMethodRetryable(methodName, retryOptions));
+        const statusRetryEnabled = Boolean(retryEnabled &&
+            retryOptions &&
+            retryOptions.statusCodes.length > 0 &&
+            headersOptions.throwOnHttpError !== false);
+        const attemptOptions = statusRetryEnabled
+            ? { ...headersOptions, throwOnHttpError: false }
+            : headersOptions;
+        const executeOnce = () => fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined);
+        if (!retryEnabled || !retryOptions) {
+            const outcome = await executeOnce();
+            if (isHttpStatusOutcome(outcome)) {
+                throw toUpstreamHttpError(outcome.status);
+            }
+            return outcome;
+        }
+        let lastErrorCode;
+        let lastStatus;
+        for (let attempt = 1; attempt <= retryOptions.attempts; attempt += 1) {
+            try {
+                const outcome = await executeOnce();
+                if (isHttpStatusOutcome(outcome)) {
+                    lastStatus = outcome.status;
+                    if (outcome.retryable && attempt < retryOptions.attempts) {
+                        await sleep(computeRetryDelayMs(retryOptions, attempt, outcome.headers));
+                        continue;
+                    }
+                    throw toUpstreamHttpError(outcome.status);
+                }
+                const response = outcome;
+                if (response.status >= 400 &&
+                    headersOptions.throwOnHttpError !== false) {
+                    throw toUpstreamHttpError(response.status);
+                }
+                if (attempt > 1) {
+                    const summary = {
+                        attempts: attempt,
+                        retries: attempt - 1,
+                        ...(retryOptions.preset ? { preset: retryOptions.preset } : {}),
+                        transport: "native",
+                        ...(lastErrorCode ? { lastErrorCode } : {}),
+                        ...(lastStatus ? { lastStatus } : {}),
+                    };
+                    clientOptions.onRetrySummary?.(summary);
+                }
+                return response;
+            }
+            catch (error) {
+                lastErrorCode = retryErrorCode(error);
+                lastStatus = retryErrorStatus(error);
+                if (attempt < retryOptions.attempts &&
+                    shouldRetryTransportError(error, retryOptions)) {
+                    await sleep(computeRetryDelayMs(retryOptions, attempt));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new TransportError("HTTP retry exhausted without a terminal result", {
+            code: "retry_exhausted",
+        });
+    }
+    async function streamRequest(url, method, options = {}) {
+        if (!baseUrl && !isAbsoluteUrl(url)) {
+            throw new TransportError("ctx.http requires an absolute URL when provider.upstream.baseUrl is not declared", { code: "transport_invalid_url" });
+        }
+        assertNoHttpTransportOverrides(options);
+        const headersOptions = withClientHeaders(options, clientOptions, options.body);
+        const methodName = normalizeHttpMethod(method);
+        return fetchNativeHttpStream(baseUrl, url, methodName, headersOptions, clientOptions, warnOnce);
+    }
+    return {
+        request: async (url, options = {}) => request(url, options.method ?? "GET", options),
+        get: async (url, options) => request(url, "GET", options),
+        post: async (url, body, options) => request(url, "POST", { ...options, body }),
+        put: async (url, body, options) => request(url, "PUT", { ...options, body }),
+        delete: async (url, options) => request(url, "DELETE", options),
+        stream: async (url, options = {}) => streamRequest(url, options.method ?? "GET", options),
+        sse: async (url, options = {}) => {
+            const headers = {
+                Accept: "text/event-stream",
+                ...options.headers,
+            };
+            const response = await streamRequest(url, options.method ?? "GET", {
+                ...options,
+                headers,
+            });
+            return parseSseStream(response.body);
+        },
+    };
+}