@apifuse/provider-sdk 2.2.0-beta.47 → 2.2.0-beta.49

package/dist/runtime/trace.js

@@ -52,6 +52,17 @@ function insertCompletedSpan(completed, entry, maxSpans) {
         completed.splice(0, completed.length - maxSpans);
     }
 }
+/** Hands the hook a copy whose attributes are detached from the recorded span; a hook that returns nothing fails closed. */
+function prepareSpanForExport(span, sanitize) {
+    const copy = { ...span, attributes: { ...span.attributes } };
+    if (!sanitize)
+        return copy;
+    const sanitized = sanitize(copy);
+    if (!sanitized || typeof sanitized !== "object") {
+        throw new Error("sanitizeSpanForExport returned no span");
+    }
+    return sanitized;
+}
 export function getTraceRecorder(trace) {
     return trace[TRACE_RECORDER] ?? null;
 }
@@ -60,14 +71,40 @@ export function createTraceContext(options = {}) {
     const completed = [];
     const activeSpanStorage = new AsyncLocalStorage();
     let sequence = 0;
-    let traceContext;
+    // Export configuration (which can carry collector credentials) stays in this closure;
+    // the context object handed to provider code never exposes it.
+    const exportOptions = options.exportOptions;
+    const exportResourceAttributes = options.resourceAttributes
+        ? { ...options.resourceAttributes }
+        : undefined;
+    // One trace id per context so every export batch of this request shares it and
+    // two processes can never mint the same id.
+    const exportTraceId = crypto.randomUUID().replace(/-/g, "");
+    let exportScheduled = false;
+    // One pending batch per context: roots completing before the flush share it, and a span is
+    // handed to the exporter exactly once, so later roots never re-send earlier spans.
     const scheduleExport = () => {
-        if (!traceContext._exportOptions) {
+        if (!exportOptions || exportScheduled) {
             return;
         }
-        const spans = completed.map((entry) => ({ ...entry.span }));
+        exportScheduled = true;
         setImmediate(() => {
-            void exportSpansOTLP(spans, traceContext._exportOptions, traceContext._resourceAttributes);
+            exportScheduled = false;
+            const pending = completed.filter((entry) => !entry.exported);
+            for (const entry of pending)
+                entry.exported = true;
+            if (pending.length === 0)
+                return;
+            // Sanitization runs off the request path; a faulty sanitizer drops the batch, never the request.
+            let spans;
+            try {
+                spans = pending.map((entry) => prepareSpanForExport(entry.span, options.sanitizeSpanForExport));
+            }
+            catch {
+                console.warn("[apifuse] OTLP export skipped; span sanitization failed.");
+                return;
+            }
+            void exportSpansOTLP(spans, exportOptions, exportResourceAttributes, exportTraceId);
         });
     };
     const recorder = {
@@ -101,7 +138,7 @@ export function createTraceContext(options = {}) {
                     ...(error ? { error } : {}),
                     ...(pendingSpan.parentId ? { parentId: pendingSpan.parentId } : {}),
                 };
-                insertCompletedSpan(completed, { sequence: pendingSpan.sequence, span }, maxSpans);
+                insertCompletedSpan(completed, { sequence: pendingSpan.sequence, span, exported: false }, maxSpans);
                 options.onSpan?.(span);
                 if (!pendingSpan.parentId) {
                     scheduleExport();
@@ -123,17 +160,13 @@ export function createTraceContext(options = {}) {
             });
         },
     };
-    traceContext = {
+    const traceContext = {
         span(name, fn) {
             return recorder.runSpan(name, fn);
         },
         getSpans() {
             return completed.map((entry) => ({ ...entry.span }));
         },
-        ...(options.exportOptions ? { _exportOptions: options.exportOptions } : {}),
-        ...(options.resourceAttributes
-            ? { _resourceAttributes: { ...options.resourceAttributes } }
-            : {}),
         [TRACE_RECORDER]: recorder,
     };
     return traceContext;

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

@@ -134,9 +134,7 @@ export interface SelfTestAppOptions {
 export declare function computeSelfTestPlanDigest(provider: ProviderDefinition): string;
 /**
  * Fail-closed read-only classification: an operation may self-test only when
- * its own metadata marks it read-only (annotations.readOnly or
- * toolRouter.riskClass "read") and nothing marks it side-effecting. Unclassified
- * operations are refused so the endpoint cannot become a mutation oracle.
+ * its authored safety source of truth classifies it as read-only.
  */
 export declare function isSelfTestReadOnlyOperation(operation: OperationDefinition): boolean;
 /** Binds the self-test executor to a tenant app's /v1 pipeline in-process. */

package/dist/server/self-test.js

@@ -115,20 +115,10 @@ export function computeSelfTestPlanDigest(provider) {
 }
 /**
  * Fail-closed read-only classification: an operation may self-test only when
- * its own metadata marks it read-only (annotations.readOnly or
- * toolRouter.riskClass "read") and nothing marks it side-effecting. Unclassified
- * operations are refused so the endpoint cannot become a mutation oracle.
+ * its authored safety source of truth classifies it as read-only.
  */
 export function isSelfTestReadOnlyOperation(operation) {
-    const annotations = operation.annotations;
-    if (annotations?.readOnly === false)
-        return false;
-    if (annotations?.destructive === true)
-        return false;
-    const riskClass = operation.toolRouter?.riskClass;
-    if (riskClass !== undefined && riskClass !== "read")
-        return false;
-    return annotations?.readOnly === true || riskClass === "read";
+    return operation.riskClass === "read";
 }
 /** Binds the self-test executor to a tenant app's /v1 pipeline in-process. */
 export function createSelfTestInvoke(app) {

package/dist/server/serve-implementation.d.ts

@@ -1,9 +1,10 @@
 import { Hono } from "hono";
 import { z } from "zod";
+import { type ProviderEngine } from "../engine.js";
 import { type ProviderErrorObservability } from "../errors.js";
 import { type ProviderErrorCategory } from "../observability.js";
 import { type ProxyTelemetryLogPayload } from "../runtime/proxy-telemetry.js";
-import type { OcrContext, ProviderContext, ProviderDefinition, ProviderRuntimeState, ResolverContext, SttContext } from "../types.js";
+import type { OcrContext, ProviderContext, ProviderDefinition, ProviderFilesContext, ProviderRuntimeState, ResolverContext, SttContext } from "../types.js";
 import type { SelfTestCancellationLogEvent } from "./self-test.js";
 import { type AuthFlowRequest, type OperationRequest } from "./types.js";
 /** Compact SDK-owned error classification emitted separately from the public response body. */
@@ -140,6 +141,10 @@ export type ProviderServerLogEvent = (ProviderServerLogEventBase & {
 export type ProviderServerLogger = (event: ProviderServerLogEvent) => void;
 export type ProviderServerOptions<TContext extends Partial<ProviderContext> = ProviderContext> = {
     logger?: ProviderServerLogger;
+    /** Capability attachment boundary. Defaults to the local in-process engine. */
+    engine?: ProviderEngine;
+    /** Request-file resolver supplied by the engine host when `files` is declared. */
+    files?: ProviderFilesContext;
     /** Optional provider-specific operation executor. Stateful providers use this to preserve provider-local runtime semantics. */
     operationExecutor?: ProviderServerOperationExecutor<TContext>;
     /** Optional signed internal executor for stateful owner forwarding. */

package/dist/server/serve-implementation.js

@@ -7,6 +7,7 @@ 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 { 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 { sanitizeDiagnosticText } from "../fixture-sanitization.js";
@@ -307,7 +308,7 @@ function getProviderStealthBaseUrl(provider) {
     return firstHost ? `https://${firstHost}` : undefined;
 }
 function getProviderStealthProfile(provider) {
-    return provider.stealth?.profile ? getStealthProfile(provider.stealth.profile) : undefined;
+    return provider.stealth ? getStealthProfile(provider.stealth) : undefined;
 }
 function isProductionProviderBrowserMode(provider, env = process.env) {
     if (provider.runtime !== "browser") {
@@ -394,16 +395,21 @@ function resolveNativeProxyPolicy(provider) {
         return { mode: "disabled" };
     return undefined;
 }
+function providerSecretNames(provider) {
+    return (provider.secrets?.map((secret) => secret.name) ?? []).filter((name) => !isEngineOwnedEnvName(name));
+}
 function createProviderContext(provider, request, operationId, options, state = createUnsupportedProviderRuntimeState(), proxyTelemetry, signal) {
     const traceConfig = resolveTraceConfigFromEnv();
     const baseUrl = getProviderBaseUrl(provider);
     const stealthBaseUrl = getProviderStealthBaseUrl(provider);
     const stealthProfile = getProviderStealthProfile(provider);
     const proxyPolicy = resolveNativeProxyPolicy(provider);
+    const engineProxyCredentials = readEngineProxyCredentials();
     const proxyClientOptions = {
         upstream: { proxy: provider.proxy },
         affinityKey: resolveProviderProxyAffinityKey(provider, request, operationId),
         telemetry: proxyTelemetry,
+        engineCredentials: engineProxyCredentials,
     };
     const resolverIdentityScope = resolveProviderResolverIdentityScope(provider, proxyClientOptions.affinityKey, request.requestId);
     let wrappedContext;
@@ -411,12 +417,14 @@ function createProviderContext(provider, request, operationId, options, state =
         upstream: proxyClientOptions.upstream,
         affinityKey: proxyClientOptions.affinityKey,
         telemetry: proxyTelemetry,
+        engineCredentials: engineProxyCredentials,
         ...(signal ? { signal } : {}),
+        ...(provider.stealth ? { stealth: provider.stealth } : {}),
     };
     const { capabilityModules } = options;
     const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
     const env = createEnvContext([
-        ...(provider.secrets?.map((secret) => secret.name) ?? []),
+        ...providerSecretNames(provider),
         PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
     ]);
     const credential = createCredentialContext({
@@ -431,9 +439,10 @@ function createProviderContext(provider, request, operationId, options, state =
     };
     const requestState = state.forConnection(requestContext.connectionId);
     const cache = createProviderCache({ providerId: provider.id });
-    const context = wrapWithInstrumentation({
+    const bindings = {
         env,
         credential,
+        ...(options.files ? { files: options.files } : {}),
         request: requestContext,
         http: createHttpClient(baseUrl, {
             ...proxyClientOptions,
@@ -448,12 +457,8 @@ function createProviderContext(provider, request, operationId, options, state =
         state: requestState,
         stealth: stealthBaseUrl
             ? capabilityModules.stealth
-                ? stealthProfile
-                    ? capabilityModules.stealth.createStealthClient(stealthBaseUrl, provider.stealth.profile, stealthClientOptions)
-                    : capabilityModules.stealth.createStealthClient(stealthBaseUrl, stealthClientOptions)
-                : stealthProfile
-                    ? createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, provider.stealth.profile, stealthClientOptions)
-                    : createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, stealthClientOptions)
+                ? capabilityModules.stealth.createStealthClient(stealthBaseUrl, stealthClientOptions)
+                : createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, stealthClientOptions)
             : createStealthStub(),
         browser: provider.runtime === "browser"
             ? capabilityModules.browser.createBrowserClient({
@@ -472,7 +477,7 @@ function createProviderContext(provider, request, operationId, options, state =
                         egress: provider.native.network,
                         proxyPolicy: resolveNativeProxyPolicy(provider),
                         affinityKey: proxyClientOptions.affinityKey,
-                        credentials: capabilityModules.nativeNetwork.createEnvVendorCredentialResolver(env),
+                        credentials: capabilityModules.nativeNetwork.createEnvVendorCredentialResolver(createEnvContext([...ENGINE_OWNED_PROXY_CREDENTIAL_ENV_NAMES])),
                     }),
                 },
             }
@@ -517,7 +522,8 @@ function createProviderContext(provider, request, operationId, options, state =
                 ...event,
             }),
         }),
-    });
+    };
+    const context = wrapWithInstrumentation(options.engine.attach({ provider, bindings }));
     wrappedContext = context;
     return context;
 }
@@ -557,19 +563,23 @@ function createAuthFlowContext(provider, request, options, state, proxyTelemetry
     const stealthBaseUrl = getProviderStealthBaseUrl(provider);
     const stealthProfile = getProviderStealthProfile(provider);
     const proxyPolicy = resolveNativeProxyPolicy(provider);
+    const engineProxyCredentials = readEngineProxyCredentials();
     const contextData = request.context ?? {};
     const flowContextStore = createFlowContextStore(provider.context?.keys ?? Object.keys(contextData), contextData);
     const proxyClientOptions = {
         upstream: { proxy: provider.proxy },
         affinityKey: resolveAuthFlowProxyAffinityKey(provider, request),
         telemetry: proxyTelemetry,
+        engineCredentials: engineProxyCredentials,
     };
     const resolverIdentityScope = resolveProviderResolverIdentityScope(provider, proxyClientOptions.affinityKey, request.requestId);
     const stealthClientOptions = {
         upstream: proxyClientOptions.upstream,
         affinityKey: proxyClientOptions.affinityKey,
         telemetry: proxyTelemetry,
+        engineCredentials: engineProxyCredentials,
         ...(signal ? { signal } : {}),
+        ...(provider.stealth ? { stealth: provider.stealth } : {}),
     };
     const { capabilityModules } = options;
     const logStealthCleanupError = (error) => logProviderCleanupError(options.logger, provider, "auth", "flow", request.requestId, "stealth", error);
@@ -596,12 +606,8 @@ function createAuthFlowContext(provider, request, options, state, proxyTelemetry
             state: state.forConnection(resolveOperationConnectionId(request)),
             stealth: stealthBaseUrl
                 ? capabilityModules.stealth
-                    ? stealthProfile
-                        ? capabilityModules.stealth.createStealthClient(stealthBaseUrl, provider.stealth.profile, stealthClientOptions)
-                        : capabilityModules.stealth.createStealthClient(stealthBaseUrl, stealthClientOptions)
-                    : stealthProfile
-                        ? createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, provider.stealth.profile, stealthClientOptions)
-                        : createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, stealthClientOptions)
+                    ? capabilityModules.stealth.createStealthClient(stealthBaseUrl, stealthClientOptions)
+                    : createLazyStealthClient(logStealthCleanupError, stealthBaseUrl, stealthClientOptions)
                 : createStealthStub(),
             ...(provider.native
                 ? {
@@ -610,13 +616,13 @@ function createAuthFlowContext(provider, request, options, state, proxyTelemetry
                             egress: provider.native.network,
                             proxyPolicy: resolveNativeProxyPolicy(provider),
                             affinityKey: proxyClientOptions.affinityKey,
-                            credentials: capabilityModules.nativeNetwork.createEnvVendorCredentialResolver(createEnvContext(provider.secrets?.map((secret) => secret.name))),
+                            credentials: capabilityModules.nativeNetwork.createEnvVendorCredentialResolver(createEnvContext([...ENGINE_OWNED_PROXY_CREDENTIAL_ENV_NAMES])),
                         }),
                     },
                 }
                 : {}),
             env: createEnvContext([
-                ...(provider.secrets?.map((secret) => secret.name) ?? []),
+                ...providerSecretNames(provider),
                 ...(provider.auth?.mode === "oauth2_proxied" ? ["APIFUSE__AUTH_PROXY__URL"] : []),
             ]),
             credential,
@@ -766,11 +772,8 @@ function providerObservabilityDetails(error, declaredErrorCode) {
     const declaredRetryable = sdkOwnsErrorResolution(error)
         ? undefined
         : declaredErrorCode?.retryable;
-    // Session-expiry surfaces the credential_expired category + the opt-in
-    // retryable signal so Gateway/Credential Service can refresh and re-drive the
-    // operation (see design.md §4.3 D3). Without this branch the auth error would
-    // serialize as a bare 401 with no retryable/category, losing the refresh
-    // signal for exactly the retryOnAuthRefresh operations it is meant to enable.
+    // Session-expiry surfaces the credential_expired category so Gateway and
+    // Credential Service can distinguish an expired credential from other 401s.
     if (isSessionExpiredError(error)) {
         return {
             category: providerErrorOption(error, "category") ?? "credential_expired",
@@ -962,7 +965,7 @@ function sdkOwnsErrorResolution(error) {
 }
 function buildOperationErrorCodeLookup(provider) {
     return new Map(Object.entries(provider.operations).flatMap(([operationId, operation]) => {
-        const errorCodes = operation.docs?.errorCodes;
+        const errorCodes = operation.errorCodes;
         return errorCodes?.length
             ? [[operationId, new Map(errorCodes.map((entry) => [entry.code, entry]))]]
             : [];
@@ -1063,7 +1066,7 @@ function logProviderError(logger, provider, kind, route, requestId, error, statu
         ...(isUnregisteredProviderErrorCode
             ? {
                 signal: "unregistered_provider_error_code",
-                signalFix: "Declare this code (with status and retryable) in the operation's docs.errorCodes so it serves its intended status instead of 500.",
+                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) } : {}),
@@ -1107,7 +1110,7 @@ function toJsonSuccessResponse(result, ctx) {
     if (result instanceof ReadableStream) {
         return new Response(result);
     }
-    const cacheMeta = ctx?.cache.responseMeta();
+    const cacheMeta = ctx && "cache" in ctx ? ctx.cache.responseMeta() : undefined;
     const retryMeta = ctx ? retryResponseMeta.get(ctx) : undefined;
     const meta = cacheMeta || retryMeta
         ? {
@@ -1425,17 +1428,21 @@ async function handleOperation(provider, request, operationId, options, state =
         if (cleanupCalled)
             return;
         cleanupCalled = true;
-        try {
-            ctx.stealth.close?.();
-        }
-        catch (error) {
-            logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
-        }
-        try {
-            await ctx.browser.close?.();
+        if ("stealth" in ctx) {
+            try {
+                ctx.stealth.close?.();
+            }
+            catch (error) {
+                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "stealth", error);
+            }
         }
-        catch (error) {
-            logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "browser", error);
+        if ("browser" in ctx) {
+            try {
+                await ctx.browser.close?.();
+            }
+            catch (error) {
+                logProviderCleanupError(options.logger, provider, "operation", operationId, request.requestId, "browser", error);
+            }
         }
     };
     try {
@@ -1447,7 +1454,9 @@ async function handleOperation(provider, request, operationId, options, state =
                 request,
                 signal,
             })
-            : await executeOperation(provider, operationId, ctx, request.input);
+            : await executeOperation(provider, operationId, ctx, request.input, {
+                env: createEnvContext(providerSecretNames(provider)),
+            });
         if (streaming && operation) {
             return toStreamingResponse(operation, result, cleanup, request.requestId);
         }
@@ -1670,7 +1679,11 @@ export function createServerApp(provider, options = {}) {
     return createServerAppWithCapabilityModules(runtimeProvider, runtimeOptions, loadProviderCapabilityModulesSync(runtimeProvider));
 }
 function createServerAppWithCapabilityModules(provider, serverOptions, capabilityModules) {
-    const options = { ...serverOptions, capabilityModules };
+    const options = {
+        ...serverOptions,
+        capabilityModules,
+        engine: serverOptions.engine ?? createInProcessProviderEngine(),
+    };
     const app = new Hono();
     const logger = options.logger ?? defaultProviderServerLogger;
     const operationErrorCodes = buildOperationErrorCodeLookup(provider);
@@ -1686,7 +1699,7 @@ function createServerAppWithCapabilityModules(provider, serverOptions, capabilit
     // instead of discovering it request-by-request. Deliberately log-only — a
     // boot crash would trade a structured MISSING_SECRET signal for
     // CrashLoopBackOff. Requests still fail closed via the executeOperation gate.
-    const missingSecretsAtBoot = listMissingRequiredSecrets(provider, createEnvContext(provider.secrets?.map((secret) => secret.name)));
+    const missingSecretsAtBoot = listMissingRequiredSecrets(provider, createEnvContext(providerSecretNames(provider)));
     if (missingSecretsAtBoot.length > 0) {
         logger({
             level: "warn",
@@ -2064,6 +2077,8 @@ export async function serve(provider, options = {}) {
     const selfTestSecrets = resolveSelfTestMasterSecrets();
     const serverAppOptions = {
         logger: options.logger,
+        engine: options.engine,
+        files: options.files,
         ocr: options.ocr,
         stt: options.stt,
         resolver: options.resolver,

package/dist/server/trace-output.d.ts

@@ -1,4 +1,6 @@
 import { type CreateTraceContextOptions } from "../runtime/trace.js";
 import type { TraceConfig } from "../types.js";
+type EnvLike = Record<string, string | undefined>;
 /** Server-only trace output policy. Shared programmatic trace callers stay in-memory. */
-export declare function resolveServerTraceContextOptions(config: TraceConfig, resourceAttributes: Record<string, string>): CreateTraceContextOptions;
+export declare function resolveServerTraceContextOptions(config: TraceConfig, resourceAttributes: Record<string, string>, env?: EnvLike): CreateTraceContextOptions;
+export {};

package/dist/server/trace-output.js

@@ -1,7 +1,56 @@
+import { isSensitiveFixtureKey, REDACTED_FIXTURE_VALUE } from "../fixture-sanitization.js";
+import { OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, resolveOTLPExportOptions, resolveOTLPResourceAttributes, } from "../runtime/otlp.js";
 import { resolveTraceContextOptions, } from "../runtime/trace.js";
-import { sanitizeSpanForOutput } from "../trace-sanitization.js";
+import { sanitizeSpanForOutput, sanitizeSpanNameForOutput, sanitizeTraceAttributes, } from "../trace-sanitization.js";
+// Warn once per environment object: process.env in production, each injected env in tests.
+const warnedEnvironments = new WeakSet();
+const warnedResourceEnvironments = new WeakSet();
+function warnDiscardedResourceAttributes(env, resolution) {
+    if (resolution.discarded.length === 0 || warnedResourceEnvironments.has(env))
+        return;
+    warnedResourceEnvironments.add(env);
+    console.warn(`[apifuse] ${resolution.discarded.join(", ")} could not be parsed as an OTel key=value list and was ignored.`);
+}
+function warnExportDisabled(env, resolution) {
+    if (warnedEnvironments.has(env))
+        return;
+    warnedEnvironments.add(env);
+    console.warn(resolution.status === "unconfigured"
+        ? `[apifuse] OTLP trace export is enabled but no endpoint is configured; set ${OTEL_EXPORTER_OTLP_TRACES_ENDPOINT} or ${OTEL_EXPORTER_OTLP_ENDPOINT}. Trace export is disabled.`
+        : `[apifuse] OTLP trace export is enabled but ${resolution.source} ${resolution.reason}. Trace export is disabled.`);
+}
+function resolveServerOTLPExportOptions(config, env) {
+    const resolution = resolveOTLPExportOptions({
+        endpoint: config.otlp?.endpoint ?? config.endpoint,
+        headers: config.otlp?.headers,
+        timeout: config.otlp?.timeout,
+    }, env);
+    if (resolution.status === "resolved")
+        return resolution.options;
+    warnExportDisabled(env, resolution);
+    return undefined;
+}
+/**
+ * Per-request attributes carry client-supplied values (request_id) and get the full attribute
+ * sanitizer, exactly as on the console path. Operator-configured attributes from the process
+ * environment are identifiers rather than request data: their values are kept, with control
+ * characters neutralized, length bounded, and secret-named keys redacted.
+ */
+function resolveExportResourceAttributes(requestAttributes, env) {
+    const resolution = resolveOTLPResourceAttributes({}, env);
+    warnDiscardedResourceAttributes(env, resolution);
+    const operatorAttributes = Object.fromEntries(Object.entries(resolution.attributes).map(([key, value]) => [
+        sanitizeSpanNameForOutput(key),
+        isSensitiveFixtureKey(key) ? REDACTED_FIXTURE_VALUE : sanitizeSpanNameForOutput(value),
+    ]));
+    const sanitizedRequestAttributes = Object.fromEntries(Object.entries(sanitizeTraceAttributes(requestAttributes)).map(([key, value]) => [
+        key,
+        String(value),
+    ]));
+    return { ...operatorAttributes, ...sanitizedRequestAttributes };
+}
 /** Server-only trace output policy. Shared programmatic trace callers stay in-memory. */
-export function resolveServerTraceContextOptions(config, resourceAttributes) {
+export function resolveServerTraceContextOptions(config, resourceAttributes, env = process.env) {
     const resolved = resolveTraceContextOptions(config);
     const outputEnabled = config.enabled !== false && config.exporter !== "none";
     const consoleHook = outputEnabled && (config.exporter === "console" || config.exporter === "json")
@@ -13,8 +62,18 @@ export function resolveServerTraceContextOptions(config, resourceAttributes) {
             resolved.onSpan?.(span);
         }
         : (consoleHook ?? resolved.onSpan);
+    const exportOptions = outputEnabled && config.exporter === "otlp"
+        ? resolveServerOTLPExportOptions(config, env)
+        : undefined;
     return {
         maxSpans: resolved.maxSpans,
         onSpan,
+        ...(exportOptions
+            ? {
+                exportOptions,
+                resourceAttributes: resolveExportResourceAttributes(resourceAttributes, env),
+                sanitizeSpanForExport: (span) => sanitizeSpanForOutput(span),
+            }
+            : {}),
     };
 }

package/dist/stealth/profiles.d.ts

@@ -1,8 +1,9 @@
-import type { StealthProfile } from "../types.js";
-export declare function generateLayer2Headers(profile: StealthProfile): Record<string, string>;
-export declare function getStealthProfile(name: string): StealthProfile;
-/** Returns the intent alias that replaces a registered version-pinned profile. */
-export declare function getStealthProfileIntentAlias(name: string): string | undefined;
-/** Internal compatibility catalog used by transport-parity tests. */
-export declare function listRegisteredStealthProfiles(): string[];
-export declare function listStealthProfiles(): string[];
+import type { StealthProfile, StealthProfileDescriptor, StealthProfileSelection } from "../types.js";
+export declare const DEFAULT_STEALTH_BROWSER: "chrome";
+export declare const DEFAULT_STEALTH_OS: "macos";
+/** Internal detector used to keep version-pinned string failures actionable. */
+export declare function getVersionPinnedStealthReplacement(name: string): string | undefined;
+/** Resolve omitted axes and validate that the resulting pair is supported. */
+export declare function resolveStealthProfileSelection(selection: StealthProfileSelection | undefined, base?: StealthProfileDescriptor): StealthProfileDescriptor;
+export declare function getStealthProfile(selection?: StealthProfileSelection): StealthProfile;
+export declare function listStealthProfiles(): StealthProfileDescriptor[];