@apifuse/provider-sdk 2.2.0-beta.12 → 2.2.0-beta.13

package/dist/runtime/native-network.js

@@ -0,0 +1,477 @@
+import { createHash } from "node:crypto";
+import { Socket } from "node:net";
+import { connect as connectTlsSocket } from "node:tls";
+import { SocksClient } from "socks";
+import { ProxyResolutionError } from "../config/loader.js";
+import { TransportError } from "../errors.js";
+import { hasNodemavenCredentials, nodemavenSessionWindow, synthesizeNodemavenProxy, } from "./proxy-nodemaven.js";
+export class NativeNetworkError extends TransportError {
+    constructor(message, code) {
+        super(message, { code, status: 0 });
+        this.name = "NativeNetworkError";
+    }
+    get code() {
+        return super.code;
+    }
+}
+export class NativeProxyExpiredError extends NativeNetworkError {
+    expiresAt;
+    constructor(expiresAt) {
+        super("Native connection closed at sticky proxy expiry", "native_proxy_expired");
+        this.expiresAt = expiresAt;
+        this.name = "NativeProxyExpiredError";
+    }
+}
+/** Raised when an established connection exceeds its opt-in read-idle window. */
+export class NativeIdleTimeoutError extends NativeNetworkError {
+    constructor() {
+        super("Native network socket timed out while reading.", "native_connection_idle_timeout");
+        this.name = "NativeIdleTimeoutError";
+    }
+}
+function synthesizeNodemavenGateway(input) {
+    if (input.vendor !== "nodemaven" || !hasNodemavenCredentials())
+        return undefined;
+    // NodeMaven defaults ctx.http to HTTP CONNECT because SOCKS5 adds ~500ms per
+    // request. Native LOCO pays this once per long-lived connection and must reach
+    // arbitrary destination ports, so SOCKS5 is mandatory here.
+    const sessionWindow = nodemavenSessionWindow(input.policy, input.now);
+    const synthesized = synthesizeNodemavenProxy({
+        policy: input.policy,
+        affinityKey: input.affinityKey,
+        protocol: "socks5",
+        poolIndex: 0,
+        refreshEpoch: sessionWindow.refreshEpoch,
+        now: input.now,
+        expiresAt: sessionWindow.expiresAt,
+    });
+    return {
+        url: synthesized.url,
+        vendor: "nodemaven",
+        sticky: synthesized.sticky,
+        sessionId: synthesized.sessionId,
+        expiresAt: synthesized.expiresAt,
+    };
+}
+const DEFAULT_GATEWAY_SYNTHESIZERS = [
+    synthesizeNodemavenGateway,
+];
+/** Domain-separated, process-independent affinity derived from credential identity. */
+export function deriveNativeCredentialAffinityKey(credentialIdentity) {
+    return createHash("sha256")
+        .update("apifuse-native-proxy-affinity:v1\0")
+        .update(credentialIdentity)
+        .digest("hex");
+}
+function isStickyPolicy(policy) {
+    return (policy.session?.affinity ?? "request") !== "request";
+}
+function resolveNativeVendorChain(policy) {
+    const declared = policy.providers?.length
+        ? policy.providers
+        : policy.provider
+            ? [policy.provider]
+            : ["nodemaven"];
+    const chain = [];
+    for (const vendor of declared) {
+        if (!chain.includes(vendor))
+            chain.push(vendor);
+    }
+    return chain;
+}
+/** Resolve the first configured native gateway without invoking an allocator API. */
+export function resolveNativeGatewayProxy(input) {
+    if (input.policy.mode === "disabled")
+        return undefined;
+    const synthesizers = input.gatewaySynthesizers ?? DEFAULT_GATEWAY_SYNTHESIZERS;
+    const now = input.now ?? Date.now();
+    for (const vendor of resolveNativeVendorChain(input.policy)) {
+        for (const synthesize of synthesizers) {
+            const resolved = synthesize({
+                vendor,
+                policy: input.policy,
+                affinityKey: input.affinityKey,
+                now,
+            });
+            if (resolved && resolved.vendor === vendor)
+                return resolved;
+        }
+    }
+    return undefined;
+}
+function proxyRequiredError(policy) {
+    const chain = resolveNativeVendorChain(policy).filter((vendor) => vendor === "smartproxy" || vendor === "nodemaven");
+    return new ProxyResolutionError("PROXY_REQUIRED", `Native proxy egress is required but no gateway vendor in [${chain.join(", ") || "none"}] resolved.`, { vendorChain: chain });
+}
+function deadlineFrom(timeoutMs) {
+    if (timeoutMs === undefined)
+        return undefined;
+    return Date.now() + Math.max(0, timeoutMs);
+}
+function remainingMs(deadline) {
+    return deadline === undefined ? undefined : Math.max(0, deadline - Date.now());
+}
+function abortError() {
+    return new NativeNetworkError("Native connection was aborted", "native_connection_aborted");
+}
+function timeoutError() {
+    return new NativeNetworkError("Native connection timed out", "native_connection_timeout");
+}
+function failedError() {
+    return new NativeNetworkError("Native connection failed", "native_connection_failed");
+}
+function assertCanStart(signal, deadline) {
+    if (signal?.aborted)
+        throw abortError();
+    if (deadline !== undefined && deadline <= Date.now())
+        throw timeoutError();
+}
+async function waitForSocketEvent(socket, event, signal, deadline) {
+    assertCanStart(signal, deadline);
+    await new Promise((resolve, reject) => {
+        let timer;
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            socket.off(event, onReady);
+            socket.off("error", onError);
+            socket.off("close", onClose);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const finish = (error) => {
+            cleanup();
+            if (error) {
+                socket.on("error", () => undefined);
+                socket.destroy();
+                reject(error);
+            }
+            else
+                resolve();
+        };
+        const onReady = () => finish();
+        const onError = () => finish(failedError());
+        const onClose = () => finish(failedError());
+        const onAbort = () => finish(abortError());
+        socket.once(event, onReady);
+        socket.once("error", onError);
+        socket.once("close", onClose);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        const remaining = remainingMs(deadline);
+        if (remaining !== undefined)
+            timer = setTimeout(() => finish(timeoutError()), remaining);
+    });
+}
+async function connectPlainSocket(host, port, signal, deadline) {
+    assertCanStart(signal, deadline);
+    const socket = new Socket();
+    const ready = waitForSocketEvent(socket, "connect", signal, deadline);
+    socket.connect({ host, port });
+    await ready;
+    return socket;
+}
+function parseSocks5Proxy(proxyUrl) {
+    let parsed;
+    try {
+        parsed = new URL(proxyUrl);
+    }
+    catch {
+        throw new NativeNetworkError("Native proxy URL is invalid", "native_proxy_invalid");
+    }
+    const port = Number(parsed.port);
+    if (parsed.protocol !== "socks5:" || !parsed.hostname || !Number.isInteger(port) || port <= 0) {
+        throw new NativeNetworkError("Native proxy URL is invalid", "native_proxy_invalid");
+    }
+    try {
+        return {
+            host: parsed.hostname,
+            port,
+            ...(parsed.username ? { userId: decodeURIComponent(parsed.username) } : {}),
+            ...(parsed.password ? { password: decodeURIComponent(parsed.password) } : {}),
+        };
+    }
+    catch {
+        throw new NativeNetworkError("Native proxy URL is invalid", "native_proxy_invalid");
+    }
+}
+async function waitForSocksHandshake(proxySocket, promise, signal, deadline) {
+    assertCanStart(signal, deadline);
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        const finish = (error, socket) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error) {
+                proxySocket.destroy();
+                reject(error);
+            }
+            else if (socket)
+                resolve(socket);
+            else
+                reject(failedError());
+        };
+        const onAbort = () => finish(abortError());
+        signal?.addEventListener("abort", onAbort, { once: true });
+        const remaining = remainingMs(deadline);
+        if (remaining !== undefined)
+            timer = setTimeout(() => finish(timeoutError()), remaining);
+        void promise.then((result) => finish(undefined, result.socket), (error) => finish(error instanceof Error && /\b(?:timed out|timeout)\b/i.test(error.message)
+            ? timeoutError()
+            : failedError()));
+    });
+}
+async function connectSocksTunnel(proxy, input, deadline) {
+    const parsed = parseSocks5Proxy(proxy.url);
+    const proxySocket = await connectPlainSocket(parsed.host, parsed.port, input.signal, deadline);
+    // `socks` removes its internal listeners as the handshake settles. Keep a
+    // credential-free sink on the owned socket so an abort/close race cannot emit
+    // an unhandled late network error between library cleanup and our wrapper.
+    proxySocket.on("error", () => undefined);
+    const remaining = remainingMs(deadline);
+    const handshake = SocksClient.createConnection({
+        command: "connect",
+        destination: { host: input.host, port: input.port },
+        proxy: { type: 5, ...parsed },
+        existing_socket: proxySocket,
+        ...(remaining === undefined ? {} : { timeout: Math.max(1, remaining) }),
+    });
+    return await waitForSocksHandshake(proxySocket, handshake, input.signal, deadline);
+}
+async function upgradeTls(socket, input, deadline) {
+    assertCanStart(input.signal, deadline);
+    const tlsSocket = socket
+        ? connectTlsSocket({
+            socket,
+            servername: input.serverName ?? input.host,
+            rejectUnauthorized: input.rejectUnauthorized,
+        })
+        : connectTlsSocket({
+            host: input.host,
+            port: input.port,
+            servername: input.serverName ?? input.host,
+            rejectUnauthorized: input.rejectUnauthorized,
+        });
+    await waitForSocketEvent(tlsSocket, "secureConnect", input.signal, deadline);
+    return tlsSocket;
+}
+export function createNativeNetworkConnection(socket, proxy, options, idleTimeoutMs) {
+    const warn = options.warn ?? console.warn;
+    let terminalError;
+    let closeReason;
+    let drainHandler;
+    let idleTimer;
+    let expiringTimer;
+    let hardExpiryTimer;
+    let lifecycleSettled = false;
+    let settleLifecycle = () => undefined;
+    const lifecycleCutoff = new Promise((resolve) => {
+        settleLifecycle = resolve;
+    });
+    const clearIdleTimer = () => {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = undefined;
+    };
+    const resetIdleTimer = () => {
+        clearIdleTimer();
+        if (idleTimeoutMs === undefined || socket.readableEnded || socket.destroyed)
+            return;
+        idleTimer = setTimeout(() => {
+            idleTimer = undefined;
+            if (socket.readableEnded || socket.destroyed)
+                return;
+            closeReason = new NativeIdleTimeoutError();
+            socket.destroy(closeReason);
+        }, Math.max(0, idleTimeoutMs));
+        idleTimer.unref?.();
+    };
+    const clearLifecycle = () => {
+        clearIdleTimer();
+        if (lifecycleSettled)
+            return;
+        lifecycleSettled = true;
+        if (expiringTimer)
+            clearTimeout(expiringTimer);
+        if (hardExpiryTimer)
+            clearTimeout(hardExpiryTimer);
+        settleLifecycle();
+    };
+    socket.on("error", (error) => {
+        terminalError = error;
+    });
+    socket.once("end", clearIdleTimer);
+    socket.once("close", clearLifecycle);
+    resetIdleTimer();
+    const expiresAt = proxy?.sticky ? proxy.expiresAt : undefined;
+    const leadSeconds = options.proxyPolicy?.session?.drainLeadSeconds;
+    const expiresAtMs = expiresAt ? Date.parse(expiresAt) : Number.NaN;
+    if (expiresAt &&
+        Number.isFinite(expiresAtMs) &&
+        typeof leadSeconds === "number" &&
+        Number.isFinite(leadSeconds) &&
+        leadSeconds >= 0) {
+        const event = {
+            expiresAt,
+            leadSeconds,
+            reason: "sticky_expiry",
+        };
+        const remaining = Math.max(0, expiresAtMs - Date.now());
+        const leadDelay = Math.max(0, remaining - leadSeconds * 1_000);
+        expiringTimer = setTimeout(() => {
+            expiringTimer = undefined;
+            const handler = drainHandler;
+            if (!handler) {
+                warn("Native sticky proxy is expiring without a drain handler");
+                return;
+            }
+            void (async () => {
+                try {
+                    await Promise.race([Promise.resolve(handler(event)), lifecycleCutoff]);
+                }
+                catch {
+                    // Drain failures do not bypass the hard-expiry fail-safe.
+                }
+            })();
+        }, leadDelay);
+        expiringTimer.unref?.();
+        hardExpiryTimer = setTimeout(() => {
+            hardExpiryTimer = undefined;
+            if (socket.destroyed)
+                return;
+            closeReason = new NativeProxyExpiredError(expiresAt);
+            settleLifecycle();
+            socket.destroy();
+        }, remaining);
+        hardExpiryTimer.unref?.();
+    }
+    const read = async () => {
+        if (closeReason)
+            throw closeReason;
+        if (terminalError)
+            throw failedError();
+        const chunk = socket.read();
+        if (chunk) {
+            resetIdleTimer();
+            return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        }
+        if (socket.readableEnded || socket.destroyed)
+            return null;
+        await new Promise((resolve) => {
+            const cleanup = () => {
+                socket.off("readable", onReadable);
+                socket.off("end", onDone);
+                socket.off("close", onDone);
+                socket.off("error", onDone);
+            };
+            const onReadable = () => {
+                cleanup();
+                resolve();
+            };
+            const onDone = () => {
+                cleanup();
+                resolve();
+            };
+            socket.once("readable", onReadable);
+            socket.once("end", onDone);
+            socket.once("close", onDone);
+            socket.once("error", onDone);
+        });
+        return await read();
+    };
+    return {
+        get closeReason() {
+            return closeReason;
+        },
+        ...(proxy
+            ? {
+                proxy: {
+                    vendor: proxy.vendor,
+                    sticky: proxy.sticky,
+                    sessionId: proxy.sessionId,
+                    expiresAt: proxy.expiresAt,
+                },
+            }
+            : {}),
+        read,
+        onExpiring: (handler) => {
+            drainHandler = handler;
+        },
+        write: async (data) => {
+            if (closeReason)
+                throw closeReason;
+            if (socket.destroyed) {
+                throw new NativeNetworkError("Native connection is closed", "native_connection_closed");
+            }
+            await new Promise((resolve, reject) => {
+                socket.write(data, (error) => {
+                    if (error)
+                        reject(failedError());
+                    else
+                        resolve();
+                });
+            });
+        },
+        close: async () => {
+            if (socket.closed || socket.destroyed) {
+                clearLifecycle();
+                return;
+            }
+            await new Promise((resolve) => {
+                socket.once("close", () => resolve());
+                socket.destroy();
+            });
+        },
+    };
+}
+async function resolveConnectionProxy(options, input) {
+    const policy = options.proxyPolicy;
+    if (!policy || policy.mode === "disabled")
+        return undefined;
+    const explicitAffinityKey = input.affinityKey ?? options.affinityKey;
+    const affinityKey = explicitAffinityKey ??
+        (isStickyPolicy(policy) && options.credentialIdentity !== undefined
+            ? deriveNativeCredentialAffinityKey(options.credentialIdentity)
+            : undefined);
+    const resolved = resolveNativeGatewayProxy({
+        policy,
+        affinityKey,
+        gatewaySynthesizers: options.gatewaySynthesizers,
+    });
+    if (!resolved && policy.mode === "required")
+        throw proxyRequiredError(policy);
+    return resolved;
+}
+/** Create the SDK byte-stream runtime; deployment egress authorization stays delegated. */
+export function createNativeNetworkClient(options = {}) {
+    return {
+        connectTcp: async (input) => {
+            const deadline = deadlineFrom(input.timeoutMs);
+            assertCanStart(input.signal, deadline);
+            const proxy = await resolveConnectionProxy(options, input);
+            const socket = proxy
+                ? await connectSocksTunnel(proxy, input, deadline)
+                : await connectPlainSocket(input.host, input.port, input.signal, deadline);
+            return createNativeNetworkConnection(socket, proxy, options, input.idleTimeoutMs);
+        },
+        connectTls: async (input) => {
+            const deadline = deadlineFrom(input.timeoutMs);
+            assertCanStart(input.signal, deadline);
+            const proxy = await resolveConnectionProxy(options, input);
+            const tunnel = proxy ? await connectSocksTunnel(proxy, input, deadline) : undefined;
+            const socket = await upgradeTls(tunnel, input, deadline);
+            return createNativeNetworkConnection(socket, proxy, options, input.idleTimeoutMs);
+        },
+        grantTcpEgress: (input) => {
+            if (options.grantTcpEgress)
+                return options.grantTcpEgress(input);
+            throw new NativeNetworkError("Dynamic native egress authorization is not configured", "native_dynamic_egress_unsupported");
+        },
+    };
+}

