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

package/dist/runtime/native-telemetry.js

@@ -0,0 +1,231 @@
+import { Buffer } from "node:buffer";
+import { closedEnum } from "./request-telemetry.js";
+const MAX_SAMPLES = 24;
+function integer(value) {
+    return Math.max(0, Math.floor(Number.isFinite(value) ? value : 0));
+}
+function saturatingAdd(a, b) {
+    if (!Number.isFinite(a) || !Number.isFinite(b))
+        return Number.MAX_SAFE_INTEGER;
+    return Math.min(Number.MAX_SAFE_INTEGER, integer(a) + integer(b));
+}
+function boundedText(value, redact) {
+    let result;
+    try {
+        result = redact ? redact(value) : value;
+        if (typeof result !== "string")
+            return "[REDACTION_FAILED]";
+    }
+    catch {
+        return "[REDACTION_FAILED]";
+    }
+    // Do not slice caller text: a substring may retain the entire vendor response.
+    const length = Math.min(result.length, 300);
+    const units = Buffer.alloc(length * 2);
+    for (let index = 0; index < length; index++)
+        units.writeUInt16LE(result.charCodeAt(index), index * 2);
+    return units.toString("utf16le");
+}
+function diagnostics(value, redact) {
+    const result = {};
+    for (const key of [
+        "host",
+        "serverName",
+        "protocol",
+        "sessionId",
+        "expiresAt",
+        "errorName",
+        "errorMessage",
+        "causeName",
+        "causeMessage",
+        "systemCode",
+    ]) {
+        if (value[key] !== undefined)
+            result[key] = boundedText(value[key], redact);
+    }
+    for (const key of ["port", "timeoutMs", "idleTimeoutMs", "status", "socksReplyCode"]) {
+        if (value[key] !== undefined)
+            result[key] = integer(value[key]);
+    }
+    if (value.sticky !== undefined)
+        result.sticky = value.sticky;
+    if (value.missingFields)
+        result.missingFields = value.missingFields
+            .slice(0, MAX_SAMPLES)
+            .map((field) => boundedText(field, redact));
+    return result;
+}
+function copyDiagnostics(value) {
+    return { ...value, ...(value.missingFields ? { missingFields: [...value.missingFields] } : {}) };
+}
+export class NativeTelemetryCollector {
+    key = "native";
+    #redact;
+    #recorded = false;
+    #attempts = 0;
+    #connectMs = 0;
+    #tunnelMs = 0;
+    #vendorSkips = 0;
+    #vendorSkipReasons = new Map();
+    #lifecycle = {
+        drain: 0,
+        drain_acknowledged: 0,
+        drain_error: 0,
+        drain_missing_handler: 0,
+        idle: 0,
+        expiry: 0,
+    };
+    #bytesIn = 0;
+    #bytesOut = 0;
+    #lastErrorCode;
+    #lastErrorDiagnostics;
+    #attemptSamples = [];
+    #attemptSamplesDropped = 0;
+    #vendorSkipSamples = [];
+    #vendorSkipSamplesDropped = 0;
+    constructor(options = {}) {
+        this.#redact = options.redact;
+    }
+    recordConnect(event) {
+        this.#recorded = true;
+        const ms = saturatingAdd(0, event.ms);
+        const tunnelMs = saturatingAdd(0, event.tunnelMs);
+        this.#attempts = saturatingAdd(this.#attempts, 1);
+        this.#connectMs = saturatingAdd(this.#connectMs, ms);
+        this.#tunnelMs = saturatingAdd(this.#tunnelMs, tunnelMs);
+        if (event.errorCode)
+            this.recordError({ errorCode: event.errorCode, diagnostics: event.diagnostics });
+        if (this.#attemptSamples.length < MAX_SAMPLES) {
+            this.#attemptSamples.push({
+                n: this.#attempts,
+                kind: event.kind,
+                outcome: event.outcome,
+                ms,
+                tunnelMs,
+                proxyUsed: event.proxyUsed,
+                ...(event.vendor ? { vendor: event.vendor } : {}),
+                ...(event.errorCode ? { errorCode: event.errorCode } : {}),
+                ...(event.diagnostics ? { diagnostics: diagnostics(event.diagnostics, this.#redact) } : {}),
+            });
+        }
+        else
+            this.#attemptSamplesDropped = saturatingAdd(this.#attemptSamplesDropped, 1);
+    }
+    recordVendorSkip(event) {
+        this.#recorded = true;
+        this.#vendorSkips = saturatingAdd(this.#vendorSkips, 1);
+        this.#vendorSkipReasons.set(event.reason, saturatingAdd(this.#vendorSkipReasons.get(event.reason) ?? 0, 1));
+        if (this.#vendorSkipSamples.length < MAX_SAMPLES) {
+            this.#vendorSkipSamples.push({
+                vendor: event.vendor,
+                reason: event.reason,
+                ...(event.diagnostics ? { diagnostics: diagnostics(event.diagnostics, this.#redact) } : {}),
+            });
+        }
+        else
+            this.#vendorSkipSamplesDropped = saturatingAdd(this.#vendorSkipSamplesDropped, 1);
+    }
+    recordLifecycle(event) {
+        this.#recorded = true;
+        this.#lifecycle[event.kind] = saturatingAdd(this.#lifecycle[event.kind], 1);
+        if (event.errorCode)
+            this.recordError({ errorCode: event.errorCode, diagnostics: event.diagnostics });
+    }
+    recordBytes(event) {
+        this.#recorded = true;
+        if (event.direction === "in")
+            this.#bytesIn = saturatingAdd(this.#bytesIn, event.bytes);
+        else
+            this.#bytesOut = saturatingAdd(this.#bytesOut, event.bytes);
+    }
+    recordError(event) {
+        this.#recorded = true;
+        this.#lastErrorCode = event.errorCode;
+        this.#lastErrorDiagnostics = event.diagnostics
+            ? diagnostics(event.diagnostics, this.#redact)
+            : undefined;
+    }
+    toLogPayload() {
+        if (!this.#recorded)
+            return undefined;
+        return {
+            attempts: this.#attempts,
+            connectMs: this.#connectMs,
+            tunnelMs: this.#tunnelMs,
+            vendorSkips: this.#vendorSkips,
+            vendorSkipReasons: [...this.#vendorSkipReasons].map(([reason, count]) => ({ reason, count })),
+            drain: this.#lifecycle.drain,
+            drainAcknowledged: this.#lifecycle.drain_acknowledged,
+            drainErrors: this.#lifecycle.drain_error,
+            drainMissingHandler: this.#lifecycle.drain_missing_handler,
+            idle: this.#lifecycle.idle,
+            expiry: this.#lifecycle.expiry,
+            bytesIn: this.#bytesIn,
+            bytesOut: this.#bytesOut,
+            ...(this.#lastErrorCode ? { lastErrorCode: this.#lastErrorCode } : {}),
+            ...(this.#lastErrorDiagnostics
+                ? { lastErrorDiagnostics: copyDiagnostics(this.#lastErrorDiagnostics) }
+                : {}),
+            ...(this.#attemptSamples.length
+                ? {
+                    attemptSamples: this.#attemptSamples.map((sample) => ({
+                        ...sample,
+                        ...(sample.diagnostics ? { diagnostics: copyDiagnostics(sample.diagnostics) } : {}),
+                    })),
+                }
+                : {}),
+            ...(this.#attemptSamplesDropped
+                ? { attemptSamplesDropped: this.#attemptSamplesDropped }
+                : {}),
+            ...(this.#vendorSkipSamples.length
+                ? {
+                    vendorSkipSamples: this.#vendorSkipSamples.map((sample) => ({
+                        ...sample,
+                        ...(sample.diagnostics ? { diagnostics: copyDiagnostics(sample.diagnostics) } : {}),
+                    })),
+                }
+                : {}),
+            ...(this.#vendorSkipSamplesDropped
+                ? { vendorSkipSamplesDropped: this.#vendorSkipSamplesDropped }
+                : {}),
+        };
+    }
+    toHeaderPayload(log) {
+        return {
+            attempts: log.attempts,
+            connectMs: log.connectMs,
+            tunnelMs: log.tunnelMs,
+            vendorSkips: log.vendorSkips,
+            vendorSkipReasons: log.vendorSkipReasons.map(({ reason, count }) => ({
+                reason: closedEnum(reason),
+                count,
+            })),
+            drain: log.drain,
+            drainAcknowledged: log.drainAcknowledged,
+            drainErrors: log.drainErrors,
+            drainMissingHandler: log.drainMissingHandler,
+            idle: log.idle,
+            expiry: log.expiry,
+            bytesIn: log.bytesIn,
+            bytesOut: log.bytesOut,
+            ...(log.lastErrorCode ? { lastErrorCode: closedEnum(log.lastErrorCode) } : {}),
+            ...(log.attemptSamples
+                ? {
+                    attemptSamples: log.attemptSamples.map((sample) => ({
+                        n: sample.n,
+                        kind: closedEnum(sample.kind),
+                        outcome: closedEnum(sample.outcome),
+                        ms: sample.ms,
+                        tunnelMs: sample.tunnelMs,
+                        proxyUsed: sample.proxyUsed,
+                        ...(sample.errorCode ? { errorCode: closedEnum(sample.errorCode) } : {}),
+                    })),
+                }
+                : {}),
+            ...(log.attemptSamplesDropped ? { attemptSamplesDropped: log.attemptSamplesDropped } : {}),
+            ...(log.vendorSkipSamplesDropped
+                ? { vendorSkipSamplesDropped: log.vendorSkipSamplesDropped }
+                : {}),
+        };
+    }
+}

package/dist/runtime/state.d.ts

@@ -15,6 +15,9 @@ export declare function createProviderRuntimeStateFromEnv(options?: {
     readonly providerId?: string;
     readonly allowMemoryFallback?: boolean;
 }): ProviderRuntimeState;
-export declare function createMemoryProviderRuntimeState(): ProviderRuntimeState;
+export declare function createMemoryProviderRuntimeState(options?: {
+    /** Clock for expiry and timestamps; defaults to `Date.now`. */
+    readonly now?: () => number;
+}): ProviderRuntimeState;
 export declare function createUnsupportedProviderRuntimeState(): ProviderRuntimeState;
 export {};

package/dist/runtime/state.js

@@ -60,9 +60,12 @@ if not indexed and redis.call("ZCARD", KEYS[2]) >= max_entries then
 end
 
 if current_decoded and type(current_decoded.createdAt) == "string" then
-	local next_decoded = cjson.decode(envelope)
-	next_decoded.createdAt = current_decoded.createdAt
-	envelope = cjson.encode(next_decoded)
+	-- Preserve the original createdAt by patching the encoded envelope in place.
+	-- The envelope puts its metadata before "value", so the first match is the
+	-- envelope's own key, never a provider value; re-encoding with cjson would
+	-- silently turn [] inside the value into {}.
+	local preserved = string.gsub(current_decoded.createdAt, "%%", "%%%%")
+	envelope = (string.gsub(envelope, '"createdAt":"[^"]*"', '"createdAt":"' .. preserved .. '"', 1))
 end
 redis.call("SET", KEYS[1], envelope, "PXAT", expires_at)
 redis.call("ZADD", KEYS[2], expires_at, KEYS[1])
@@ -197,7 +200,11 @@ function isStateTombstone(raw) {
 }
 function redisEnvelope(value, version, createdAt, expiresAt) {
     const updatedAt = new Date().toISOString();
-    return { value, version, expiresAt, createdAt, updatedAt };
+    // Metadata precedes `value` on purpose: the compare-and-set Lua script patches
+    // `createdAt` in the encoded string (first occurrence) instead of decoding and
+    // re-encoding with cjson, which would turn empty arrays inside `value` into
+    // objects. Keep the key order stable.
+    return { version, expiresAt, createdAt, updatedAt, value };
 }
 class RedisProviderStateNamespace {
     backend;
@@ -404,10 +411,12 @@ class UnsupportedProviderRuntimeState {
 }
 class MemoryProviderStateNamespace {
     options;
+    now;
     // biome-ignore lint/suspicious/noExplicitAny: in-memory state stores heterogeneous generic values by key.
     values = new Map();
-    constructor(options) {
+    constructor(options, now = Date.now) {
         this.options = options;
+        this.now = now;
     }
     enforceValueSize(value) {
         const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
@@ -426,7 +435,7 @@ class MemoryProviderStateNamespace {
             throw new UnsupportedProviderStateError(`Provider runtime state namespace quota exceeded (${this.options.maxEntries + 1} > ${this.options.maxEntries})`);
         }
     }
-    pruneExpired(nowMs = Date.now()) {
+    pruneExpired(nowMs = this.now()) {
         for (const [key, row] of this.values.entries()) {
             if (row.expiresAt && Date.parse(row.expiresAt) <= nowMs) {
                 this.values.delete(key);
@@ -445,9 +454,9 @@ class MemoryProviderStateNamespace {
     async set(key, value, options) {
         this.pruneExpired();
         this.enforceWritePolicy(key, value, options?.ttl);
-        const now = new Date().toISOString();
+        const now = new Date(this.now()).toISOString();
         const current = this.values.get(key);
-        const expiresAt = resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl);
+        const expiresAt = resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl, this.now());
         const row = {
             key,
             value,
@@ -469,12 +478,12 @@ class MemoryProviderStateNamespace {
             return { ok: false, current: current ?? null };
         }
         this.enforceWritePolicy(key, value, options?.ttl);
-        const now = new Date().toISOString();
+        const now = new Date(this.now()).toISOString();
         const stored = {
             key,
             value,
             version: expectedVersion + 1,
-            expiresAt: resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl),
+            expiresAt: resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl, this.now()),
             createdAt: current?.createdAt ?? now,
             updatedAt: now,
         };
@@ -491,7 +500,10 @@ class MemoryProviderStateNamespace {
 class MemoryProviderRuntimeState {
     backend;
     scopeDiscriminator;
-    constructor(backend = { namespaces: new Map() }, scopeDiscriminator = MISSING_CONNECTION_SCOPE_DISCRIMINATOR) {
+    constructor(backend = {
+        namespaces: new Map(),
+        now: Date.now,
+    }, scopeDiscriminator = MISSING_CONNECTION_SCOPE_DISCRIMINATOR) {
         this.backend = backend;
         this.scopeDiscriminator = scopeDiscriminator;
     }
@@ -504,15 +516,15 @@ class MemoryProviderRuntimeState {
         const existing = this.backend.namespaces.get(namespaceIdentity);
         if (existing)
             return existing;
-        const created = new MemoryProviderStateNamespace(options);
+        const created = new MemoryProviderStateNamespace(options, this.backend.now);
         this.backend.namespaces.set(namespaceIdentity, created);
         return created;
     }
 }
-function resolveMemoryStateExpiresAt(ttl) {
+function resolveMemoryStateExpiresAt(ttl, nowMs = Date.now()) {
     const match = /^(\d+)(ms|s|m|h|d)$/.exec(ttl ?? "1h");
     if (!match)
-        return new Date(Date.now() + 3_600_000).toISOString();
+        return new Date(nowMs + 3_600_000).toISOString();
     const amount = Number(match[1]);
     const unit = match[2];
     const multiplier = unit === "ms"
@@ -524,7 +536,7 @@ function resolveMemoryStateExpiresAt(ttl) {
                 : unit === "h"
                     ? 3_600_000
                     : 86_400_000;
-    return new Date(Date.now() + amount * multiplier).toISOString();
+    return new Date(nowMs + amount * multiplier).toISOString();
 }
 export function createRedisProviderRuntimeState(options) {
     return new RedisProviderRuntimeState(options);
@@ -542,8 +554,11 @@ export function createProviderRuntimeStateFromEnv(options = {}) {
     }
     return createUnsupportedProviderRuntimeState();
 }
-export function createMemoryProviderRuntimeState() {
-    return new MemoryProviderRuntimeState();
+export function createMemoryProviderRuntimeState(options) {
+    return new MemoryProviderRuntimeState({
+        namespaces: new Map(),
+        now: options?.now ?? Date.now,
+    });
 }
 export function createUnsupportedProviderRuntimeState() {
     return new UnsupportedProviderRuntimeState();

package/dist/server/index.d.ts

@@ -12,3 +12,4 @@ export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, type SelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export type { AuthFlowRequest, AuthFlowResponse, AuthFlowSuccessResponse, ConnectionMode, OperationConnection, OperationErrorResponse, OperationRequest, OperationResponse, OperationSuccessResponse, } from "./types.js";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types.js";
+export { NativeTelemetryCollector, type NativeAttemptSample, type NativeConnectTelemetryEvent, type NativeLifecycleTelemetryEvent, type NativeTelemetryDiagnostics, type NativeTelemetryErrorCode, type NativeTelemetryHeaderPayload, type NativeTelemetryKind, type NativeTelemetryLifecycleKind, type NativeTelemetryLogPayload, type NativeTelemetryOutcome, type NativeTelemetrySink, type NativeTelemetryVendorSkipReason, type NativeVendorSkipTelemetryEvent, } from "../runtime/native-telemetry.js";

package/dist/server/index.js

@@ -6,3 +6,4 @@ export { resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js"
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types.js";
+export { NativeTelemetryCollector, } from "../runtime/native-telemetry.js";

package/dist/server/sensitive-values.d.ts

@@ -1,7 +1,7 @@
 import type { ProviderDefinition } from "../types.js";
 export declare const SELF_TEST_SENSITIVE_SOURCE_KINDS: readonly ["selfTestMasterSecrets", "providerSecrets", "healthProbeSecrets", "requestCredentials"];
 /** Explicit source allowlist: no environment-name or payload-shape secret sweep. */
-export declare const DIAGNOSTIC_SENSITIVE_SOURCE_KINDS: readonly ["selfTestMasterSecrets", "providerSecrets", "healthProbeSecrets", "requestCredentials", "engineProxyCredentials", "engineSolverKeys", "engineCeremonyLeaseCredentials", "choiceMasterSecret", "ocrCredentials", "sttCredentials", "cdpCredentials", "statefulForwardingSecret", "redisCredentials", "otlpHeaders", "cacheKeyPepper", "sensitiveParams"];
+export declare const DIAGNOSTIC_SENSITIVE_SOURCE_KINDS: readonly ["selfTestMasterSecrets", "providerSecrets", "healthProbeSecrets", "requestCredentials", "engineProxyCredentials", "engineSolverKeys", "engineCeremonyLeaseCredentials", "ocrCredentials", "sttCredentials", "cdpCredentials", "statefulForwardingSecret", "redisCredentials", "otlpHeaders", "cacheKeyPepper", "sensitiveParams"];
 export type DiagnosticSensitiveSourceKind = (typeof DIAGNOSTIC_SENSITIVE_SOURCE_KINDS)[number];
 /**
  * Startup inventory; request-scoped readers additionally register live values on access.

package/dist/server/sensitive-values.js

@@ -2,7 +2,6 @@ import { resolvedStringVariants, urlCredentialComponents, otlpHeaderCredentialVa
 import { PROVIDER_CACHE_REDIS_URL_ENV, PROVIDER_STATE_REDIS_URL_ENV, REDIS_URL_ENV, } from "../config/loader.js";
 import { ENGINE_OWNED_PROXY_CREDENTIAL_ENV_NAMES, ENGINE_OWNED_RESOLVER_CREDENTIAL_ENV_NAMES, } from "../engine.js";
 import { APIFUSE__CACHE__KEY_PEPPER_ENV } from "../runtime/cache.js";
-import { PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV } from "../runtime/choice.js";
 import { APIFUSE__ENGINE__CEREMONY_LEASE_KEY } from "../runtime/egress-lease.js";
 import { APIFUSE__OCR__API_KEY_ENV, APIFUSE__OCR__CLOUDFLARE_API_TOKEN_ENV, } from "../runtime/ocr.js";
 import { OTEL_EXPORTER_OTLP_HEADERS, OTEL_EXPORTER_OTLP_TRACES_HEADERS, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, } from "../runtime/otlp.js";
@@ -21,7 +20,6 @@ export const DIAGNOSTIC_SENSITIVE_SOURCE_KINDS = [
     "engineProxyCredentials",
     "engineSolverKeys",
     "engineCeremonyLeaseCredentials",
-    "choiceMasterSecret",
     "ocrCredentials",
     "sttCredentials",
     "cdpCredentials",
@@ -68,7 +66,6 @@ export function collectDiagnosticSensitiveValues(provider, options = {}) {
         // These are the resolver-config API keys after #251's engine credential projection.
         engineSolverKeys: () => resolvedEnvValues(ENGINE_OWNED_RESOLVER_CREDENTIAL_ENV_NAMES),
         engineCeremonyLeaseCredentials: () => resolvedEnvValues([APIFUSE__ENGINE__CEREMONY_LEASE_KEY]),
-        choiceMasterSecret: () => resolvedEnvValues([PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV]),
         ocrCredentials: () => resolvedEnvValues([APIFUSE__OCR__CLOUDFLARE_API_TOKEN_ENV, APIFUSE__OCR__API_KEY_ENV]),
         sttCredentials: () => resolvedEnvValues([APIFUSE__STT__CLOUDFLARE_API_TOKEN_ENV]),
         cdpCredentials: () => resolvedStringVariants(env[APIFUSE__CDP_POOL__URL]).flatMap((url) => [

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

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { type ProviderEngine } from "../engine.js";
 import { type ProviderErrorObservability } from "../errors.js";
 import { type ProviderErrorCategory } from "../observability.js";
+import type { HandleTelemetryEvent } from "../handle.js";
 import { type ProxyTelemetryLogPayload } from "../runtime/proxy-telemetry.js";
 import { type ResolverTelemetryLogPayload } from "../runtime/resolver-telemetry.js";
 import type { OcrContext, ProviderContext, ProviderDefinition, ProviderFilesContext, ProviderRuntimeState, ResolverContext, SttContext } from "../types.js";
@@ -115,18 +116,10 @@ export type ProviderServerLogEvent = (ProviderServerLogEventBase & {
     event: "provider_secrets_missing";
     providerId: string;
     missingSecrets: string[];
-} | {
+} | ({
     level: "info";
-    event: "provider_choice_token";
-    providerId: string;
-    purpose: string;
-    operation: "parse" | "consume";
-    format: "word" | "legacy";
-    outcome: "success" | "not-found" | "invalid" | "unsupported" | "error";
-    consumeMode: "never" | "on-parse" | "explicit";
-    consumed: boolean;
-    replay: boolean;
-} | {
+    event: "provider_handle";
+} & HandleTelemetryEvent) | {
     level: "warn";
     event: "provider_cleanup_failed";
     providerId: string;

package/dist/server/serve-implementation.js

@@ -1,3 +1,4 @@
+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";
@@ -18,7 +19,7 @@ import { loadProviderLocaleCatalogs, localizeAuthTurn, } from "../i18n/catalog.j
 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";
@@ -525,10 +526,7 @@ function createProviderContext(provider, request, operationId, options, state =
             : {}),
     };
     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,
-    ]);
+    const env = createEnvContext([...providerSecretNames(provider)]);
     const credential = createCredentialContext({
         allowedKeys: provider.credential?.keys,
         mode: request.connection?.mode,
@@ -575,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,
@@ -596,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,
             }),
         }),
@@ -732,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,
@@ -884,6 +884,52 @@ function toErrorResponse(error, requestId, observabilityDetails, redact) {
 // 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
@@ -909,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,
@@ -1415,9 +1480,11 @@ function createRequestScope(input) {
     bindDiagnosticSensitiveRegistry(trace, sensitiveRegistry);
     const proxyCollector = new ProxyTelemetryCollector();
     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) => {
@@ -1494,6 +1561,7 @@ function createRequestScope(input) {
         trace,
         telemetry,
         resolverTelemetry: resolverCollector,
+        nativeTelemetry: nativeCollector,
         seedCredentials(rawBody, kind) {
             const harvested = rawRequestCredentials(rawBody, kind);
             sensitiveRegistry.add(harvested.values);