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

package/dist/runtime/stealth.js

@@ -1,11 +1,12 @@
 import { createHash } from "node:crypto";
 import { Impit } from "impit";
-import { DEFAULT_SMARTPROXY_POOL_SIZE, invalidateProxyResolutionCacheAsync, policyResolvesRegistryVendorChain, ProxyResolutionError, resolvePolicyProxyPoolSpan, resolvePolicyTransportAttemptCap, resolveProxyConfigAsync, vendorFromResolvedSource, } from "../config/loader.js";
-import { SDKError, TransportError } from "../errors.js";
+import { Cookie, CookieJar as ToughCookieJar } from "tough-cookie";
+import { DEFAULT_SMARTPROXY_POOL_SIZE, invalidateProxyResolutionCacheAsync, ProxyResolutionError, policyResolvesRegistryVendorChain, resolvePolicyProxyPoolSpan, resolvePolicyTransportAttemptCap, resolveProxyConfigAsync, vendorFromResolvedSource, } from "../config/loader.js";
+import { SDKError, StealthCookieStoreVersionError, TransportError } from "../errors.js";
 import { getStealthProfile } from "../stealth/profiles.js";
 import { createProxyAuthIpDeniedError, createProxyEdgeAuthRejectedError, createProxyEdgeTlsRejectedError, createProxyPoolExhaustedError, createProxyPoolStaleError, isProxyAuthIpDeniedMessage, isProxyEdgeAuthRejectedMessage, isProxyEdgeTlsRejectedResponse, isProxyPoolRefreshableError, isProxyPoolStaleMessage, isProxyPoolStaleStatus, PROXY_EDGE_AUTH_REJECTED_CODE, PROXY_POOL_STALE_CODE, } from "./proxy-errors.js";
 import { computeProxyAttemptIndex, computeProxyTransportRetryDelayMs, createDefaultProxyTransportRetryOptions, normalizeProxyTransportRetryOptions, shouldRetryProxyTransportAttempt, validateUnsafeProxyTransportRetryMethods, } from "./proxy-retry-policy.js";
-import { appendQueryParams } from "./request-options.js";
+import { isSensitiveKey, redactSensitiveError, redactSensitiveRequestError, redactSensitiveText, redactUrlQueryParams, normalizeSensitiveParams, serializeRequestUrl, } from "./request-options.js";
 const DEFAULT_PROFILE = "chrome-146";
 const MISSING_PROXY_WARNING = "[provider-sdk] Provider requested proxy routing, but no proxy URL was configured. Continuing without proxy.";
 const MAX_POLICY_PROXY_POOL_REFRESHES = 1;
