@apifuse/provider-sdk 2.2.0-beta.58 → 2.2.0-beta.60

package/dist/server/serve-implementation.js

@@ -1,5 +1,7 @@
-import { createHash } from "node:crypto";
+import { STATUS_CODES } from "node:http";
+import { readDiagnosticEnv, withDiagnosticEnv } from "../runtime/diagnostic-env.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
@@ -7,41 +9,45 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { AuthAbortError, createAuthFlowHelpers } from "../auth.js";
 import { validateFailClosedDeclaration } from "../declaration-validation.js";
-import { safeProviderErrorObservability } from "../error-observability.js";
 import { createInProcessProviderEngine, ENGINE_OWNED_PROXY_CREDENTIAL_ENV_NAMES, isEngineOwnedEnvName, readEngineProxyCredentials, } from "../engine.js";
+import { safeProviderErrorObservability } from "../error-observability.js";
 import { SDK_OWNED_PROVIDER_ERROR_CODES, SDK_RUNTIME_OWNED_ERROR_CODES, SDK_STATUS_MAPPED_PROVIDER_ERROR_CODES, } from "../error-resolution.js";
-import { AuthError, isProviderError, isSessionExpiredError, isTransportError, isValidationError, ProviderError, } from "../errors.js";
+import { AuthError, isProviderError, isSessionExpiredError, isTransportError, isValidationError, ProviderError, SDKError, } from "../errors.js";
 import { sanitizeDiagnosticText } from "../fixture-sanitization.js";
 import { loadProviderLocaleCatalogs, localizeAuthTurn, } from "../i18n/catalog.js";
-import { categoryForStatus, sourceForCategory, isRetryableCategory, PROVIDER_OBSERVABILITY_TAXONOMY_VERSION, } from "../observability.js";
+import { categoryForStatus, isRetryableCategory, PROVIDER_OBSERVABILITY_TAXONOMY_VERSION, sourceForCategory, } from "../observability.js";
 import { createScratchpad } from "../runtime/auth-flow.js";
 import { createProviderCache } from "../runtime/cache.js";
 import { createProviderChoiceContext, PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV, } from "../runtime/choice.js";
 import { createCredentialContext } from "../runtime/credential.js";
+import { bindDiagnosticSensitiveRegistry, compileProcessDiagnosticSensitiveValues, createDiagnosticRedactor, REDACTION_FAILED, isDiagnosticRedactionSuppressed, bindCriticalDiagnosticRedactor, redactCriticalDiagnosticText, redactDiagnosticText, registerDiagnosticSensitiveValues, } from "../runtime/diagnostic-redactor.js";
+import { createCeremonyEgressLeaseRuntime, ENGINE_CEREMONY_EGRESS_LEASE, } from "../runtime/egress-lease.js";
 import { createEnvContext } from "../runtime/env.js";
 import { executeOperation } from "../runtime/executor.js";
 import { createHttpClient } from "../runtime/http.js";
 import { wrapWithInstrumentation } from "../runtime/instrumentation.js";
-import { getProviderBaseUrl } from "../runtime/provider.js";
 import { createOcrClientFromEnv } from "../runtime/ocr.js";
+import { getProviderBaseUrl } from "../runtime/provider.js";
 import { PROXY_AUTH_IP_DENIED_CODE, PROXY_EDGE_AUTH_REJECTED_CODE, PROXY_POOL_EXHAUSTED_CODE, } from "../runtime/proxy-errors.js";
 import { PROVIDER_TELEMETRY_HEADER, ProxyTelemetryCollector, } from "../runtime/proxy-telemetry.js";
 import { closedEnum, RequestTelemetry, tenantOpaqueKeys, } from "../runtime/request-telemetry.js";
-import { createUnsupportedResolverClient, } from "../runtime/resolver-shared.js";
+import { bindResolverTelemetry, createUnsupportedResolverClient, inheritResolverTelemetryBinding, } from "../runtime/resolver-shared.js";
+import { ResolverTelemetryCollector, } from "../runtime/resolver-telemetry.js";
 import { assertRequiredSecretsPresent, listMissingRequiredSecrets, MISSING_SECRET_CODE, } from "../runtime/secrets.js";
 import { createProviderRuntimeStateFromEnv, createUnsupportedProviderRuntimeState, } from "../runtime/state.js";
 import { StealthCookieJar } from "../runtime/stealth-cookies.js";
 import { createSttClientFromEnv } from "../runtime/stt.js";
-import { createTraceContext, updateTraceContextExportMetadata, } from "../runtime/trace.js";
+import { createTraceContext, getTraceRecorder, updateTraceContextExportMetadata, } from "../runtime/trace.js";
 import { resolveTraceConfigFromEnv } from "../runtime/trace-config.js";
 import { parseSchema } from "../schema.js";
-import { STATEFUL_NONCE_HEADER as STATEFUL_FORWARDING_NONCE_HEADER, STATEFUL_SIGNATURE_HEADER as STATEFUL_FORWARDING_SIGNATURE_HEADER, STATEFUL_TIMESTAMP_HEADER as STATEFUL_FORWARDING_TIMESTAMP_HEADER, verifyStatefulRequestSignature, } from "../stateful-signing.js";
 import { StatefulRoutingDeadlineError } from "../stateful/errors.js";
+import { STATEFUL_NONCE_HEADER as STATEFUL_FORWARDING_NONCE_HEADER, STATEFUL_SIGNATURE_HEADER as STATEFUL_FORWARDING_SIGNATURE_HEADER, STATEFUL_TIMESTAMP_HEADER as STATEFUL_FORWARDING_TIMESTAMP_HEADER, verifyStatefulRequestSignature, } from "../stateful-signing.js";
 import { getStealthProfile } from "../stealth/profiles.js";
-import { sanitizeTraceAttributes } from "../trace-sanitization.js";
 import { APIFUSE_STREAM_DONE_EVENT, APIFUSE_STREAM_ERROR_EVENT, encodeSseEvent, error as streamError, } from "../stream.js";
+import { sanitizeSpanNameForOutput, sanitizeTraceAttributes } from "../trace-sanitization.js";
 import { VALID_OPERATION_ERROR_STATUSES } from "../types.js";
 import { resolveSelfTestMasterSecrets } from "./self-test-token.js";
