@apifuse/provider-sdk 2.2.0-beta.59 → 2.2.0-beta.61

package/dist/server/serve-implementation.js

@@ -1,5 +1,8 @@
-import { createHash } from "node:crypto";
+import { NativeTelemetryCollector } from "../runtime/native-telemetry.js";
+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,29 +10,30 @@ 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, 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 { createHandleContext } from "../runtime/handle.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 { bindResolverTelemetry, createUnsupportedResolverClient, inheritResolverTelemetryBinding, } from "../runtime/resolver-shared.js";
 import { ResolverTelemetryCollector, } from "../runtime/resolver-telemetry.js";
-import { createUnsupportedResolverClient, bindResolverTelemetry, inheritResolverTelemetryBinding, } from "../runtime/resolver-shared.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";
@@ -37,13 +41,14 @@ import { createSttClientFromEnv } from "../runtime/stt.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";
@@ -520,11 +525,8 @@ function createProviderContext(provider, request, operationId, options, state =
             }
             : {}),
     };
-    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
-    const env = createEnvContext([
-        ...providerSecretNames(provider),
-        PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
-    ]);
+    const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error, scope.redact);
+    const env = createEnvContext([...providerSecretNames(provider)]);
     const credential = createCredentialContext({
         allowedKeys: provider.credential?.keys,
         mode: request.connection?.mode,
@@ -560,7 +562,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,
@@ -571,6 +573,8 @@ function createProviderContext(provider, request, operationId, options, state =
             ? {
                 native: {
                     network: capabilityModules.nativeNetwork.createNativeNetworkClient({
+                        telemetry: scope.telemetry.proxy,
+                        nativeTelemetry: scope.nativeTelemetry,
                         egress: provider.native.network,
                         proxyPolicy: resolveNativeProxyPolicy(provider),
                         affinityKey: proxyClientOptions.affinityKey,
@@ -592,15 +596,13 @@ function createProviderContext(provider, request, operationId, options, state =
                 ? bindResolverTelemetry(options.resolver, resolverOptions.telemetry)
                 : undefined) ??
                 createUnsupportedResolverClient("Provider does not declare resolver capability"), signal),
-        choice: createProviderChoiceContext({
+        handle: createHandleContext({
             providerId: provider.id,
-            env,
             request: requestContext,
-            credential,
             state: requestState,
             onTelemetry: (event) => (options.logger ?? defaultProviderServerLogger)({
                 level: "info",
-                event: "provider_choice_token",
+                event: "provider_handle",
                 ...event,
             }),
         }),
@@ -668,6 +670,7 @@ function createAuthFlowContext(provider, request, route, options, state, scope,
             providerId: provider.id,
             flowId: request.flowId,
             affinityKey: proxyClientOptions.affinityKey,
+            onHandle: (handle) => registerDiagnosticSensitiveValues(scope.trace, [handle]),
             ...(request.engine?.egressLease ? { handle: request.engine.egressLease } : {}),
         })
         : undefined;
@@ -697,7 +700,7 @@ function createAuthFlowContext(provider, request, route, options, state, scope,
             }
             : {}),
     };
-    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,
@@ -727,6 +730,8 @@ function createAuthFlowContext(provider, request, route, options, state, scope,
             ? {
                 native: {
                     network: capabilityModules.nativeNetwork.createNativeNetworkClient({
+                        telemetry: scope.telemetry.proxy,
+                        nativeTelemetry: scope.nativeTelemetry,
                         egress: provider.native.network,
                         proxyPolicy: resolveNativeProxyPolicy(provider),
                         affinityKey: proxyClientOptions.affinityKey,
@@ -786,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
@@ -813,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) {
@@ -849,7 +854,7 @@ function toErrorResponse(error, requestId, observabilityDetails) {
                 ...(requestId ? { requestId } : {}),
                 retryable: observability.retryable,
                 source,
-                details: zodDetails(error),
+                details: zodDetails(error, redact),
             },
         };
     }
@@ -879,6 +884,52 @@ function toErrorResponse(error, requestId, observabilityDetails) {
 // narrowing from a ProviderError-typed value would collapse the negative branch
 // to `never`. Narrowing from unknown avoids that while still recognizing errors
 // from a duplicate SDK module instance.
+function ownErrorCode(error) {
+    if (error === null || (typeof error !== "object" && typeof error !== "function")) {
+        return undefined;
+    }
+    try {
+        const descriptor = Object.getOwnPropertyDescriptor(error, "code");
+        return descriptor && Object.hasOwn(descriptor, "value") && typeof descriptor.value === "string"
+            ? descriptor.value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function errorChainHasCode(error, expected) {
+    const seen = new Set();
+    let current = error;
+    for (let depth = 0; depth < 5; depth++) {
+        if (current === null || (typeof current !== "object" && typeof current !== "function")) {
+            return false;
+        }
+        if (seen.has(current))
+            return false;
+        seen.add(current);
+        let code;
+        try {
+            code = providerErrorCode(current) ?? ownErrorCode(current);
+        }
+        catch {
+            code = ownErrorCode(current);
+        }
+        if (code === expected)
+            return true;
+        let cause;
+        try {
+            cause = Object.getOwnPropertyDescriptor(current, "cause");
+        }
+        catch {
+            return false;
+        }
+        if (!cause || !Object.hasOwn(cause, "value"))
+            return false;
+        current = cause.value;
+    }
+    return false;
+}
 function providerObservabilityDetails(error, declaredErrorCode) {
     const declaredRetryable = sdkOwnsErrorResolution(error)
         ? undefined
@@ -904,24 +955,43 @@ function providerObservabilityDetails(error, declaredErrorCode) {
             retryable: providerErrorOption(error, "retryable") ?? declaredRetryable ?? false,
         };
     }
+    // Native proxy resolution throws ProxyResolutionError directly, while HTTP
+    // normalizes it beneath a transport_network_error cause and stealth retains
+    // the original code. Preserve proxy attribution across all three forms.
+    if (errorChainHasCode(error, "PROXY_REQUIRED")) {
+        return {
+            category: "proxy_pool",
+            taxonomyVersion: PROVIDER_OBSERVABILITY_TAXONOMY_VERSION,
+            retryable: true,
+        };
+    }
     if (!isTransportError(error)) {
         return undefined;
     }
-    const isProxyPoolCode = providerErrorCode(error) === PROXY_POOL_EXHAUSTED_CODE ||
-        providerErrorCode(error) === PROXY_EDGE_AUTH_REJECTED_CODE ||
-        providerErrorCode(error) === "PROXY_ALLOCATION_FAILED";
+    const errorCode = providerErrorCode(error);
+    const isProxyPoolCode = errorCode === PROXY_POOL_EXHAUSTED_CODE ||
+        errorCode === PROXY_EDGE_AUTH_REJECTED_CODE ||
+        errorCode === "PROXY_ALLOCATION_FAILED" ||
+        errorCode === "native_proxy_expired" ||
+        errorCode === "native_proxy_invalid";
     const category = providerErrorOption(error, "category") ??
         (isProxyPoolCode
             ? "proxy_pool"
-            : providerErrorCode(error) === PROXY_AUTH_IP_DENIED_CODE
+            : errorCode === PROXY_AUTH_IP_DENIED_CODE
                 ? "anti_bot_blocked"
-                : providerErrorCode(error) === "transport_timeout"
+                : errorCode === "transport_timeout" ||
+                    errorCode === "native_connection_timeout" ||
+                    errorCode === "native_connection_idle_timeout"
                     ? "timeout"
-                    : providerErrorCode(error) === "transport_network_error"
+                    : errorCode === "transport_network_error" ||
+                        errorCode === "native_connection_failed" ||
+                        errorCode === "native_connection_closed"
                         ? "network"
-                        : error.upstreamStatus
-                            ? categoryForStatus(error.upstreamStatus)
-                            : "upstream_http");
+                        : errorCode === "native_connection_aborted"
+                            ? "client_cancelled"
+                            : error.upstreamStatus
+                                ? categoryForStatus(error.upstreamStatus)
+                                : "upstream_http");
     return {
         category,
         taxonomyVersion: PROVIDER_OBSERVABILITY_TAXONOMY_VERSION,
@@ -1097,13 +1167,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]);
@@ -1117,9 +1187,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 } : {}),
@@ -1128,7 +1198,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")
@@ -1139,7 +1209,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) &&
@@ -1158,24 +1228,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 } : {}),
@@ -1188,42 +1262,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,
@@ -1276,9 +1354,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,
@@ -1297,15 +1472,19 @@ 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();
+    const resolverCollector = new ResolverTelemetryCollector({ redact });
+    const nativeCollector = new NativeTelemetryCollector({ redact });
     const telemetry = new RequestTelemetry(trace);
     telemetry.register(proxyCollector);
     telemetry.register(resolverCollector);
+    telemetry.register(nativeCollector);
     let rootRunner = (fn) => fn();
     let resolveRoot;
     const rootTerminal = new Promise((resolve) => {
@@ -1326,13 +1505,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)
@@ -1368,7 +1547,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),
         ]));
@@ -1378,9 +1557,18 @@ function createRequestScope(input) {
         });
     };
     const scope = {
+        redact,
         trace,
         telemetry,
         resolverTelemetry: resolverCollector,
+        nativeTelemetry: nativeCollector,
+        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;
@@ -1442,21 +1630,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 {
@@ -1490,8 +1678,9 @@ function createRequestScope(input) {
     };
     return scope;
 }
-// A raw `Response` result skips `toErrorResponse`, so its body stays
-// provider-owned, but the observability header is still SDK-owned: derive it
+// 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.
@@ -1505,7 +1694,7 @@ function rawResponseErrorObservability(status) {
 // `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.
-function responseWithRequestScopeHeaders(response, finished, rawStatusFallback) {
+async function responseWithRequestScopeHeaders(response, finished, rawStatusFallback, redact) {
     const headers = new Headers(response.headers);
     headers.delete(PROVIDER_TELEMETRY_HEADER);
     if (finished.providerTelemetryHeader) {
@@ -1519,16 +1708,25 @@ function responseWithRequestScopeHeaders(response, finished, rawStatusFallback)
     if (errorObservability) {
         headers.set(ERROR_OBSERVABILITY_HEADER, JSON.stringify(errorObservability));
     }
-    return new Response(response.body, {
+    // 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), outcome.kind === "completed");
+        const finalResponse = await responseWithRequestScopeHeaders(response, scope.snapshotHeaders(error), outcome.kind === "completed", scope.redact);
         scope.terminalize(outcome);
         return finalResponse;
     }
@@ -1706,7 +1904,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();
@@ -1886,7 +2084,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) {
@@ -1894,11 +2092,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);
         },
@@ -1996,7 +2195,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);
         }
     }
 }
@@ -2102,13 +2301,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),
     });
 }
 /**
@@ -2142,6 +2341,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 ??
@@ -2182,6 +2385,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()),
@@ -2212,7 +2416,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" });
             }
@@ -2313,7 +2518,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,
@@ -2326,6 +2531,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
         const operation = c.req.param("operation");
         const requestScope = createRequestScope({
             provider,
+            staticSensitiveValues,
             kind: "operation",
             route: operation,
             operationId: operation,
@@ -2339,6 +2545,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 };
@@ -2356,7 +2563,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(), true)
+                    ? responseWithRequestScopeHeaders(response, requestScope.snapshotHeaders(), true, requestScope.redact)
                     : response;
             };
             const response = streaming
@@ -2375,7 +2582,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,
@@ -2395,6 +2602,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()),
@@ -2406,6 +2614,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,
@@ -2434,7 +2643,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,