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

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,6 @@ 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 { HttpTelemetryCollector, type HttpTelemetrySink, type HttpTelemetryRequestSink, type HttpAttemptTelemetryEvent, type HttpAttemptSample, type HttpTelemetryErrorCode, type HttpTelemetryRetryPayload, type HttpTelemetryLogPayload, type HttpTelemetryHeaderPayload, } from "../runtime/http-telemetry.js";
+export type { HttpRetrySummary } 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,5 @@ 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 { HttpTelemetryCollector, } from "../runtime/http-telemetry.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,8 @@ 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 HttpTelemetryLogPayload } from "../runtime/http-telemetry.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";
@@ -87,6 +89,7 @@ type ProviderServerLogEventBase = ProviderRequestCost & {
     status: number;
     proxy?: ProxyTelemetryLogPayload;
     resolver?: ResolverTelemetryLogPayload;
+    http?: HttpTelemetryLogPayload;
 };
 export type ProviderServerLogEvent = (ProviderServerLogEventBase & {
     level: "info";
@@ -115,18 +118,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;