+import { collectStaticDiagnosticSensitiveValues, createDiagnosticEnvObserver, } from "./sensitive-values.js";
 import { resolveServerTraceContextOptions } from "./trace-output.js";
 import { AuthFlowRequestSchema, OperationConnectionSchema, OperationRequestSchema, } from "./types.js";
 const DEFAULT_HOST = "0.0.0.0";
@@ -268,6 +274,9 @@ function createLazyStealthClient(onCleanupError, ...createArgs) {
                 async fetch(...args) {
                     return (await getSession()).fetch(...args);
                 },
+                async replayChallenged(...args) {
+                    return (await getSession()).replayChallenged(...args);
+                },
                 redirects: {
                     async run(...args) {
                         return (await getSession()).redirects.run(...args);
@@ -304,13 +313,15 @@ function createLazyStealthClient(onCleanupError, ...createArgs) {
 function bindResolverSignalWithoutRuntime(resolver, defaultSignal) {
     if (!defaultSignal)
         return resolver;
-    return {
+    const boundResolver = {
         solve(challenge, signal = defaultSignal, traceRecorder) {
             // Forward the instrumentation trace recorder so resolver.vendor.* spans
             // survive this wrapper. See ResolverSolveWithRecorder in resolver-shared.ts.
             return resolver.solve(challenge, signal, traceRecorder);
         },
     };
+    inheritResolverTelemetryBinding(resolver, boundResolver);
+    return boundResolver;
 }
 function getProviderStealthBaseUrl(provider) {
     const baseUrl = getProviderBaseUrl(provider);
@@ -323,6 +334,73 @@ function getProviderStealthBaseUrl(provider) {
 function getProviderStealthProfile(provider) {
     return provider.stealth ? getStealthProfile(provider.stealth) : undefined;
 }
+/** One option set for ctx.resolver and the automatic SBSD solve, so both share identity scope, cache, proxy intent, and telemetry. */
+function createResolverRuntimeOptions(provider, cache, identityScope, proxyPolicy, proxyClientOptions, stealthProfile, telemetry) {
+    return {
+        allowedHosts: provider.allowedHosts,
+        cache,
+        telemetry,
+        identityScope,
+        ...(proxyPolicy
+            ? {
+                proxyIntent: {
+                    mode: proxyPolicy.mode,
+                    ...proxyClientOptions,
+                    ...(stealthProfile ? { userAgent: stealthProfile.userAgent } : {}),
+                },
+            }
+            : {}),
+    };
+}
+/** Shared predicate for the SBSD challenge runtime and the ceremony egress lease. */
+function declaresAkamaiSbsdResolver(provider) {
+    return provider.resolver?.kinds.some((kind) => kind === "akamai_sbsd") === true;
+}
+function createStealthChallengeDetection(provider, resolverRuntime, resolverOverride, resolverOptions, trace, signal) {
+    const resolverDeclared = declaresAkamaiSbsdResolver(provider);
+    const detectOnly = provider.stealth?.challengeDetection?.akamaiSbsd === true;
+    if (!resolverDeclared && !detectOnly) {
+        return undefined;
+    }
+    return {
+        akamaiSbsd: {
+            allowedHosts: provider.allowedHosts ?? [],
+            // The profile belongs to the SBSD resolver; a resolver declared for other kinds
+            // may name a different browser without affecting detect-only classification.
+            ...(resolverDeclared && provider.resolver?.clientProfile
+                ? { clientProfile: provider.resolver.clientProfile }
+                : {}),
+            ...(resolverDeclared && resolverRuntime
+                ? {
+                    async solve(challenge, transport, solveSignal) {
+                        const resolver = resolverRuntime.bindResolverSignal((resolverOverride
+                            ? bindResolverTelemetry(resolverOverride, resolverOptions.telemetry)
+                            : undefined) ??
+                            resolverRuntime.createResolverClientFromEnv(provider.resolver, undefined, {
+                                allowedHosts: resolverOptions.allowedHosts,
+                                cache: resolverOptions.cache,
+                                telemetry: resolverOptions.telemetry,
+                                identityScope: resolverOptions.identityScope,
+                                // No proxyIntent: the transport is already bound to the initiating
+                                // request's lease, and a second identity resolution would allocate
+                                // again (and fail closed without allocator credentials) for nothing
+                                // the SBSD adapters consume.
+                                createTransport: () => transport,
+                            }), signal);
+                        // Same span and recorder threading as the instrumented ctx.resolver.solve.
+                        const recorder = getTraceRecorder(trace);
+                        const solve = () => resolver.solve(challenge, solveSignal, recorder ?? undefined);
+                        return recorder
+                            ? recorder.runSpan("resolver.solve", solve, {
+                                attributes: { challenge_kind: challenge.kind },
+                            })
+                            : solve();
+                    },
+                }
+                : {}),
+        },
+    };
+}
 function isProductionProviderBrowserMode(provider, env = process.env) {
     if (provider.runtime !== "browser") {
         return false;
@@ -424,17 +502,29 @@ function createProviderContext(provider, request, operationId, options, state =
         engineCredentials: engineProxyCredentials,
     };
     const resolverIdentityScope = resolveProviderResolverIdentityScope(provider, proxyClientOptions.affinityKey, request.requestId);
+    const cache = createProviderCache({ providerId: provider.id });
     let wrappedContext;
+    const { capabilityModules } = options;
+    const resolverOptions = createResolverRuntimeOptions(provider, cache, resolverIdentityScope, proxyPolicy, proxyClientOptions, stealthProfile, scope.resolverTelemetry);
+    const challengeRuntime = createStealthChallengeDetection(provider, capabilityModules.resolver, options.resolver, resolverOptions, scope.trace, signal);
     const stealthClientOptions = {
         upstream: proxyClientOptions.upstream,
         affinityKey: proxyClientOptions.affinityKey,
         telemetry: scope.telemetry.proxy,
         engineCredentials: engineProxyCredentials,
         ...(signal ? { signal } : {}),
-        ...(provider.stealth ? { stealth: provider.stealth } : {}),
+        // A declared resolver without a `stealth` block still gets the default Chrome client
+        // (auth FlowContext is not capability-gated), so the runtime must ride along.
+        ...(provider.stealth || challengeRuntime
+            ? {
+                stealth: {
+                    ...(provider.stealth ?? {}),
+                    ...(challengeRuntime ? { challengeRuntime } : {}),
+                },
+            }
+            : {}),
     };
-    const { capabilityModules } = options;
-    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
+    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error, scope.redact);
     const env = createEnvContext([
         ...providerSecretNames(provider),
         PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
@@ -450,7 +540,6 @@ function createProviderContext(provider, request, operationId, options, state =
         headers: request.headers ?? {},
     };
     const requestState = state.forConnection(requestContext.connectionId);
-    const cache = createProviderCache({ providerId: provider.id });
     const bindings = {
         env,
         credential,
@@ -475,7 +564,7 @@ function createProviderContext(provider, request, operationId, options, state =
         browser: provider.runtime === "browser"
             ? capabilityModules.browser.createBrowserClient({
                 allowedHosts: provider.allowedHosts,
-                cdpUrl: process.env.APIFUSE__CDP_POOL__URL,
+                cdpUrl: readDiagnosticEnv("APIFUSE__CDP_POOL__URL"),
                 headless: true,
                 requireCdpPool: isProductionProviderBrowserMode(provider),
                 stealth: true,
@@ -499,22 +588,13 @@ function createProviderContext(provider, request, operationId, options, state =
         ocr: options.ocr ?? createOcrClientFromEnv(provider.ocr),
         stt: options.stt ?? createSttClientFromEnv(provider.stt),
         resolver: capabilityModules.resolver
-            ? capabilityModules.resolver.bindResolverSignal(options.resolver ??
-                capabilityModules.resolver.createResolverClientFromEnv(provider.resolver, undefined, {
-                    allowedHosts: provider.allowedHosts,
-                    cache,
-                    identityScope: resolverIdentityScope,
-                    ...(proxyPolicy
-                        ? {
-                            proxyIntent: {
-                                mode: proxyPolicy.mode,
-                                ...proxyClientOptions,
-                                ...(stealthProfile ? { userAgent: stealthProfile.userAgent } : {}),
-                            },
-                        }
-                        : {}),
-                }), signal)
-            : bindResolverSignalWithoutRuntime(options.resolver ??
+            ? capabilityModules.resolver.bindResolverSignal((options.resolver
+                ? bindResolverTelemetry(options.resolver, resolverOptions.telemetry)
+                : undefined) ??
+                capabilityModules.resolver.createResolverClientFromEnv(provider.resolver, undefined, resolverOptions), signal)
+            : bindResolverSignalWithoutRuntime((options.resolver
+                ? bindResolverTelemetry(options.resolver, resolverOptions.telemetry)
+                : undefined) ??
                 createUnsupportedResolverClient("Provider does not declare resolver capability"), signal),
         choice: createProviderChoiceContext({
             providerId: provider.id,
@@ -564,7 +644,7 @@ export function resolveAuthFlowProxyAffinityKey(provider, request) {
         request.providerId ??
         provider.id);
 }
-function createAuthFlowContext(provider, request, options, state, scope, signal) {
+function createAuthFlowContext(provider, request, route, options, state, scope, signal) {
     const baseUrl = getProviderBaseUrl(provider);
     const stealthBaseUrl = getProviderStealthBaseUrl(provider);
     const stealthProfile = getProviderStealthProfile(provider);
@@ -578,17 +658,51 @@ function createAuthFlowContext(provider, request, options, state, scope, signal)
         telemetry: scope.telemetry.proxy,
         engineCredentials: engineProxyCredentials,
     };
+    // The lease pins the proxy egress a challenged ceremony solved on, so only providers
+    // that declare the akamai_sbsd resolver kind carry one (same predicate as the challenge
+    // runtime). `abort` never evaluates the key or tenant: a user must be able to cancel a
+    // stranded flow even when engine provisioning is broken, and an abort is not a
+    // continuation of the ceremony the lease pins.
+    const ceremonyEgressLease = route !== "abort" &&
+        declaresAkamaiSbsdResolver(provider) &&
+        proxyPolicy &&
+        proxyPolicy.mode !== "disabled"
+        ? createCeremonyEgressLeaseRuntime({
+            tenantId: request.tenantId,
+            providerId: provider.id,
+            flowId: request.flowId,
+            affinityKey: proxyClientOptions.affinityKey,
+            onHandle: (handle) => registerDiagnosticSensitiveValues(scope.trace, [handle]),
+            ...(request.engine?.egressLease ? { handle: request.engine.egressLease } : {}),
+        })
+        : undefined;
+    if (route !== "abort" && request.engine?.egressLease && !ceremonyEgressLease) {
+        throw new SDKError("An egress lease was supplied for an auth flow that does not use a ceremony lease", { code: "EGRESS_LEASE_INVALID" });
+    }
     const resolverIdentityScope = resolveProviderResolverIdentityScope(provider, proxyClientOptions.affinityKey, request.requestId);
+    const cache = createProviderCache({ providerId: provider.id });
+    const { capabilityModules } = options;
+    const resolverOptions = createResolverRuntimeOptions(provider, cache, resolverIdentityScope, proxyPolicy, proxyClientOptions, stealthProfile, scope.resolverTelemetry);
+    const challengeRuntime = createStealthChallengeDetection(provider, capabilityModules.resolver, options.resolver, resolverOptions, scope.trace, signal);
     const stealthClientOptions = {
         upstream: proxyClientOptions.upstream,
         affinityKey: proxyClientOptions.affinityKey,
         telemetry: scope.telemetry.proxy,
         engineCredentials: engineProxyCredentials,
+        ...(ceremonyEgressLease ? { [ENGINE_CEREMONY_EGRESS_LEASE]: ceremonyEgressLease } : {}),
         ...(signal ? { signal } : {}),
-        ...(provider.stealth ? { stealth: provider.stealth } : {}),
+        // A declared resolver without a `stealth` block still gets the default Chrome client
+        // (auth FlowContext is not capability-gated), so the runtime must ride along.
+        ...(provider.stealth || challengeRuntime
+            ? {
+                stealth: {
+                    ...(provider.stealth ?? {}),
+                    ...(challengeRuntime ? { challengeRuntime } : {}),
+                },
+            }
+            : {}),
     };
-    const { capabilityModules } = options;
-    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "auth", "flow", request.requestId, "stealth", error);
+    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "auth", "flow", request.requestId, "stealth", error, scope.redact);
     const credential = request.connection
         ? createCredentialContext({
             allowedKeys: provider.credential?.keys,
@@ -597,7 +711,6 @@ function createAuthFlowContext(provider, request, options, state, scope, signal)
             values: request.connection.secrets,
         })
         : undefined;
-    const cache = createProviderCache({ providerId: provider.id });
     const context = wrapWithInstrumentation({
         flowId: request.flowId,
         connectionId: resolveOperationConnectionId(request),
@@ -636,28 +749,23 @@ function createAuthFlowContext(provider, request, options, state, scope, signal)
         ocr: options.ocr ?? createOcrClientFromEnv(provider.ocr),
         stt: options.stt ?? createSttClientFromEnv(provider.stt),
         resolver: capabilityModules.resolver
-            ? capabilityModules.resolver.bindResolverSignal(options.resolver ??
-                capabilityModules.resolver.createResolverClientFromEnv(provider.resolver, undefined, {
-                    allowedHosts: provider.allowedHosts,
-                    cache,
-                    identityScope: resolverIdentityScope,
-                    ...(proxyPolicy
-                        ? {
-                            proxyIntent: {
-                                mode: proxyPolicy.mode,
-                                ...proxyClientOptions,
-                                ...(stealthProfile ? { userAgent: stealthProfile.userAgent } : {}),
-                            },
-                        }
-                        : {}),
-                }), signal)
-            : bindResolverSignalWithoutRuntime(options.resolver ??
+            ? capabilityModules.resolver.bindResolverSignal((options.resolver
+                ? bindResolverTelemetry(options.resolver, resolverOptions.telemetry)
+                : undefined) ??
+                capabilityModules.resolver.createResolverClientFromEnv(provider.resolver, undefined, resolverOptions), signal)
+            : bindResolverSignalWithoutRuntime((options.resolver
+                ? bindResolverTelemetry(options.resolver, resolverOptions.telemetry)
+                : undefined) ??
                 createUnsupportedResolverClient("Provider does not declare resolver capability"), signal),
         auth: createAuthFlowHelpers({ signal }),
     });
     return {
         context,
         getPatch: flowContextStore.getPatch,
+        getEngineState() {
+            const egressLease = ceremonyEgressLease?.handle();
+            return egressLease ? { egressLease } : undefined;
+        },
     };
 }
 const defaultProviderServerLogger = (event) => {
@@ -683,11 +791,11 @@ function finishRequestCost(input) {
         cpuTotalMicros: Math.max(0, cpuDelta.user + cpuDelta.system),
     };
 }
-function zodDetails(error) {
+function zodDetails(error, redact) {
     return error.issues.map((issue) => ({
-        path: issue.path.join("."),
-        code: issue.code,
-        message: issue.message,
+        path: sanitizeSpanNameForOutput(issue.path.join("."), redact),
+        code: sanitizeSpanNameForOutput(issue.code, redact),
+        message: sanitizeSpanNameForOutput(issue.message, redact),
     }));
 }
 // Category-level projection with code-aware honesty overrides: a missing
@@ -710,7 +818,7 @@ function publicErrorSource(error, category) {
     }
     return sourceForCategory(category);
 }
-function toErrorResponse(error, requestId, observabilityDetails) {
+function toErrorResponse(error, requestId, observabilityDetails, redact) {
     const observability = observabilityDetails;
     const source = publicErrorSource(error, observability.category);
     if (error instanceof StatefulRoutingDeadlineError) {
@@ -746,7 +854,7 @@ function toErrorResponse(error, requestId, observabilityDetails) {
                 ...(requestId ? { requestId } : {}),
                 retryable: observability.retryable,
                 source,
-                details: zodDetails(error),
+                details: zodDetails(error, redact),
             },
         };
     }
@@ -994,13 +1102,13 @@ function extractRequestId(raw) {
 }
 const MAX_PROVIDER_ERROR_CAUSE_FRAMES = 5;
 const MAX_PROVIDER_ERROR_CAUSE_MESSAGE_LENGTH = 300;
-function providerErrorCauseMessage(message) {
-    const sanitized = sanitizeDiagnosticText(message);
+function providerErrorCauseMessage(message, redact) {
+    const sanitized = sanitizeDiagnosticText(redactDiagnosticText(message, redact));
     return sanitized.length > MAX_PROVIDER_ERROR_CAUSE_MESSAGE_LENGTH
         ? `${sanitized.slice(0, MAX_PROVIDER_ERROR_CAUSE_MESSAGE_LENGTH)}… [truncated]`
         : sanitized;
 }
-function providerErrorCauseChain(error) {
+function providerErrorCauseChain(error, redact) {
     if (!(error instanceof Error) && !isProviderError(error))
         return undefined;
     const seen = new Set([error]);
@@ -1014,9 +1122,9 @@ function providerErrorCauseChain(error) {
         const providerObservability = safeProviderErrorObservability(cause);
         const causeCode = providerErrorCode(cause);
         frames.push({
-            errorClass: cause.name,
-            ...(causeCode !== undefined ? { code: causeCode } : {}),
-            message: providerErrorCauseMessage(message),
+            errorClass: redactDiagnosticText(cause.name, redact),
+            ...(causeCode !== undefined ? { code: redactDiagnosticText(causeCode, redact) } : {}),
+            message: providerErrorCauseMessage(message, redact),
             messageLength: message.length,
             messageFingerprint: createHash("sha256").update(message).digest("hex").slice(0, 12),
             ...(providerObservability ? { providerObservability } : {}),
@@ -1025,7 +1133,7 @@ function providerErrorCauseChain(error) {
     }
     return frames.length > 0 ? frames : undefined;
 }
-function logProviderError(logger, provider, kind, route, requestId, error, status, cost, declaredErrorCode, telemetry, observabilityDetails, correlation = {}) {
+function logProviderError(logger, provider, kind, route, requestId, error, status, cost, declaredErrorCode, telemetry, observabilityDetails, correlation = {}, redact) {
     const providerCode = isProviderError(error) ? providerErrorCode(error) : undefined;
     const code = isProviderError(error)
         ? (providerCode ?? "provider_error")
@@ -1036,7 +1144,7 @@ function logProviderError(logger, provider, kind, route, requestId, error, statu
                 : "internal_error";
     const errorClass = error instanceof Error ? error.name : typeof error;
     const message = error instanceof Error ? error.message : String(error);
-    const causeChain = providerErrorCauseChain(error);
+    const causeChain = providerErrorCauseChain(error, redact);
     const details = observabilityDetails;
     const isUnregisteredProviderErrorCode = status === 500 &&
         isProviderError(error) &&
@@ -1055,24 +1163,28 @@ function logProviderError(logger, provider, kind, route, requestId, error, statu
     emit({
         level: status >= 500 ? "error" : "warn",
         event: "provider_request_failed",
-        providerId: provider.id,
+        providerId: redactDiagnosticText(provider.id, redact),
         kind,
-        route,
-        ...(requestId ? { requestId } : {}),
+        route: redactCriticalDiagnosticText(route, redact),
+        ...(requestId ? { requestId: redactCriticalDiagnosticText(requestId, redact) } : {}),
         ...(correlation.connectionId !== undefined
-            ? { connectionId: correlation.connectionId }
+            ? { connectionId: redactDiagnosticText(correlation.connectionId, redact) }
+            : {}),
+        ...(correlation.flowId !== undefined
+            ? { flowId: redactDiagnosticText(correlation.flowId, redact) }
+            : {}),
+        ...(correlation.tenantId !== undefined
+            ? { tenantId: redactDiagnosticText(correlation.tenantId, redact) }
             : {}),
-        ...(correlation.flowId !== undefined ? { flowId: correlation.flowId } : {}),
-        ...(correlation.tenantId !== undefined ? { tenantId: correlation.tenantId } : {}),
         ...(correlation.requestedProviderId !== undefined
-            ? { requestedProviderId: correlation.requestedProviderId }
+            ? { requestedProviderId: redactDiagnosticText(correlation.requestedProviderId, redact) }
             : {}),
         status,
         ...cost,
         ...(telemetryPayload ?? {}),
-        code,
-        errorClass,
-        message,
+        code: sanitizeSpanNameForOutput(redactCriticalDiagnosticText(code, redact)),
+        errorClass: redactDiagnosticText(errorClass, redact),
+        message: sanitizeDiagnosticText(redactDiagnosticText(message, redact)),
         ...(causeChain ? { causeChain } : {}),
         ...(providerObservability ? { providerObservability } : {}),
         ...(details.upstreamStatus ? { upstreamStatus: details.upstreamStatus } : {}),
@@ -1085,42 +1197,46 @@ function logProviderError(logger, provider, kind, route, requestId, error, statu
                 signalFix: "Declare this code (with status and retryable) in the operation's errorCodes so it serves its intended status instead of 500.",
             }
             : {}),
-        ...(error instanceof z.ZodError ? { issues: zodDetails(error) } : {}),
+        ...(error instanceof z.ZodError ? { issues: zodDetails(error, redact) } : {}),
     });
 }
-function logProviderCleanupError(logger, provider, kind, operationId, requestId, resource, error) {
+function logProviderCleanupError(logger, provider, kind, operationId, requestId, resource, error, redact) {
     const emit = typeof logger === "function" ? logger : defaultProviderServerLogger;
     const errorClass = error instanceof Error ? error.name : typeof error;
     const message = error instanceof Error ? error.message : String(error);
     emit({
         level: "warn",
         event: "provider_cleanup_failed",
-        providerId: provider.id,
+        providerId: redactDiagnosticText(provider.id, redact),
         kind,
-        route: operationId,
-        ...(requestId ? { requestId } : {}),
+        route: redactCriticalDiagnosticText(operationId, redact),
+        ...(requestId ? { requestId: redactCriticalDiagnosticText(requestId, redact) } : {}),
         resource,
-        errorClass,
-        message,
+        errorClass: redactDiagnosticText(errorClass, redact),
+        message: sanitizeDiagnosticText(redactDiagnosticText(message, redact)),
     });
 }
-function logProviderSuccess(logger, provider, kind, route, requestId, status, cost, telemetry, correlation = {}) {
+function logProviderSuccess(logger, provider, kind, route, requestId, status, cost, telemetry, correlation = {}, redact) {
     const telemetryPayload = telemetry?.toLogPayload();
     const emit = typeof logger === "function" ? logger : defaultProviderServerLogger;
     emit({
         level: "info",
         event: "provider_request_completed",
-        providerId: provider.id,
+        providerId: redactDiagnosticText(provider.id, redact),
         kind,
-        route,
-        ...(requestId ? { requestId } : {}),
+        route: redactCriticalDiagnosticText(route, redact),
+        ...(requestId ? { requestId: redactCriticalDiagnosticText(requestId, redact) } : {}),
         ...(correlation.connectionId !== undefined
-            ? { connectionId: correlation.connectionId }
+            ? { connectionId: redactDiagnosticText(correlation.connectionId, redact) }
+            : {}),
+        ...(correlation.flowId !== undefined
+            ? { flowId: redactDiagnosticText(correlation.flowId, redact) }
+            : {}),
+        ...(correlation.tenantId !== undefined
+            ? { tenantId: redactDiagnosticText(correlation.tenantId, redact) }
             : {}),
-        ...(correlation.flowId !== undefined ? { flowId: correlation.flowId } : {}),
-        ...(correlation.tenantId !== undefined ? { tenantId: correlation.tenantId } : {}),
         ...(correlation.requestedProviderId !== undefined
-            ? { requestedProviderId: correlation.requestedProviderId }
+            ? { requestedProviderId: redactDiagnosticText(correlation.requestedProviderId, redact) }
             : {}),
         status,
         ...cost,
@@ -1173,9 +1289,106 @@ function requestTraceId(headers, requestId) {
             ? createHash("sha256").update(requestId, "utf8").digest("hex").slice(0, 32)
             : undefined));
 }
+/** Harvest only credential subtrees, iteratively and before schema diagnostics. */
+function rawRequestCredentials(rawBody, kind) {
+    const record = (value) => value !== null && typeof value === "object" ? value : undefined;
+    const own = (value, key) => {
+        const object = record(value);
+        return object && Object.hasOwn(object, key) ? object[key] : undefined;
+    };
+    const body = kind === "stateful" ? own(rawBody, "operationRequest") : rawBody;
+    const values = [];
+    let remainingBytes = 64 * 1024;
+    let exhausted = false;
+    const add = (value) => {
+        if (typeof value !== "string")
+            return;
+        const bytes = Buffer.byteLength(value, "utf8");
+        if (bytes > remainingBytes) {
+            exhausted = true;
+            return;
+        }
+        remainingBytes -= bytes;
+        if (value)
+            values.push(value);
+        const trimmed = value.trim();
+        if (trimmed && trimmed !== value)
+            values.push(trimmed);
+    };
+    function* entries(object) {
+        for (const key in object) {
+            if (Object.hasOwn(object, key))
+                yield [key, object[key]];
+        }
+    }
+    const visit = (root) => {
+        const object = record(root);
+        if (!object) {
+            add(root);
+            return;
+        }
+        // Connection inventories are usually flat. Walk the root directly and only
+        // allocate iterator frames when a nested credential container is encountered.
+        for (const key in object) {
+            if (!Object.hasOwn(object, key))
+                continue;
+            const value = object[key];
+            add(key);
+            if (exhausted)
+                break;
+            const child = record(value);
+            if (!child) {
+                add(value);
+                if (exhausted)
+                    break;
+                continue;
+            }
+            const stack = [{ iterator: entries(child), depth: 1 }];
+            while (stack.length && !exhausted) {
+                const frame = stack[stack.length - 1];
+                const entry = frame.iterator.next();
+                if (entry.done) {
+                    stack.pop();
+                    continue;
+                }
+                const [key, value] = entry.value;
+                add(key);
+                if (exhausted)
+                    break;
+                const child = record(value);
+                if (child) {
+                    if (frame.depth >= 8) {
+                        exhausted = true;
+                        break;
+                    }
+                    stack.push({ iterator: entries(child), depth: frame.depth + 1 });
+                }
+                else
+                    add(value);
+            }
+            if (exhausted)
+                break;
+        }
+    };
+    visit(own(own(body, "connection"), "secrets"));
+    if (kind === "auth" && !exhausted) {
+        add(own(own(body, "engine"), "egressLease"));
+        if (!exhausted)
+            visit(own(body, "input"));
+    }
+    return { values, exhausted };
+}
 function createRequestScope(input) {
+    const sensitiveRegistry = createDiagnosticRedactor([], input.staticSensitiveValues);
+    const redact = (text) => redactDiagnosticText(text, sensitiveRegistry.redact);
+    bindCriticalDiagnosticRedactor(redact, sensitiveRegistry.redactCritical, sensitiveRegistry.redactStructured, () => sensitiveRegistry.suppressed);
     const requestCost = startRequestCost();
-    const traceConfig = resolveTraceConfigFromEnv();
+    const observeEnv = {
+        observe: createDiagnosticEnvObserver(input.provider, sensitiveRegistry.add, sensitiveRegistry.has),
+        finished: false,
+        staticValues: input.staticSensitiveValues,
+    };
+    const traceConfig = withDiagnosticEnv(observeEnv, () => resolveTraceConfigFromEnv());
     const details = {
         route: input.route,
         requestId: input.requestId,
@@ -1194,13 +1407,17 @@ function createRequestScope(input) {
     const initialTraceId = requestTraceId(input.headers, input.requestId);
     const trace = traceConfig
         ? createTraceContext({
-            ...resolveServerTraceContextOptions(traceConfig, traceAttributes),
+            ...withDiagnosticEnv(observeEnv, () => resolveServerTraceContextOptions(traceConfig, traceAttributes, undefined, redact)),
+            redact,
             ...(initialTraceId ? { traceId: initialTraceId } : {}),
         })
-        : createTraceContext();
+        : createTraceContext({ redact });
+    bindDiagnosticSensitiveRegistry(trace, sensitiveRegistry);
     const proxyCollector = new ProxyTelemetryCollector();
+    const resolverCollector = new ResolverTelemetryCollector({ redact });
     const telemetry = new RequestTelemetry(trace);
     telemetry.register(proxyCollector);
+    telemetry.register(resolverCollector);
     let rootRunner = (fn) => fn();
     let resolveRoot;
     const rootTerminal = new Promise((resolve) => {
@@ -1221,13 +1438,13 @@ function createRequestScope(input) {
             return clientCancelledError();
         return undefined;
     };
-    const root = trace.span(`request:${input.kind}:${input.route}`, async () => {
+    const root = withDiagnosticEnv(observeEnv, () => trace.span(`request:${input.kind}:${input.route}`, async () => {
         rootRunner = AsyncLocalStorage.snapshot();
         const outcome = await rootTerminal;
         const error = terminalError(outcome);
         if (error !== undefined)
             throw error;
-    });
+    }));
     void root.catch(() => undefined);
     const settleRoot = () => {
         if (!terminalOutcome || streamingSetupPending || rootSettled)
@@ -1263,7 +1480,7 @@ function createRequestScope(input) {
             traceAttributes.flow_id = details.flowId;
         traceAttributes.route = details.route;
         const traceId = requestTraceId(details.headers, details.requestId);
-        const sanitizedAttributes = Object.fromEntries(Object.entries(sanitizeTraceAttributes(traceAttributes)).map(([key, value]) => [
+        const sanitizedAttributes = Object.fromEntries(Object.entries(sanitizeTraceAttributes(traceAttributes, redact)).map(([key, value]) => [
             key,
             String(value),
         ]));
@@ -1273,8 +1490,17 @@ function createRequestScope(input) {
         });
     };
     const scope = {
+        redact,
         trace,
         telemetry,
+        resolverTelemetry: resolverCollector,
+        seedCredentials(rawBody, kind) {
+            const harvested = rawRequestCredentials(rawBody, kind);
+            sensitiveRegistry.add(harvested.values);
+            // An incomplete inventory cannot certify free text: emit less.
+            if (harvested.exhausted)
+                sensitiveRegistry.suppress();
+        },
         enrich(enrichment) {
             if (terminalOutcome)
                 return;
@@ -1336,21 +1562,21 @@ function createRequestScope(input) {
         terminalize(outcome) {
             if (finishedResult)
                 return finishedResult;
+            observeEnv.finished = true;
             terminalOutcome = outcome;
             const error = terminalError(outcome);
             finishedResult = {};
             try {
                 const declaredErrorCode = error === undefined ? undefined : input.declaredErrorCode?.(error);
-                const status = outcome.status ??
-                    (error === undefined ? 200 : toStatusCode(error, declaredErrorCode));
+                const status = outcome.status ?? (error === undefined ? 200 : toStatusCode(error, declaredErrorCode));
                 finishedResult = headerSnapshot(error);
                 const cost = finishRequestCost(requestCost);
                 try {
                     if (error === undefined) {
-                        logProviderSuccess(input.logger, input.provider, input.kind, details.route, details.requestId, status, cost, telemetry, details.correlation);
+                        logProviderSuccess(input.logger, input.provider, input.kind, details.route, details.requestId, status, cost, telemetry, details.correlation, redact);
                     }
                     else {
-                        logProviderError(input.logger, input.provider, input.kind, details.route, details.requestId, error, status, cost, declaredErrorCode, telemetry, finishedResult.errorObservability, details.correlation);
+                        logProviderError(input.logger, input.provider, input.kind, details.route, details.requestId, error, status, cost, declaredErrorCode, telemetry, finishedResult.errorObservability, details.correlation, redact);
                     }
                 }
                 catch {
@@ -1384,25 +1610,55 @@ function createRequestScope(input) {
     };
     return scope;
 }
-function responseWithRequestScopeHeaders(response, finished) {
+// A raw `Response` result skips `toErrorResponse`. Its payload shape stays
+// provider-owned; known credentials in error payloads still need redaction.
+// The observability header is SDK-owned: derive it
+// from the status. Only timeouts, rate limits, and 5xx are retryable;
+// `isRetryableCategory` would otherwise mark every other 4xx (`upstream_http`)
+// as retryable.
+function rawResponseErrorObservability(status) {
+    return {
+        category: categoryForStatus(status),
+        taxonomyVersion: PROVIDER_OBSERVABILITY_TAXONOMY_VERSION,
+        retryable: status === 408 || status === 429 || status >= 500,
+    };
+}
+// `rawStatusFallback` is decided by the caller from the outcome, not from a
+// missing snapshot: a failed outcome whose thrown value is `undefined` also has
+// no `errorObservability`, and its 500 carries the SDK envelope, not a raw body.
+async function responseWithRequestScopeHeaders(response, finished, rawStatusFallback, redact) {
     const headers = new Headers(response.headers);
     headers.delete(PROVIDER_TELEMETRY_HEADER);
     if (finished.providerTelemetryHeader) {
         headers.set(PROVIDER_TELEMETRY_HEADER, finished.providerTelemetryHeader);
     }
-    if (finished.errorObservability) {
-        headers.set(ERROR_OBSERVABILITY_HEADER, JSON.stringify(finished.errorObservability));
-    }
-    return new Response(response.body, {
+    headers.delete(ERROR_OBSERVABILITY_HEADER);
+    const errorObservability = finished.errorObservability ??
+        (rawStatusFallback && response.status >= 400
+            ? rawResponseErrorObservability(response.status)
+            : undefined);
+    if (errorObservability) {
+        headers.set(ERROR_OBSERVABILITY_HEADER, JSON.stringify(errorObservability));
+    }
+    // Raw Response bodies are provider-owned. Preserve their stream and representation.
+    const body = response.body;
+    const statusText = rawStatusFallback && response.status >= 400
+        ? redactDiagnosticText(response.statusText, redact)
+        : response.statusText;
+    return new Response(body, {
         headers,
         status: response.status,
-        statusText: response.statusText,
+        // When free text cannot be certified, use the SDK's standard HTTP reason
+        // phrase. It preserves the status contract without trusting provider text.
+        statusText: statusText === REDACTION_FAILED && isDiagnosticRedactionSuppressed(redact)
+            ? (STATUS_CODES[response.status] ?? "")
+            : statusText,
     });
 }
-function finalizeRequestResponse(scope, response, outcome) {
+async function finalizeRequestResponse(scope, response, outcome) {
     try {
         const error = outcome.kind === "failed" ? outcome.error : undefined;
-        const finalResponse = responseWithRequestScopeHeaders(response, scope.snapshotHeaders(error));
+        const finalResponse = await responseWithRequestScopeHeaders(response, scope.snapshotHeaders(error), outcome.kind === "completed", scope.redact);
         scope.terminalize(outcome);
         return finalResponse;
     }
@@ -1580,7 +1836,7 @@ function toSseResponse(operation, result, lifecycle, requestId) {
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : "Stream failed";
-                controller.enqueue(encoder.encode(encodeSseEvent(streamError("stream_error", message, {
+                controller.enqueue(encoder.encode(encodeSseEvent(streamError("stream_error", sanitizeDiagnosticText(redactDiagnosticText(message, lifecycle.redact)), {
                     ...(requestId ? { requestId } : {}),
                 }))));
                 controller.close();
@@ -1679,7 +1935,7 @@ function getSseTransport(operation) {
 function getHttpStreamTransport(operation) {
     return operation.transport?.kind === "http-stream" ? operation.transport : undefined;
 }
-function toAuthFlowResponse(result, contextPatch) {
+function toAuthFlowResponse(result, contextPatch, engine) {
     if (result instanceof Response) {
         return result;
     }
@@ -1689,6 +1945,7 @@ function toAuthFlowResponse(result, contextPatch) {
     return {
         data: result,
         ...(contextPatch ? { contextPatch } : {}),
+        ...(engine ? { engine } : {}),
     };
 }
 function authFlowLocaleFromHeaders(headers) {
@@ -1759,7 +2016,7 @@ async function handleOperation(provider, request, operationId, options, state =
                 ctx.stealth.close?.();
             }
             catch (error) {
-                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
+                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error, scope.redact);
             }
         }
         if ("browser" in ctx) {
@@ -1767,11 +2024,12 @@ async function handleOperation(provider, request, operationId, options, state =
                 await ctx.browser.close?.();
             }
             catch (error) {
-                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "browser", error);
+                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "browser", error, scope.redact);
             }
         }
     };
     const streamLifecycle = {
+        redact: scope.redact,
         runStep(fn) {
             return scope.runStreamStep(fn);
         },
@@ -1823,8 +2081,9 @@ async function handleAuthFlow(provider, request, route, options, state, scope, s
     // depend on declared secrets (client ids/secrets), so fail structured before
     // any flow code runs instead of at whatever point the ceremony first reads
     // the env. `abort` stays exempt: a user must always be able to cancel a
-    // stranded flow even when provisioning is broken.
-    const { context, getPatch } = createAuthFlowContext(provider, request, options, state, scope, signal);
+    // stranded flow even when provisioning is broken (createAuthFlowContext
+    // applies the same exemption to the engine ceremony lease).
+    const { context, getPatch, getEngineState } = createAuthFlowContext(provider, request, route, options, state, scope, signal);
     try {
         if (route !== "abort") {
             assertRequiredSecretsPresent(provider, context.env);
@@ -1855,11 +2114,11 @@ async function handleAuthFlow(provider, request, route, options, state, scope, s
             isAuthTurn(result)
             ? materializeAuthFlowTurn(provider, request, result)
             : result;
-        return toAuthFlowResponse(materializedResult, getPatch());
+        return toAuthFlowResponse(materializedResult, getPatch(), getEngineState());
     }
     catch (error) {
         if (error instanceof AuthAbortError) {
-            return toAuthFlowResponse(error.turn, getPatch());
+            return toAuthFlowResponse(error.turn, getPatch(), getEngineState());
         }
         throw error;
     }
@@ -1868,7 +2127,7 @@ async function handleAuthFlow(provider, request, route, options, state, scope, s
             context.stealth.close?.();
         }
         catch (error) {
-            logProviderCleanupError(options.logger, provider, "auth", route, request.requestId, "stealth", error);
+            logProviderCleanupError(options.logger, provider, "auth", route, request.requestId, "stealth", error, scope.redact);
         }
     }
 }
@@ -1974,13 +2233,13 @@ function operationRequestFromForwardingEnvelope(envelope) {
         ...(envelope.deadlineAt !== undefined ? { deadlineAt: envelope.deadlineAt } : {}),
     };
 }
-function parseStatefulForwardingEnvelope(rawBody) {
+function parseStatefulForwardingEnvelope(rawBody, redact) {
     const parsed = ProviderServerStatefulForwardEnvelopeSchema.safeParse(rawBody);
     if (parsed.success)
         return parsed.data;
     throw new ProviderError("Stateful forwarding envelope is invalid.", {
         code: "STATEFUL_FORWARDING_ENVELOPE_INVALID",
-        details: zodDetails(parsed.error),
+        details: zodDetails(parsed.error, redact),
     });
 }
 /**
@@ -2014,6 +2273,10 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
         engine: serverOptions.engine ?? createInProcessProviderEngine(),
     };
     const app = new Hono();
+    // Compile the startup inventory once, composed with the shared outside-context fallback.
+    const staticSensitiveValues = compileProcessDiagnosticSensitiveValues(collectStaticDiagnosticSensitiveValues(provider, {
+        statefulForwardingSecret: options.statefulForwarding?.secret,
+    }));
     const logger = options.logger ?? defaultProviderServerLogger;
     const operationErrorCodes = buildOperationErrorCodeLookup(provider);
     const statefulForwardingReplayCache = new StatefulForwardingReplayCache(options.statefulForwarding?.replayCacheMaxEntries ??
@@ -2054,6 +2317,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
         const operation = "stateful-internal";
         const requestScope = createRequestScope({
             provider,
+            staticSensitiveValues,
             kind: "operation",
             route: operation,
             headers: Object.fromEntries(c.req.raw.headers.entries()),
@@ -2084,7 +2348,8 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                     code: "STATEFUL_FORWARDING_ENVELOPE_INVALID",
                 });
             }
-            const envelope = parseStatefulForwardingEnvelope(rawBody);
+            requestScope.seedCredentials(rawBody, "stateful");
+            const envelope = parseStatefulForwardingEnvelope(rawBody, requestScope.redact);
             if (envelope.providerId !== provider.id) {
                 throw new ProviderError("Stateful forwarding envelope providerId does not match the served provider.", { code: "STATEFUL_FORWARDING_PROVIDER_MISMATCH" });
             }
@@ -2185,7 +2450,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                 ...(requestId ? { requestId } : {}),
             });
             const observabilityDetails = errorObservabilityDetails(error, declaredErrorCode);
-            const response = c.json(toErrorResponse(error, requestId, observabilityDetails), status);
+            const response = c.json(toErrorResponse(error, requestId, observabilityDetails, requestScope.redact), status);
             return finalizeRequestResponse(requestScope, response, {
                 kind: "failed",
                 status,
@@ -2198,6 +2463,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
         const operation = c.req.param("operation");
         const requestScope = createRequestScope({
             provider,
+            staticSensitiveValues,
             kind: "operation",
             route: operation,
             operationId: operation,
@@ -2211,6 +2477,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                 .clone()
                 .json()
                 .catch(() => undefined);
+            requestScope.seedCredentials(rawBody, "operation");
             const body = OperationRequestSchema.parse(rawBody);
             const requestHeaders = Object.fromEntries(c.req.raw.headers.entries());
             body.headers = { ...requestHeaders, ...body.headers };
@@ -2228,7 +2495,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                 const handled = await handleOperation(provider, body, operation, options, state, requestScope, c.req.raw.signal);
                 const response = handled instanceof Response ? handled : c.json(handled);
                 return streaming
-                    ? responseWithRequestScopeHeaders(response, requestScope.snapshotHeaders())
+                    ? responseWithRequestScopeHeaders(response, requestScope.snapshotHeaders(), true, requestScope.redact)
                     : response;
             };
             const response = streaming
@@ -2247,7 +2514,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
             const requestId = extractRequestId(rawBody);
             requestScope.enrich({ ...(requestId ? { requestId } : {}) });
             const observabilityDetails = errorObservabilityDetails(error, declaredErrorCode);
-            const response = c.json(toErrorResponse(error, requestId, observabilityDetails), status);
+            const response = c.json(toErrorResponse(error, requestId, observabilityDetails, requestScope.redact), status);
             return finalizeRequestResponse(requestScope, response, {
                 kind: "failed",
                 status,
@@ -2267,6 +2534,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
             let rawBody;
             const requestScope = createRequestScope({
                 provider,
+                staticSensitiveValues,
                 kind: "auth",
                 route: logRoute,
                 headers: Object.fromEntries(c.req.raw.headers.entries()),
@@ -2278,6 +2546,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                     .clone()
                     .json()
                     .catch(() => undefined);
+                requestScope.seedCredentials(rawBody, "auth");
                 const body = withAuthRequestHeaders(AuthFlowRequestSchema.parse(rawBody), c.req.raw.headers);
                 requestScope.enrich({
                     requestId: body.requestId,
@@ -2306,7 +2575,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
                 const requestId = extractRequestId(rawBody);
                 requestScope.enrich({ ...(requestId ? { requestId } : {}) });
                 const observabilityDetails = errorObservabilityDetails(error);
-                const response = c.json(toErrorResponse(error, requestId, observabilityDetails), status);
+                const response = c.json(toErrorResponse(error, requestId, observabilityDetails, requestScope.redact), status);
                 return finalizeRequestResponse(requestScope, response, {
                     kind: "failed",
                     status,