@rheonic/sdk 0.1.0-beta.8 → 0.1.0-beta.9

package/CHANGELOG.md

@@ -4,7 +4,9 @@ All notable changes to `@rheonic/sdk` will be documented in this file.
 
 ## Unreleased
 
-- Publish-ready changelog entries will be added here for the next release.
+### Fixed
+- SDK debug logs now always emit non-empty `trace_id` and `span_id`, including warmup, token-estimation, and protect preflight paths.
+- Provider instrumentation now keeps the full protected call lifecycle under one trace so SDK debug logs correlate cleanly with backend requests.
 
 ## 0.1.0-beta.7
 

package/dist/client.js

@@ -130,7 +130,11 @@ export class Client {
     }
     async evaluateProtectDecision(context) {
         await this.ensureWarmup();
-        return this.protectEngine.evaluate(context);
+        return this.protectEngine.evaluate({
+            ...context,
+            trace_id: context.trace_id ?? getTraceId() ?? undefined,
+            span_id: context.span_id ?? getSpanId() ?? undefined,
+        });
     }
     async warmConnections() {
         if (this.warmupCompleted) {
@@ -156,21 +160,29 @@ export class Client {
     }
     async runWarmup() {
         try {
-            const response = await bindTraceContext(generateTraceId(), generateSpanId(), async () => await requestJson(`${this.baseUrl}/health`, {
-                method: "GET",
-                headers: {
-                    "X-Trace-ID": getTraceId(),
-                    "X-Span-ID": getSpanId(),
-                },
-            }));
-            this.debugLog("SDK connection warmup completed", { status_code: response.status });
+            const traceId = generateTraceId();
+            const spanId = generateSpanId();
+            await bindTraceContext(traceId, spanId, async () => {
+                const response = await requestJson(`${this.baseUrl}/health`, {
+                    method: "GET",
+                    headers: {
+                        "X-Trace-ID": getTraceId(),
+                        "X-Span-ID": getSpanId(),
+                    },
+                });
+                this.debugLog("SDK connection warmup completed", { status_code: response.status });
+            });
         }
         catch {
             this.debugLog("SDK connection warmup failed");
         }
         try {
-            await this.protectEngine.bootstrap();
-            this.debugLog("SDK protect config bootstrap completed");
+            const traceId = generateTraceId();
+            const spanId = generateSpanId();
+            await bindTraceContext(traceId, spanId, async () => {
+                await this.protectEngine.bootstrap();
+                this.debugLog("SDK protect config bootstrap completed");
+            });
         }
         catch {
             this.debugLog("SDK protect config bootstrap failed");

package/dist/logger.js

@@ -19,6 +19,8 @@ export function getSpanId() {
     return contextStorage.getStore()?.spanId ?? "";
 }
 export function emitLog(params) {
+    const traceId = params.traceId ?? getTraceId();
+    const spanId = params.spanId ?? getSpanId();
     const payload = {
         timestamp: new Date().toISOString(),
         level: params.level,
@@ -29,8 +31,8 @@ export function emitLog(params) {
             process.env.ENVIRONMENT ??
             process.env.ENV ??
             "unknown").toLowerCase(),
-        trace_id: params.traceId ?? getTraceId(),
-        span_id: params.spanId ?? getSpanId(),
+        trace_id: traceId || generateTraceId(),
+        span_id: spanId || generateSpanId(),
         event: sanitizeEvent(params.event),
         message: params.message,
         metadata: sanitizeMetadata(params.metadata ?? {}),

package/dist/protectEngine.d.ts

@@ -6,6 +6,8 @@ export interface ProtectContext {
     feature?: string;
     max_output_tokens?: number;
     input_tokens_estimate?: number;
+    trace_id?: string;
+    span_id?: string;
 }
 export interface ProtectEvaluation {
     decision: ProtectDecision;

package/dist/protectEngine.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { sdkNodeConfig } from "./config.js";
 import { requestJson } from "./httpTransport.js";
-import { bindTraceContext, generateSpanId, generateTraceId, getTraceId } from "./logger.js";
+import { bindTraceContext, generateSpanId, generateTraceId, getSpanId, getTraceId } from "./logger.js";
 export class RHEONICBlockedError extends Error {
     reason;
     trace_id;
@@ -46,111 +46,113 @@ export class ProtectEngine {
     }
     async evaluate(context) {
         const requestId = randomUUID();
-        const traceId = generateTraceId();
-        const nowMs = Date.now();
-        if (this.cooldownUntilMs !== null && nowMs < this.cooldownUntilMs) {
-            this.debugLog?.("Protect preflight blocked locally from cached cooldown", {
-                provider: context.provider,
-                decision: "block",
-                reason: this.cooldownReason ?? "cooldown_active",
-            });
-            return {
-                decision: "block",
-                reason: this.cooldownReason ?? "cooldown_active",
-                trace_id: traceId,
-                request_id: requestId,
-                blocked_until: formatBlockedUntilMs(this.cooldownUntilMs),
-                retry_after_seconds: toRetryAfterSeconds(this.cooldownUntilMs, nowMs),
-            };
-        }
-        const controller = new AbortController();
-        const timeoutMs = this.decisionTimeoutMs > 0 ? this.decisionTimeoutMs : this.fallbackRequestTimeoutMs;
-        const timeout = setTimeout(() => controller.abort(), timeoutMs);
-        timeout.unref?.();
-        const startedAt = Date.now();
-        const spanId = generateSpanId();
-        try {
-            const response = await bindTraceContext(traceId, spanId, async () => await requestJson(`${this.baseUrl}/api/v1/protect/decision`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "X-Project-Ingest-Key": this.ingestKey,
-                    "X-Trace-ID": getTraceId(),
-                    "X-Span-ID": spanId,
-                    "X-Rheonic-Protect-Request-Id": requestId,
-                },
-                body: JSON.stringify(context),
-                signal: controller.signal,
-            }));
-            clearTimeout(timeout);
-            if (!response.ok) {
-                this.debugLog?.("Protect preflight returned non-success status", {
+        const traceId = context.trace_id?.trim() || generateTraceId();
+        const spanId = context.span_id?.trim() || generateSpanId();
+        return bindTraceContext(traceId, spanId, async () => {
+            const nowMs = Date.now();
+            if (this.cooldownUntilMs !== null && nowMs < this.cooldownUntilMs) {
+                this.debugLog?.("Protect preflight blocked locally from cached cooldown", {
                     provider: context.provider,
-                    status_code: response.status,
-                    latency_ms: Date.now() - startedAt,
+                    decision: "block",
+                    reason: this.cooldownReason ?? "cooldown_active",
                 });
-                void this.reportDecisionUnavailable(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
-                return this.fallbackEvaluation(traceId, requestId);
+                return {
+                    decision: "block",
+                    reason: this.cooldownReason ?? "cooldown_active",
+                    trace_id: traceId,
+                    request_id: requestId,
+                    blocked_until: formatBlockedUntilMs(this.cooldownUntilMs),
+                    retry_after_seconds: toRetryAfterSeconds(this.cooldownUntilMs, nowMs),
+                };
             }
-            const parsed = (await response.json());
-            const decision = parseDecision(parsed.decision);
-            const reason = typeof parsed.reason === "string" ? parsed.reason : "ok";
-            const failMode = parseFailMode(parsed.fail_mode);
-            if (failMode) {
-                this.failMode = failMode;
-            }
-            const decisionTimeout = Number(parsed.protect_decision_timeout_ms);
-            if (Number.isFinite(decisionTimeout) && decisionTimeout > 0) {
-                this.decisionTimeoutMs = decisionTimeout;
-            }
-            const blockedUntilMs = parseBlockedUntilMs(parsed.blocked_until);
-            if (blockedUntilMs !== null && blockedUntilMs > Date.now()) {
-                this.cooldownUntilMs = blockedUntilMs;
-                this.cooldownReason = "cooldown_active";
-            }
-            else if (this.cooldownUntilMs !== null && Date.now() >= this.cooldownUntilMs) {
-                this.cooldownUntilMs = null;
-                this.cooldownReason = null;
-            }
-            this.debugLog?.("Protect preflight completed", {
-                provider: context.provider,
-                decision,
-                reason,
-                latency_ms: Date.now() - startedAt,
-                timeout_ms: this.decisionTimeoutMs,
-            });
-            return {
-                decision,
-                reason,
-                trace_id: traceId,
-                request_id: requestId,
-                blocked_until: typeof parsed.blocked_until === "string" ? parsed.blocked_until : undefined,
-                retry_after_seconds: parseRetryAfterSeconds(parsed.retry_after_seconds),
-                snapshot: parseSnapshot(parsed.snapshot),
-                applyClampEnabled: typeof parsed.apply_clamp_enabled === "boolean" ? parsed.apply_clamp_enabled : undefined,
-                clamp: parseClamp(parsed.clamp),
-            };
-        }
-        catch (error) {
-            clearTimeout(timeout);
-            if (isAbortError(error)) {
-                this.debugLog?.("Protect preflight timed out", {
-                    provider: context.provider,
-                    latency_ms: Date.now() - startedAt,
-                    timeout_ms: timeoutMs,
+            const controller = new AbortController();
+            const timeoutMs = this.decisionTimeoutMs > 0 ? this.decisionTimeoutMs : this.fallbackRequestTimeoutMs;
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            timeout.unref?.();
+            const startedAt = Date.now();
+            try {
+                const response = await requestJson(`${this.baseUrl}/api/v1/protect/decision`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "X-Project-Ingest-Key": this.ingestKey,
+                        "X-Trace-ID": getTraceId(),
+                        "X-Span-ID": getSpanId(),
+                        "X-Rheonic-Protect-Request-Id": requestId,
+                    },
+                    body: JSON.stringify(context),
+                    signal: controller.signal,
                 });
-                void this.reportDecisionTimeout(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
-            }
-            else {
-                this.debugLog?.("Protect preflight failed", {
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    this.debugLog?.("Protect preflight returned non-success status", {
+                        provider: context.provider,
+                        status_code: response.status,
+                        latency_ms: Date.now() - startedAt,
+                    });
+                    void this.reportDecisionUnavailable(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
+                    return this.fallbackEvaluation(traceId, requestId);
+                }
+                const parsed = (await response.json());
+                const decision = parseDecision(parsed.decision);
+                const reason = typeof parsed.reason === "string" ? parsed.reason : "ok";
+                const failMode = parseFailMode(parsed.fail_mode);
+                if (failMode) {
+                    this.failMode = failMode;
+                }
+                const decisionTimeout = Number(parsed.protect_decision_timeout_ms);
+                if (Number.isFinite(decisionTimeout) && decisionTimeout > 0) {
+                    this.decisionTimeoutMs = decisionTimeout;
+                }
+                const blockedUntilMs = parseBlockedUntilMs(parsed.blocked_until);
+                if (blockedUntilMs !== null && blockedUntilMs > Date.now()) {
+                    this.cooldownUntilMs = blockedUntilMs;
+                    this.cooldownReason = "cooldown_active";
+                }
+                else if (this.cooldownUntilMs !== null && Date.now() >= this.cooldownUntilMs) {
+                    this.cooldownUntilMs = null;
+                    this.cooldownReason = null;
+                }
+                this.debugLog?.("Protect preflight completed", {
                     provider: context.provider,
+                    decision,
+                    reason,
                     latency_ms: Date.now() - startedAt,
-                    error_type: extractErrorType(error),
+                    timeout_ms: this.decisionTimeoutMs,
                 });
-                void this.reportDecisionUnavailable(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
+                return {
+                    decision,
+                    reason,
+                    trace_id: traceId,
+                    request_id: requestId,
+                    blocked_until: typeof parsed.blocked_until === "string" ? parsed.blocked_until : undefined,
+                    retry_after_seconds: parseRetryAfterSeconds(parsed.retry_after_seconds),
+                    snapshot: parseSnapshot(parsed.snapshot),
+                    applyClampEnabled: typeof parsed.apply_clamp_enabled === "boolean" ? parsed.apply_clamp_enabled : undefined,
+                    clamp: parseClamp(parsed.clamp),
+                };
             }
-            return this.fallbackEvaluation(traceId, requestId);
-        }
+            catch (error) {
+                clearTimeout(timeout);
+                if (isAbortError(error)) {
+                    this.debugLog?.("Protect preflight timed out", {
+                        provider: context.provider,
+                        latency_ms: Date.now() - startedAt,
+                        timeout_ms: timeoutMs,
+                    });
+                    void this.reportDecisionTimeout(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
+                }
+                else {
+                    this.debugLog?.("Protect preflight failed", {
+                        provider: context.provider,
+                        latency_ms: Date.now() - startedAt,
+                        error_type: extractErrorType(error),
+                    });
+                    void this.reportDecisionUnavailable(context.provider, typeof context.model === "string" ? context.model : undefined, requestId, traceId);
+                }
+                return this.fallbackEvaluation(traceId, requestId);
+            }
+        });
     }
     fallbackEvaluation(traceId, requestId) {
         return {

package/dist/providers/anthropicAdapter.js

@@ -1,4 +1,5 @@
 import { buildEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
 import { validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
@@ -13,82 +14,88 @@ export function instrumentAnthropic(anthropicClient, options) {
     }
     const originalCreate = targetCreate.bind(anthropicClient.messages);
     anthropicClient.messages.create = async (...args) => {
-        const startedAt = Date.now();
-        const requestPayload = extractRequestPayload(args);
-        const requestedModel = extractRequestedModel(args);
-        validateProviderModel("anthropic", requestedModel);
-        let estimatedInputTokens = null;
-        const tokenEstimateStartedAt = Date.now();
-        estimatedInputTokens = requestPayload
-            ? (estimatorOverrideForTests
-                ? estimatorOverrideForTests(requestPayload)
-                : estimateInputTokensFromRequest(requestPayload))
-            : null;
-        options.client.debugLog("Protect token estimation completed", {
-            provider: "anthropic",
-            model: requestedModel,
-            latency_ms: Date.now() - tokenEstimateStartedAt,
-            estimated_input_tokens: estimatedInputTokens ?? undefined,
-        });
-        const protectPayload = {
-            provider: "anthropic",
-            model: requestedModel,
-            environment: options.environment ?? options.client.environment,
-            feature: options.feature,
-            max_output_tokens: extractMaxOutputTokens(args),
-        };
-        if (typeof estimatedInputTokens === "number") {
-            protectPayload.input_tokens_estimate = estimatedInputTokens;
-        }
-        const protectDecision = await options.client.evaluateProtectDecision(protectPayload);
-        if (protectDecision.decision === "block") {
-            throw new RHEONICBlockedError(protectDecision);
-        }
-        const callArgs = maybeApplyAnthropicClamp(args, protectDecision);
-        markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
-        try {
-            const response = await originalCreate(...callArgs);
-            await options.client.captureEventAndFlush(buildEvent({
+        const traceId = generateTraceId();
+        const spanId = generateSpanId();
+        return bindTraceContext(traceId, spanId, async () => {
+            const startedAt = Date.now();
+            const requestPayload = extractRequestPayload(args);
+            const requestedModel = extractRequestedModel(args);
+            validateProviderModel("anthropic", requestedModel);
+            let estimatedInputTokens = null;
+            const tokenEstimateStartedAt = Date.now();
+            estimatedInputTokens = requestPayload
+                ? (estimatorOverrideForTests
+                    ? estimatorOverrideForTests(requestPayload)
+                    : estimateInputTokensFromRequest(requestPayload))
+                : null;
+            options.client.debugLog("Protect token estimation completed", {
                 provider: "anthropic",
-                model: extractResponseModel(response) ?? requestedModel,
-                environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    total_tokens: extractTotalTokens(response),
-                    http_status: 200,
-                },
-            }));
-            return response;
-        }
-        catch (error) {
-            await options.client.captureEventAndFlush(buildEvent({
+                model: requestedModel,
+                latency_ms: Date.now() - tokenEstimateStartedAt,
+                estimated_input_tokens: estimatedInputTokens ?? undefined,
+            });
+            const protectPayload = {
                 provider: "anthropic",
                 model: requestedModel,
                 environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    error_type: extractErrorType(error),
-                    http_status: extractHttpStatus(error),
-                },
-            }));
-            throw error;
-        }
+                feature: options.feature,
+                max_output_tokens: extractMaxOutputTokens(args),
+                trace_id: traceId,
+                span_id: spanId,
+            };
+            if (typeof estimatedInputTokens === "number") {
+                protectPayload.input_tokens_estimate = estimatedInputTokens;
+            }
+            const protectDecision = await options.client.evaluateProtectDecision(protectPayload);
+            if (protectDecision.decision === "block") {
+                throw new RHEONICBlockedError(protectDecision);
+            }
+            const callArgs = maybeApplyAnthropicClamp(args, protectDecision);
+            markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
+            try {
+                const response = await originalCreate(...callArgs);
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "anthropic",
+                    model: extractResponseModel(response) ?? requestedModel,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        total_tokens: extractTotalTokens(response),
+                        http_status: 200,
+                    },
+                }));
+                return response;
+            }
+            catch (error) {
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "anthropic",
+                    model: requestedModel,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        error_type: extractErrorType(error),
+                        http_status: extractHttpStatus(error),
+                    },
+                }));
+                throw error;
+            }
+        });
     };
     return anthropicClient;
 }

package/dist/providers/googleAdapter.js

@@ -1,4 +1,5 @@
 import { buildEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
 import { validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
@@ -13,82 +14,88 @@ export function instrumentGoogle(googleModel, options) {
     }
     const originalGenerate = targetGenerate.bind(googleModel);
     googleModel.generateContent = async (...args) => {
-        const startedAt = Date.now();
-        const requestedModel = extractRequestedModel(googleModel);
-        validateProviderModel("google", requestedModel);
-        const requestPayload = extractRequestPayload(args, requestedModel);
-        let estimatedInputTokens = null;
-        const tokenEstimateStartedAt = Date.now();
-        estimatedInputTokens = requestPayload
-            ? (estimatorOverrideForTests
-                ? estimatorOverrideForTests(requestPayload)
-                : estimateInputTokensFromRequest(requestPayload))
-            : null;
-        options.client.debugLog("Protect token estimation completed", {
-            provider: "google",
-            model: requestedModel,
-            latency_ms: Date.now() - tokenEstimateStartedAt,
-            estimated_input_tokens: estimatedInputTokens ?? undefined,
-        });
-        const protectPayload = {
-            provider: "google",
-            model: requestedModel,
-            environment: options.environment ?? options.client.environment,
-            feature: options.feature,
-            max_output_tokens: extractMaxOutputTokens(args),
-        };
-        if (typeof estimatedInputTokens === "number") {
-            protectPayload.input_tokens_estimate = estimatedInputTokens;
-        }
-        const protectDecision = await options.client.evaluateProtectDecision(protectPayload);
-        if (protectDecision.decision === "block") {
-            throw new RHEONICBlockedError(protectDecision);
-        }
-        const callArgs = maybeApplyGoogleClamp(args, protectDecision);
-        markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
-        try {
-            const response = await originalGenerate(...callArgs);
-            await options.client.captureEventAndFlush(buildEvent({
+        const traceId = generateTraceId();
+        const spanId = generateSpanId();
+        return bindTraceContext(traceId, spanId, async () => {
+            const startedAt = Date.now();
+            const requestedModel = extractRequestedModel(googleModel);
+            validateProviderModel("google", requestedModel);
+            const requestPayload = extractRequestPayload(args, requestedModel);
+            let estimatedInputTokens = null;
+            const tokenEstimateStartedAt = Date.now();
+            estimatedInputTokens = requestPayload
+                ? (estimatorOverrideForTests
+                    ? estimatorOverrideForTests(requestPayload)
+                    : estimateInputTokensFromRequest(requestPayload))
+                : null;
+            options.client.debugLog("Protect token estimation completed", {
                 provider: "google",
                 model: requestedModel,
-                environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    total_tokens: extractTotalTokens(response),
-                    http_status: 200,
-                },
-            }));
-            return response;
-        }
-        catch (error) {
-            await options.client.captureEventAndFlush(buildEvent({
+                latency_ms: Date.now() - tokenEstimateStartedAt,
+                estimated_input_tokens: estimatedInputTokens ?? undefined,
+            });
+            const protectPayload = {
                 provider: "google",
                 model: requestedModel,
                 environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    error_type: extractErrorType(error),
-                    http_status: extractHttpStatus(error),
-                },
-            }));
-            throw error;
-        }
+                feature: options.feature,
+                max_output_tokens: extractMaxOutputTokens(args),
+                trace_id: traceId,
+                span_id: spanId,
+            };
+            if (typeof estimatedInputTokens === "number") {
+                protectPayload.input_tokens_estimate = estimatedInputTokens;
+            }
+            const protectDecision = await options.client.evaluateProtectDecision(protectPayload);
+            if (protectDecision.decision === "block") {
+                throw new RHEONICBlockedError(protectDecision);
+            }
+            const callArgs = maybeApplyGoogleClamp(args, protectDecision);
+            markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
+            try {
+                const response = await originalGenerate(...callArgs);
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "google",
+                    model: requestedModel,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        total_tokens: extractTotalTokens(response),
+                        http_status: 200,
+                    },
+                }));
+                return response;
+            }
+            catch (error) {
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "google",
+                    model: requestedModel,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        input_tokens_estimate: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        error_type: extractErrorType(error),
+                        http_status: extractHttpStatus(error),
+                    },
+                }));
+                throw error;
+            }
+        });
     };
     return googleModel;
 }