@@ -14,6 +15,14 @@ const PROXY_CONNECT_FAILURE_BODY_PATTERN = /\bproxy\b.*\b(non[\s-]?200|connect|t
 const PROXY_AUTH_DIAGNOSTIC_URL = "http://example.com/";
 const PROXY_AUTH_DIAGNOSTIC_TIMEOUT_MS = 5_000;
 const STEALTH_PROXY_TRANSPORT_RETRY_ERROR_CODES = [PROXY_CONNECT_FAILURE_CODE];
+function sensitiveQueryParamNames(url) {
+    const queryStart = url.indexOf("?");
+    if (queryStart === -1)
+        return [];
+    const fragmentStart = url.indexOf("#", queryStart);
+    const query = url.slice(queryStart + 1, fragmentStart === -1 ? undefined : fragmentStart);
+    return [...new URLSearchParams(query).keys()].filter(isSensitiveKey);
+}
 const REMOVED_CHROME_PROFILE_NAMES = new Set([
     "chrome-120",
     "chrome-124",
@@ -49,69 +58,128 @@ const FIREFOX_IMPIT_BY_MAJOR = {
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
+const LEGACY_COOKIE_ORIGIN = "https://legacy-cookie.invalid/";
 class CookieJarImpl {
     cookies;
-    constructor(cookieStrings) {
-        this.cookies = {};
+    defaultUrl;
+    constructor(cookieStrings, defaultUrl = LEGACY_COOKIE_ORIGIN) {
+        this.cookies = new ToughCookieJar(undefined, {
+            allowSecureOnLocal: false,
+            rejectPublicSuffixes: true,
+        });
+        this.defaultUrl = this.normalizeUrl(defaultUrl) ?? LEGACY_COOKIE_ORIGIN;
         this.setFromCookieStrings(cookieStrings);
     }
-    setFromCookieStrings(cookieStrings) {
+    /**
+     * URL-less legacy operations are scoped to this jar's default URL. Session
+     * jars use the client's base URL and response jars use the response URL. A
+     * flat restore has no attributes to recover, so it creates host-only Path=/
+     * cookies for that default URL instead of making them visible to every host.
+     */
+    setFromCookieStrings(cookieStrings, url = this.defaultUrl) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return;
         for (const cookieString of cookieStrings) {
-            const [nameValue] = cookieString.split(";");
-            if (!nameValue) {
-                continue;
-            }
-            const separatorIndex = nameValue.indexOf("=");
-            if (separatorIndex === -1) {
-                continue;
-            }
-            const name = nameValue.slice(0, separatorIndex).trim();
-            const value = nameValue.slice(separatorIndex + 1).trim();
-            if (name)
-                this.cookies[name] = value;
+            this.cookies.setCookieSync(cookieString, cookieUrl, { ignoreError: true });
         }
     }
-    get(name) {
-        return this.cookies[name];
+    get(name, url) {
+        return this.getAll(url)[name];
     }
-    getAll() {
-        return { ...this.cookies };
+    getAll(url) {
+        return Object.fromEntries(this.getUniqueCookies(url ?? this.defaultUrl).map((cookie) => [cookie.key, cookie.value]));
     }
-    has(name) {
-        return Object.hasOwn(this.cookies, name);
+    has(name, url) {
+        return Object.hasOwn(this.getAll(url), name);
     }
-    toString() {
-        return Object.entries(this.cookies)
-            .map(([name, value]) => `${name}=${value}`)
+    toString(url) {
+        return this.getUniqueCookies(url ?? this.defaultUrl)
+            .map((cookie) => cookie.cookieString())
             .join("; ");
     }
-    toHeader() {
-        return this.toString();
+    toHeader(url) {
+        return this.toString(url);
     }
     snapshot() {
-        return this.getAll();
+        // This compatibility view deliberately enumerates the serialized store,
+        // not getAll(defaultUrl): persistence must include sibling hosts and paths.
+        // Duplicate names still collapse because a flat map cannot represent them.
+        const entries = [];
+        for (const cookie of this.serialize().jar.cookies) {
+            if (typeof cookie.key === "string" && typeof cookie.value === "string" && cookie.key) {
+                entries.push([cookie.key, cookie.value]);
+            }
+        }
+        return Object.fromEntries(entries);
     }
     restore(cookies) {
         this.clear();
         for (const [name, value] of Object.entries(cookies)) {
-            if (name)
-                this.cookies[name] = value;
+            if (!name)
+                continue;
+            this.cookies.setCookieSync(new Cookie({ key: name, path: "/", value }), this.defaultUrl, {
+                ignoreError: true,
+            });
         }
     }
-    clear() {
-        for (const name of Object.keys(this.cookies)) {
-            delete this.cookies[name];
+    serialize() {
+        const jar = this.cookies.serializeSync();
+        if (!jar) {
+            throw new SDKError("Stealth cookie store could not be serialized", {
+                code: "stealth_cookie_store_serialize_failed",
+            });
+        }
+        return { version: 1, jar };
+    }
+    deserialize(state) {
+        const version = isRecord(state) ? state.version : undefined;
+        if (version !== 1) {
+            throw new StealthCookieStoreVersionError(version);
         }
+        // Deserialize into a new jar first so invalid state cannot partially clear
+        // or replace a live session. tough-cookie restores the cookie attributes and
+        // matching semantics represented in its own serialized format.
+        const restored = ToughCookieJar.deserializeSync(state.jar);
+        // tough-cookie 6 does not include this option in serializeSync(). Preserve
+        // the SDK's stricter setting across restoration.
+        Reflect.set(restored, "allowSecureOnLocal", false);
+        this.cookies = restored;
+    }
+    clear() {
+        this.cookies.removeAllCookiesSync();
     }
-    find(predicate) {
-        for (const [name, value] of Object.entries(this.cookies)) {
-            const cookie = `${name}=${value}`;
-            if (predicate(cookie)) {
-                return cookie;
+    find(predicate, url) {
+        for (const cookie of this.getUniqueCookies(url ?? this.defaultUrl)) {
+            const cookieString = cookie.cookieString();
+            if (predicate(cookieString)) {
+                return cookieString;
             }
         }
         return undefined;
     }
+    normalizeUrl(url) {
+        try {
+            return new URL(url).toString();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    getUniqueCookies(url) {
+        const cookieUrl = this.normalizeUrl(url);
+        if (!cookieUrl)
+            return [];
+        // tough-cookie returns longer (more-specific) paths first. Keeping the
+        // first cookie for each name prevents ambiguous duplicate-name headers.
+        const names = new Set();
+        return this.cookies.getCookiesSync(cookieUrl).filter((cookie) => {
+            if (names.has(cookie.key))
+                return false;
+            names.add(cookie.key);
+            return true;
+        });
+    }
 }
 function closestImpitBrowser(major, candidates) {
     let closestMajor;
@@ -175,13 +243,13 @@ function hasOwn(object, key) {
 }
 function toImpitCookieJar(cookieJar) {
     return {
-        setCookie(cookie, _url, cb) {
-            cookieJar.setFromCookieStrings([cookie]);
+        setCookie(cookie, url, cb) {
+            cookieJar.setFromCookieStrings([cookie], url);
             if (typeof cb === "function")
                 cb();
         },
-        getCookieString(_url) {
-            return cookieJar.toString();
+        getCookieString(url) {
+            return cookieJar.toHeader(url);
         },
     };
 }
@@ -233,10 +301,12 @@ function splitCombinedSetCookieHeader(headerValue) {
         cookieStrings.push(finalCookie);
     return cookieStrings;
 }
-export async function normalizeResponse(response, requestUrl) {
+export async function normalizeResponse(response, requestUrl, maxBodyBytes) {
     const headers = Object.fromEntries(response.headers.entries());
-    const cookies = new CookieJarImpl(setCookieHeadersFromResponse(response.headers));
-    const bodyBytes = await response.arrayBuffer();
+    const cookies = new CookieJarImpl(setCookieHeadersFromResponse(response.headers), response.url ?? requestUrl);
+    const bodyBytes = maxBodyBytes === undefined
+        ? await response.arrayBuffer()
+        : await readResponseBodyWithLimit(response, maxBodyBytes);
     const body = new TextDecoder().decode(bodyBytes);
     return {
         status: response.status,
@@ -262,6 +332,75 @@ export async function normalizeResponse(response, requestUrl) {
         },
     };
 }
+function responseTooLargeError(maxBodyBytes, observedBytes) {
+    return new TransportError(`Response body exceeded maxBodyBytes limit of ${maxBodyBytes} bytes (observed ${observedBytes} bytes)`, {
+        code: "response_too_large",
+        category: "upstream_http",
+        retryable: false,
+        status: 0,
+    });
+}
+function declaredContentLength(headers) {
+    const contentLength = headers.get("content-length")?.trim();
+    if (!contentLength || !/^\d+$/.test(contentLength))
+        return undefined;
+    const parsed = Number(contentLength);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function abortTransportResponse(response) {
+    if (!response.abort)
+        return false;
+    try {
+        response.abort();
+    }
+    catch {
+        // The size error remains the primary failure if impit has already closed the response.
+    }
+    return true;
+}
+async function readResponseBodyWithLimit(response, maxBodyBytes) {
+    const contentLength = declaredContentLength(response.headers);
+    if (contentLength !== undefined && contentLength > maxBodyBytes) {
+        if (!abortTransportResponse(response)) {
+            await response.body?.cancel().catch(() => undefined);
+        }
+        throw responseTooLargeError(maxBodyBytes, contentLength);
+    }
+    if (!response.body) {
+        throw new TransportError("Response body stream is unavailable", {
+            code: "transport_stream_unavailable",
+            category: "upstream_http",
+            status: 0,
+        });
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let receivedBytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            receivedBytes += value.byteLength;
+            if (receivedBytes > maxBodyBytes) {
+                await reader.cancel().catch(() => undefined);
+                abortTransportResponse(response);
+                throw responseTooLargeError(maxBodyBytes, receivedBytes);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bodyBytes = new Uint8Array(receivedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bodyBytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bodyBytes.buffer;
+}
 function normalizeBody(body) {
     if (body === undefined) {
         return "";
@@ -441,7 +580,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
     let closed = false;
     let hasWarnedMissingProxy = false;
     const warn = clientOptions.warn ?? console.warn;
-    const cookieJar = new CookieJarImpl([]);
+    const cookieJar = new CookieJarImpl([], baseUrl);
     const impitCookieJar = toImpitCookieJar(cookieJar);
     function getClient(profileName, proxyUrl, ignoreTlsErrors) {
         if (closed) {
@@ -492,21 +631,29 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
     }
     const session = {
         async fetch(url, options = {}) {
-            const method = normalizeMethod(options.method ?? "GET");
-            const hasExplicitRetryPolicy = options.retry !== undefined;
-            const stealthRetryOptions = normalizeProxyTransportRetryOptions(options.retry, {
-                extraErrorCodes: STEALTH_PROXY_TRANSPORT_RETRY_ERROR_CODES,
-                label: "Stealth",
-            }) ??
-                (hasExplicitRetryPolicy
-                    ? undefined
-                    : createDefaultProxyTransportRetryOptions({
+            const { hasExplicitRetryPolicy, method, stealthRetryOptions } = (() => {
+                try {
+                    const method = normalizeMethod(options.method ?? "GET");
+                    const hasExplicitRetryPolicy = options.retry !== undefined;
+                    const stealthRetryOptions = normalizeProxyTransportRetryOptions(options.retry, {
                         extraErrorCodes: STEALTH_PROXY_TRANSPORT_RETRY_ERROR_CODES,
                         label: "Stealth",
-                    }));
-            if (stealthRetryOptions) {
-                validateUnsafeProxyTransportRetryMethods(stealthRetryOptions, "Stealth");
-            }
+                    }) ??
+                        (hasExplicitRetryPolicy
+                            ? undefined
+                            : createDefaultProxyTransportRetryOptions({
+                                extraErrorCodes: STEALTH_PROXY_TRANSPORT_RETRY_ERROR_CODES,
+                                label: "Stealth",
+                            }));
+                    if (stealthRetryOptions) {
+                        validateUnsafeProxyTransportRetryMethods(stealthRetryOptions, "Stealth");
+                    }
+                    return { hasExplicitRetryPolicy, method, stealthRetryOptions };
+                }
+                catch (error) {
+                    throw redactSensitiveRequestError(error, url, options.sensitiveParams);
+                }
+            })();
             const hasPolicyProxy = isPolicyManagedProxy(clientOptions);
             const usesPolicyAllocator = hasPolicyProxy && !options.proxy && !clientOptions.proxy;
             const retryAttemptCap = Math.max(1, stealthRetryOptions?.attempts ?? 1);
@@ -540,6 +687,11 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                 for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
                     let proxy;
                     let attemptProxy;
+                    // Reuse the exact serialization used by this outbound attempt in its catch path.
+                    let serializedUrl;
+                    let fallbackSensitiveValues = [];
+                    let fallbackRequestUrl;
+                    let fallbackRedactedUrl;
                     const attemptStartedAt = Date.now();
                     let attemptRecorded = false;
                     const recordProxyAttempt = (outcome, errorCode, status) => {
@@ -560,6 +712,16 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                         });
                     };
                     try {
+                        const sensitiveParams = normalizeSensitiveParams(options.sensitiveParams);
+                        const structural = redactUrlQueryParams(url, Object.keys(sensitiveParams ?? {}));
+                        fallbackSensitiveValues = [
+                            ...new Set([
+                                ...Object.values(sensitiveParams ?? {}).map(String),
+                                ...structural.sensitiveValues,
+                            ]),
+                        ].filter((value) => value !== "");
+                        fallbackRequestUrl = url;
+                        fallbackRedactedUrl = structural.redactedUrl;
                         assertNoUnsupportedFingerprintOverrides(options);
                         attemptProxy = await resolveRequestProxy(options, attempt, refreshAttempt);
                         proxy = attemptProxy.url;
@@ -577,10 +739,11 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                         const ignoreTlsErrors = Boolean(options.stealth?.insecureSkipVerify ??
                             (!hasPolicyProxy && proxy && clientOptions.proxyStealth?.insecureSkipVerify));
                         const profileName = options.profile ?? defaultProfile;
-                        const requestUrl = appendQueryParams(resolveUrl(baseUrl, url), options.params);
+                        serializedUrl = serializeRequestUrl(resolveUrl(baseUrl, url), options.params, sensitiveParams);
+                        const { requestUrl } = serializedUrl;
                         const headers = { ...(options.headers ?? {}) };
                         if (!hasHeader(headers, "Cookie")) {
-                            const cookieHeader = cookieJar.toString();
+                            const cookieHeader = cookieJar.toHeader(requestUrl);
                             if (cookieHeader)
                                 headers.Cookie = cookieHeader;
                         }
@@ -594,8 +757,8 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                             requestInit.body = normalizeBody(options.body);
                         }
                         const response = await getClient(profileName, proxy, ignoreTlsErrors).fetch(requestUrl, requestInit);
-                        const normalized = await normalizeResponse(response, requestUrl);
-                        cookieJar.setFromCookieStrings(setCookieHeadersFromResponse(response.headers));
+                        const normalized = await normalizeResponse(response, requestUrl, options.maxBodyBytes);
+                        cookieJar.setFromCookieStrings(setCookieHeadersFromResponse(response.headers), response.url ?? requestUrl);
                         if (proxy && isProxyConnectFailureResponse(response, normalized.body)) {
                             throw createProxyConnectFailureError(normalized.body);
                         }
@@ -627,12 +790,23 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                         return normalized;
                     }
                     catch (error) {
-                        const normalizedError = normalizeStealthTransportError(error);
+                        const sensitiveValues = serializedUrl?.sensitiveValues ?? fallbackSensitiveValues;
+                        let normalizedError;
+                        try {
+                            normalizedError = normalizeStealthTransportError(error);
+                        }
+                        catch (normalizationError) {
+                            throw redactSensitiveError(normalizationError, sensitiveValues, serializedUrl?.requestUrl ?? fallbackRequestUrl, serializedUrl?.redactedUrl ?? fallbackRedactedUrl);
+                        }
+                        const retryErrorCode = proxyAttemptErrorCode(normalizedError);
+                        const refreshableProxyError = isProxyPoolRefreshableError(normalizedError);
+                        const runProxyAuthDiagnostic = shouldRunProxyAuthDiagnostic(normalizedError);
+                        normalizedError = redactSensitiveError(normalizedError, sensitiveValues, serializedUrl?.requestUrl ?? fallbackRequestUrl, serializedUrl?.redactedUrl ?? fallbackRedactedUrl);
                         recordProxyAttempt("error", proxyAttemptErrorCode(normalizedError), proxyAttemptStatus(normalizedError));
                         lastError = normalizedError;
-                        if (proxy && rotatesRegistryChain && isProxyPoolRefreshableError(normalizedError)) {
+                        if (proxy && rotatesRegistryChain && refreshableProxyError) {
                             stalePoolError = normalizedError;
-                            if (shouldRunProxyAuthDiagnostic(normalizedError)) {
+                            if (runProxyAuthDiagnostic) {
                                 stalePoolDiagnosticProxy = proxy;
                             }
                             if (attempt + 1 < maxAttempts) {
@@ -662,7 +836,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                         });
                         if (attempt + 1 < transportRetryCap &&
                             shouldRetryProxyTransportAttempt({
-                                error: normalizedError,
+                                error: { code: retryErrorCode },
                                 explicitRetry: hasExplicitRetryPolicy,
                                 method,
                                 options: stealthRetryOptions,
@@ -712,49 +886,137 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                 const maxHops = options.maxHops === undefined || !Number.isFinite(options.maxHops)
                     ? 10
                     : Math.max(0, Math.floor(options.maxHops));
+                const { url: _url, maxHops: _maxHops, stopWhen, params, sensitiveParams, ...fetchOptions } = options;
                 const hops = [];
-                let currentUrl = resolveUrl(baseUrl, options.url);
                 let method = normalizeMethod(options.method ?? "GET");
                 let body = options.body;
                 let response;
                 const visitedRequests = new Set();
-                const { url: _url, maxHops: _maxHops, stopWhen, params, ...fetchOptions } = options;
+                const initialParams = params
+                    ? Object.fromEntries(Object.entries(params).map(([key, value]) => [
+                        key,
+                        Array.isArray(value) ? [...value] : value,
+                    ]))
+                    : undefined;
+                const normalizedSensitiveParams = normalizeSensitiveParams(sensitiveParams);
+                const initialSensitiveParams = normalizedSensitiveParams
+                    ? { ...normalizedSensitiveParams }
+                    : undefined;
+                const sensitiveParamNames = initialSensitiveParams
+                    ? Object.keys(initialSensitiveParams)
+                    : [];
+                const callerStructural = redactUrlQueryParams(options.url, sensitiveParamNames);
+                const sensitiveValues = new Set([
+                    ...Object.values(initialSensitiveParams ?? {}),
+                    ...callerStructural.sensitiveValues,
+                ].filter((value) => value !== ""));
+                const redactRedirectUrl = (value) => {
+                    const structural = redactUrlQueryParams(value, [
+                        ...new Set([...sensitiveParamNames, ...sensitiveQueryParamNames(value)]),
+                    ]);
+                    for (const sensitiveValue of structural.sensitiveValues) {
+                        sensitiveValues.add(sensitiveValue);
+                    }
+                    return redactSensitiveText(structural.redactedUrl, [...sensitiveValues]);
+                };
+                let currentUrl;
+                let initialUrl;
+                try {
+                    currentUrl = resolveUrl(baseUrl, options.url);
+                    redactRedirectUrl(currentUrl);
+                    initialUrl = serializeRequestUrl(currentUrl, initialParams, initialSensitiveParams);
+                    for (const value of initialUrl.sensitiveValues) {
+                        if (value !== "")
+                            sensitiveValues.add(value);
+                    }
+                }
+                catch (error) {
+                    throw redactSensitiveError(error, [...sensitiveValues], options.url, redactRedirectUrl(options.url));
+                }
                 for (let hopIndex = 0; hopIndex <= maxHops; hopIndex += 1) {
-                    visitedRequests.add(`${method} ${currentUrl}`);
-                    response = await session.fetch(currentUrl, {
-                        ...fetchOptions,
-                        body,
-                        method,
-                        ...(hopIndex === 0 && params ? { params } : {}),
-                        redirect: "manual",
-                        throwOnHttpError: false,
-                    });
+                    const outboundUrl = hopIndex === 0 ? initialUrl.requestUrl : serializeRequestUrl(currentUrl).requestUrl;
+                    // Preserve params-only loop bookkeeping from before sensitiveParams:
+                    // the first visited key is the caller's resolved URL, not its expanded query.
+                    const visitedUrl = hopIndex === 0 && !initialSensitiveParams ? currentUrl : outboundUrl;
+                    visitedRequests.add(`${method} ${visitedUrl}`);
+                    try {
+                        response = await session.fetch(currentUrl, {
+                            ...fetchOptions,
+                            body,
+                            method,
+                            ...(hopIndex === 0 && initialParams ? { params: initialParams } : {}),
+                            ...(hopIndex === 0 && initialSensitiveParams
+                                ? { sensitiveParams: initialSensitiveParams }
+                                : {}),
+                            redirect: "manual",
+                            throwOnHttpError: false,
+                        });
+                    }
+                    catch (error) {
+                        throw redactSensitiveError(error, [...sensitiveValues], outboundUrl, redactRedirectUrl(outboundUrl));
+                    }
+                    // StealthResponse.url is programmatic metadata and remains raw. Only the
+                    // redirect hop emitted below is a diagnostic surface.
+                    const responseUrl = response.url ?? (hopIndex === 0 && initialSensitiveParams ? outboundUrl : currentUrl);
                     if (!isRedirectStatus(response.status)) {
                         return {
                             final: response,
                             hops,
                             reason: "completed",
                             cookies: cookieJar.snapshot(),
+                            cookieStore: cookieJar.serialize(),
                         };
                     }
                     const location = locationHeader(response.headers);
-                    const nextUrl = location
-                        ? new URL(location, response.url ?? currentUrl).toString()
-                        : undefined;
-                    const hop = {
-                        url: response.url ?? currentUrl,
+                    const redactedResponseUrl = redactRedirectUrl(responseUrl);
+                    const redactedLocation = location ? redactRedirectUrl(location) : undefined;
+                    let nextUrl;
+                    try {
+                        nextUrl = location ? new URL(location, responseUrl).toString() : undefined;
+                    }
+                    catch (error) {
+                        throw redactSensitiveError(error, [...sensitiveValues], location, redactedLocation);
+                    }
+                    const realHop = {
+                        url: responseUrl,
                         status: response.status,
                         method,
                         ...(location ? { location } : {}),
                         ...(nextUrl ? { nextUrl } : {}),
                     };
+                    const hop = {
+                        ...realHop,
+                        url: redactedResponseUrl,
+                        ...(redactedLocation ? { location: redactedLocation } : {}),
+                        ...(nextUrl ? { nextUrl: redactRedirectUrl(nextUrl) } : {}),
+                    };
                     hops.push(hop);
-                    if (stopWhen && (await stopWhen(hop))) {
+                    let shouldStop = false;
+                    if (stopWhen) {
+                        try {
+                            shouldStop = await stopWhen(realHop);
+                        }
+                        catch (error) {
+                            let sanitizedError = error;
+                            for (const [rawUrl, safeUrl] of [
+                                [responseUrl, redactedResponseUrl],
+                                [location, redactedLocation],
+                                [nextUrl, nextUrl ? redactRedirectUrl(nextUrl) : undefined],
+                            ]) {
+                                if (!rawUrl || !safeUrl)
+                                    continue;
+                                sanitizedError = redactSensitiveError(sanitizedError, [...sensitiveValues], rawUrl, safeUrl);
+                            }
+                            throw sanitizedError;
+                        }
+                    }
+                    if (shouldStop) {
                         return {
                             final: response,
                             hops,
                             reason: "stopped",
                             cookies: cookieJar.snapshot(),
+                            cookieStore: cookieJar.serialize(),
                         };
                     }
                     if (!nextUrl) {
@@ -763,6 +1025,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                             hops,
                             reason: "missing_location",
                             cookies: cookieJar.snapshot(),
+                            cookieStore: cookieJar.serialize(),
                         };
                     }
                     if (hops.length > maxHops) {
@@ -771,6 +1034,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                             hops,
                             reason: "max_hops",
                             cookies: cookieJar.snapshot(),
+                            cookieStore: cookieJar.serialize(),
                         };
                     }
                     const nextMethod = nextRedirectMethod(response.status, method);
@@ -783,6 +1047,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                             hops,
                             reason: "loop",
                             cookies: cookieJar.snapshot(),
+                            cookieStore: cookieJar.serialize(),
                         };
                     }
                     method = nextMethod;
@@ -803,6 +1068,7 @@ function createSessionFetcher(baseUrl, defaultProfile, clientOptions) {
                     hops,
                     reason: "max_hops",
                     cookies: cookieJar.snapshot(),
+                    cookieStore: cookieJar.serialize(),
                 };
             },
         },

package/dist/server/index.d.ts

@@ -1,6 +1,6 @@
 export { createServerApp, type ProviderServerCloseOptions, type ProviderServerHandle, type ProviderServerLogEvent, type ProviderServerLogger, type ProviderServerOperationExecutor, type ProviderServerOperationExecutorInput, type ProviderServerOptions, type ProviderServerStatefulForwardEnvelope, type ServeOptions, serve, } from "./serve.js";
 export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestAuthFlowInvoke, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_AUTH_FLOW_MULTI_TURN_SKIP_REASON, SELF_TEST_AUTH_FLOW_REJECTED_SKIP_REASON, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, type SelfTestAppOptions, type SelfTestAuthFlowInvoke, type SelfTestAuthFlowRoute, type SelfTestCaseResult, type SelfTestCaseStatus, type SelfTestOperationInvoke, type SelfTestRequest, SelfTestRequestSchema, type SelfTestResponse, } from "./self-test.js";
-export { resolveHealthCheckInputDateTokens } from "./self-test-input-tokens.js";
+export { type InputDateTokenCalendar, resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js";
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, type SelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export type { AuthFlowRequest, AuthFlowResponse, AuthFlowSuccessResponse, ConnectionMode, OperationConnection, OperationErrorResponse, OperationRequest, OperationResponse, OperationSuccessResponse, } from "./types.js";

package/dist/server/index.js

@@ -1,6 +1,6 @@
 export { createServerApp, serve, } from "./serve.js";
 export { computeSelfTestPlanDigest, createSelfTestApp, createSelfTestAuthFlowInvoke, createSelfTestInvoke, DEFAULT_SELF_TEST_REQUEST_BUDGET_MS, isSelfTestReadOnlyOperation, PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV, resolveSelfTestPort, SELF_TEST_AUTH_FLOW_MULTI_TURN_SKIP_REASON, SELF_TEST_AUTH_FLOW_REJECTED_SKIP_REASON, SELF_TEST_HEALTHZ_PATH, SELF_TEST_PATH, SELF_TEST_SCHEMA_VERSION, SelfTestRequestSchema, } from "./self-test.js";
-export { resolveHealthCheckInputDateTokens } from "./self-test-input-tokens.js";
+export { resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js";
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types.js";

package/dist/server/self-test-input-tokens.d.ts

@@ -1 +1,2 @@
-export declare function resolveHealthCheckInputDateTokens(value: unknown, now?: Date): unknown;
+export type InputDateTokenCalendar = "KST" | "UTC";
+export declare function resolveHealthCheckInputDateTokens(value: unknown, now?: Date, calendar?: InputDateTokenCalendar): unknown;