package/dist/runtime/proxy-nodemaven.d.ts

@@ -14,6 +14,13 @@ export declare const NODEMAVEN_DEFAULT_PROTOCOL: ProxyProtocol;
 export declare const NODEMAVEN_MAX_POOL_SIZE = 50;
 export declare function hasNodemavenCredentials(): boolean;
 export declare function nodemavenPoolSize(policy: ProviderProxyPolicy): number;
+export declare function nodemavenLifetimeMinutes(policy: ProviderProxyPolicy): number;
+export type NodemavenSessionWindow = {
+    refreshEpoch: number;
+    expiresAt: string;
+};
+/** Stable wall-clock window shared by every process deriving the same sticky sid. */
+export declare function nodemavenSessionWindow(policy: ProviderProxyPolicy, now?: number): NodemavenSessionWindow;
 export type NodemavenSynthesisInput = {
     policy: ProviderProxyPolicy;
     affinityKey: string | undefined;
@@ -22,10 +29,17 @@ export type NodemavenSynthesisInput = {
     refreshEpoch: number;
     /** ISO 3166-1 alpha-2, already resolved by the caller (falls back to env). */
     country?: string;
+    /** Clock injection used by native sticky-expiry lifecycle tests. */
+    now?: number;
+    /** Stable caller-owned hard expiry when the refresh epoch is wall-clock-derived. */
+    expiresAt?: string;
 };
 export type NodemavenSynthesis = {
     url: string;
     protocol: ProxyProtocol;
+    sticky: boolean;
+    sessionId: string;
+    expiresAt?: string;
     diagnostics: Record<string, string | number | boolean>;
 };
 /**

package/dist/runtime/proxy-nodemaven.js

@@ -42,13 +42,22 @@ function resolveNodemavenFilter() {
 export function nodemavenPoolSize(policy) {
     return Math.min(NODEMAVEN_MAX_POOL_SIZE, Math.max(1, Math.floor(policy.session?.poolSize ?? DEFAULT_NODEMAVEN_POOL_SIZE)));
 }
-function nodemavenLifetimeMinutes(policy) {
+export function nodemavenLifetimeMinutes(policy) {
     const configured = policy.session?.lifetimeMinutes;
     if (typeof configured !== "number" || !Number.isFinite(configured) || configured <= 0) {
         return NODEMAVEN_MAX_LIFETIME_MINUTES;
     }
     return Math.min(NODEMAVEN_MAX_LIFETIME_MINUTES, Math.max(1, Math.floor(configured)));
 }
+/** Stable wall-clock window shared by every process deriving the same sticky sid. */
+export function nodemavenSessionWindow(policy, now = Date.now()) {
+    const lifetimeMs = nodemavenLifetimeMinutes(policy) * 60_000;
+    const refreshEpoch = Math.floor(now / lifetimeMs);
+    return {
+        refreshEpoch,
+        expiresAt: new Date((refreshEpoch + 1) * lifetimeMs).toISOString(),
+    };
+}
 /** NodeMaven username tokens accept `[a-z0-9]`; slugify geo values to that set. */
 function slugifyGeo(value) {
     if (!value)
@@ -97,6 +106,7 @@ export function synthesizeNodemavenProxy(input) {
     const sid = deriveSid(input.policy, input.affinityKey, input.poolIndex, input.refreshEpoch);
     const port = selectPort(input.protocol, sid, input.poolIndex);
     const lifetimeMinutes = nodemavenLifetimeMinutes(input.policy);
+    const sticky = isStickyAffinity(input.policy);
     const country = slugifyGeo(input.country ?? input.policy.geo?.country);
     const region = slugifyGeo(input.policy.geo?.subdivision);
     const city = slugifyGeo(input.policy.geo?.city);
@@ -116,10 +126,18 @@ export function synthesizeNodemavenProxy(input) {
     return {
         url,
         protocol: input.protocol,
+        sticky,
+        sessionId: sid,
+        ...(sticky
+            ? {
+                expiresAt: input.expiresAt ??
+                    new Date((input.now ?? Date.now()) + lifetimeMinutes * 60_000).toISOString(),
+            }
+            : {}),
         diagnostics: {
             vendor: "nodemaven",
             protocol: input.protocol,
-            sticky: isStickyAffinity(input.policy),
+            sticky,
             filter,
             lifetimeMinutes,
             ...(country ? { country } : {}),

package/dist/runtime/request-options.d.ts

@@ -1,3 +1,70 @@
-import type { RequestParams } from "../types.js";
+import type { HttpClient, RequestOptions, RequestParams } from "../types.js";
+export declare const REDACTED_QUERY_VALUE = "[REDACTED]";
+/** Internal heuristic shared by diagnostic and fixture structural redaction. */
+export declare function isSensitiveKey(key: string): boolean;
+declare const HTTP_REQUEST_METHOD_CONFIG: {
+    readonly request: {
+        readonly optionsIndex: 1;
+    };
+    readonly get: {
+        readonly optionsIndex: 1;
+    };
+    readonly post: {
+        readonly optionsIndex: 2;
+    };
+    readonly put: {
+        readonly optionsIndex: 2;
+    };
+    readonly delete: {
+        readonly optionsIndex: 1;
+    };
+    readonly stream: {
+        readonly optionsIndex: 1;
+    };
+    readonly sse: {
+        readonly optionsIndex: 1;
+    };
+};
+export type HttpRequestMethod = keyof typeof HTTP_REQUEST_METHOD_CONFIG;
+export type HttpRequestInvocation = {
+    [M in HttpRequestMethod]: {
+        method: M;
+        args: Parameters<HttpClient[M]>;
+    };
+}[HttpRequestMethod];
+export declare const HTTP_REQUEST_METHOD_NAMES: HttpRequestMethod[];
+export declare function isHttpRequestMethod(method: PropertyKey): method is HttpRequestMethod;
+export type SerializedRequestUrl = {
+    requestUrl: string;
+    redactedUrl: string;
+    sensitiveValues: readonly string[];
+};
+export declare function normalizeSensitiveParams(sensitiveParams?: Record<string, string>): Record<string, string> | undefined;
 export declare function appendQueryParams(url: string, params?: RequestParams): string;
+/** Redacts matching query keys without reserializing any other URL bytes. */
+export declare function redactUrlQueryParams(url: string, sensitiveParamNames: readonly string[]): {
+    redactedUrl: string;
+    sensitiveValues: readonly string[];
+};
+/**
+ * Serializes public and secret query parameters together while constructing a
+ * separate, structurally redacted URL for diagnostics and observability.
+ */
+export declare function serializeRequestUrl(url: string, params?: RequestParams, sensitiveParams?: Record<string, string>): SerializedRequestUrl;
+/** Scrubs raw and URL-encoded secret values from diagnostic text. */
+export declare function redactSensitiveText(text: string, sensitiveValues: readonly string[], requestUrl?: string, redactedUrl?: string): string;
+/**
+ * Redacts error text and recursively serializable diagnostic metadata.
+ * Mutable errors retain identity; readonly/frozen errors may be replaced, so
+ * callers must use the returned value.
+ */
+export declare function redactSensitiveError<T>(error: T, sensitiveValues: readonly string[], requestUrl?: string, redactedUrl?: string): T;
+/** Redacts failures that occur before a request URL can be fully serialized. */
+export declare function redactSensitiveRequestError<T>(error: T, url: string, sensitiveParams?: Record<string, string>): T;
+/** Validates an untyped proxy invocation before narrowing it to the HttpClient contract. */
+export declare function parseHttpRequestInvocation(method: PropertyKey, args: unknown[]): HttpRequestInvocation | undefined;
+/** Internal typed registry for the request-options position of HttpClient calls. */
+export declare function requestOptionsFromHttpInvocation(invocation: HttpRequestInvocation): RequestOptions | undefined;
+export declare function replaceRequestOptionsInHttpInvocation(invocation: HttpRequestInvocation, options: RequestOptions): void;
 export declare function normalizeHttpRequestBody(body: unknown): string | Buffer | undefined;
+export {};