package/dist/providers/openaiAdapter.js

@@ -1,4 +1,5 @@
 import { buildEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
 import { validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
@@ -13,81 +14,87 @@ export function instrumentOpenAI(openaiClient, options) {
     }
     const originalCreate = targetCreate.bind(openaiClient.chat.completions);
     openaiClient.chat.completions.create = async (...args) => {
-        const startedAt = Date.now();
-        const model = extractRequestedModel(args);
-        validateProviderModel("openai", model);
-        const requestPayload = extractRequestPayload(args);
-        const tokenEstimateStartedAt = Date.now();
-        const estimatedInputTokens = requestPayload
-            ? (estimatorOverrideForTests
-                ? estimatorOverrideForTests(requestPayload)
-                : estimateInputTokensFromRequest(requestPayload))
-            : null;
-        options.client.debugLog("Protect token estimation completed", {
-            provider: "openai",
-            model,
-            latency_ms: Date.now() - tokenEstimateStartedAt,
-            estimated_input_tokens: estimatedInputTokens ?? undefined,
-        });
-        const protectPayload = {
-            provider: "openai",
-            model,
-            environment: options.environment ?? options.client.environment,
-            feature: options.feature,
-            max_output_tokens: extractMaxOutputTokens(args),
-        };
-        if (typeof estimatedInputTokens === "number") {
-            protectPayload.input_tokens_estimate = estimatedInputTokens;
-        }
-        const protectDecision = await options.client.evaluateProtectDecision({
-            ...protectPayload,
-        });
-        if (protectDecision.decision === "block") {
-            throw new RHEONICBlockedError(protectDecision);
-        }
-        const callArgs = maybeApplyOpenAIClamp(args, protectDecision);
-        markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
-        try {
-            const response = await originalCreate(...callArgs);
-            await options.client.captureEventAndFlush(buildEvent({
+        const traceId = generateTraceId();
+        const spanId = generateSpanId();
+        return bindTraceContext(traceId, spanId, async () => {
+            const startedAt = Date.now();
+            const model = extractRequestedModel(args);
+            validateProviderModel("openai", model);
+            const requestPayload = extractRequestPayload(args);
+            const tokenEstimateStartedAt = Date.now();
+            const estimatedInputTokens = requestPayload
+                ? (estimatorOverrideForTests
+                    ? estimatorOverrideForTests(requestPayload)
+                    : estimateInputTokensFromRequest(requestPayload))
+                : null;
+            options.client.debugLog("Protect token estimation completed", {
                 provider: "openai",
-                model: extractResponseModel(response) ?? model,
-                environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    total_tokens: extractTotalTokens(response),
-                    http_status: 200,
-                },
-            }));
-            return response;
-        }
-        catch (error) {
-            await options.client.captureEventAndFlush(buildEvent({
+                model,
+                latency_ms: Date.now() - tokenEstimateStartedAt,
+                estimated_input_tokens: estimatedInputTokens ?? undefined,
+            });
+            const protectPayload = {
                 provider: "openai",
                 model,
                 environment: options.environment ?? options.client.environment,
-                request: {
-                    endpoint: options.endpoint,
-                    feature: options.feature,
-                    token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
-                    protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
-                    protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
-                },
-                response: {
-                    latency_ms: Date.now() - startedAt,
-                    error_type: extractErrorType(error),
-                    http_status: extractHttpStatus(error),
-                },
-            }));
-            throw error;
-        }
+                feature: options.feature,
+                max_output_tokens: extractMaxOutputTokens(args),
+                trace_id: traceId,
+                span_id: spanId,
+            };
+            if (typeof estimatedInputTokens === "number") {
+                protectPayload.input_tokens_estimate = estimatedInputTokens;
+            }
+            const protectDecision = await options.client.evaluateProtectDecision({
+                ...protectPayload,
+            });
+            if (protectDecision.decision === "block") {
+                throw new RHEONICBlockedError(protectDecision);
+            }
+            const callArgs = maybeApplyOpenAIClamp(args, protectDecision);
+            markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
+            try {
+                const response = await originalCreate(...callArgs);
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "openai",
+                    model: extractResponseModel(response) ?? model,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        total_tokens: extractTotalTokens(response),
+                        http_status: 200,
+                    },
+                }));
+                return response;
+            }
+            catch (error) {
+                await options.client.captureEventAndFlush(buildEvent({
+                    provider: "openai",
+                    model,
+                    environment: options.environment ?? options.client.environment,
+                    request: {
+                        endpoint: options.endpoint,
+                        feature: options.feature,
+                        token_explosion_tokens: typeof estimatedInputTokens === "number" ? estimatedInputTokens : undefined,
+                        protect_decision: protectDecision.decision !== "allow" ? protectDecision.decision : undefined,
+                        protect_reason: protectDecision.decision !== "allow" ? protectDecision.reason : undefined,
+                    },
+                    response: {
+                        latency_ms: Date.now() - startedAt,
+                        error_type: extractErrorType(error),
+                        http_status: extractHttpStatus(error),
+                    },
+                }));
+                throw error;
+            }
+        });
     };
     return openaiClient;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rheonic/sdk",
-  "version": "0.1.0-beta.8",
+  "version": "0.1.0-beta.9",
   "description": "Node.js SDK for Rheonic observability and protect preflight enforcement.",
   "author": "Rheonic <founder@rheonic.dev>",
   "license": "MIT",