@rheonic/sdk 0.1.0-beta.13 → 0.1.0-beta.15

package/dist/client.d.ts

@@ -1,8 +1,8 @@
+import { type BuildEventInput, type EventPayload } from "./eventBuilder.js";
 import { type ProtectContext, type ProtectEvaluation, type ProtectFailMode } from "./protectEngine.js";
 import { type AnthropicInstrumentationOptions } from "./providers/anthropicAdapter.js";
 import { type GoogleInstrumentationOptions } from "./providers/googleAdapter.js";
 import { type OpenAIInstrumentationOptions } from "./providers/openaiAdapter.js";
-import type { EventPayload } from "./eventBuilder.js";
 export type OverflowPolicy = "drop_oldest" | "drop_newest";
 export interface ClientStats {
     queued: number;
@@ -41,8 +41,8 @@ export declare class Client {
     private warmupPromise;
     private warmupCompleted;
     constructor(config: ClientConfig);
-    captureEvent(event: EventPayload): Promise<void>;
-    captureEventAndFlush(event: EventPayload): Promise<void>;
+    captureEvent(event: EventPayload | BuildEventInput): Promise<void>;
+    captureEventAndFlush(event: EventPayload | BuildEventInput): Promise<void>;
     getStats(): ClientStats;
     flush(): Promise<void>;
     evaluateProtectDecision(context: ProtectContext): Promise<ProtectEvaluation>;

package/dist/client.js

@@ -1,13 +1,66 @@
 import { sdkNodeConfig } from "./config.js";
+import { normalizeEventPayload } from "./eventBuilder.js";
 import { requestJson } from "./httpTransport.js";
 import { bindTraceContext, emitLog, generateSpanId, generateTraceId, getSpanId, getTraceId } from "./logger.js";
 import { ProtectEngine } from "./protectEngine.js";
+import { RHEONICValidationError } from "./providerModelValidation.js";
 import { instrumentAnthropic as instrumentAnthropicProvider } from "./providers/anthropicAdapter.js";
 import { instrumentGoogle as instrumentGoogleProvider } from "./providers/googleAdapter.js";
 import { instrumentOpenAI as instrumentOpenAIProvider } from "./providers/openaiAdapter.js";
 import { prewarmTokenEstimator } from "./tokenEstimator.js";
 const CLIENT_REGISTRY = new Set();
 let EXIT_HOOKS_REGISTERED = false;
+const CLIENT_CONFIG_KEYS = new Set([
+    "baseUrl",
+    "ingestKey",
+    "environment",
+    "flushIntervalMs",
+    "maxQueueSize",
+    "overflowPolicy",
+    "requestTimeoutMs",
+    "protectFailMode",
+    "debug",
+]);
+function failClientValidation(message) {
+    throw new RHEONICValidationError(message, "client", "", []);
+}
+function validateClientConfig(config) {
+    if (!config || typeof config !== "object" || Array.isArray(config)) {
+        failClientValidation("RHEONIC: createClient config must be an object.");
+    }
+    for (const key of Object.keys(config)) {
+        if (!CLIENT_CONFIG_KEYS.has(key)) {
+            failClientValidation(`RHEONIC: unexpected client config property: ${key}`);
+        }
+    }
+    if (typeof config.ingestKey !== "string" || config.ingestKey.trim().length === 0) {
+        failClientValidation("RHEONIC: ingestKey must be a non-empty string.");
+    }
+    if (config.baseUrl !== undefined && (typeof config.baseUrl !== "string" || config.baseUrl.trim().length === 0)) {
+        failClientValidation("RHEONIC: baseUrl must be a non-empty string.");
+    }
+    if (config.environment !== undefined && (typeof config.environment !== "string" || config.environment.trim().length === 0)) {
+        failClientValidation("RHEONIC: environment must be a non-empty string.");
+    }
+    if (config.flushIntervalMs !== undefined && (!Number.isFinite(config.flushIntervalMs) || config.flushIntervalMs <= 0)) {
+        failClientValidation("RHEONIC: flushIntervalMs must be a positive number.");
+    }
+    if (config.maxQueueSize !== undefined && (!Number.isInteger(config.maxQueueSize) || config.maxQueueSize < 1)) {
+        failClientValidation("RHEONIC: maxQueueSize must be a positive integer.");
+    }
+    if (config.overflowPolicy !== undefined && !["drop_oldest", "drop_newest"].includes(config.overflowPolicy)) {
+        failClientValidation("RHEONIC: overflowPolicy must be 'drop_oldest' or 'drop_newest'.");
+    }
+    if (config.requestTimeoutMs !== undefined && (!Number.isFinite(config.requestTimeoutMs) || config.requestTimeoutMs <= 0)) {
+        failClientValidation("RHEONIC: requestTimeoutMs must be a positive number.");
+    }
+    if (config.protectFailMode !== undefined && !["open", "closed"].includes(config.protectFailMode)) {
+        failClientValidation("RHEONIC: protectFailMode must be 'open' or 'closed'.");
+    }
+    if (config.debug !== undefined && typeof config.debug !== "boolean") {
+        failClientValidation("RHEONIC: debug must be a boolean.");
+    }
+}
 export class Client {
     baseUrl;
     ingestKey;
@@ -28,6 +81,7 @@ export class Client {
     warmupPromise = null;
     warmupCompleted = false;
     constructor(config) {
+        validateClientConfig(config);
         this.baseUrl = config.baseUrl ?? process.env.RHEONIC_BASE_URL ?? sdkNodeConfig.defaultBaseUrl;
         this.ingestKey = config.ingestKey;
         this.environment =
@@ -75,28 +129,24 @@ export class Client {
         });
     }
     async captureEvent(event) {
-        try {
-            if (this.queue.length >= this.maxQueueSize) {
-                if (this.overflowPolicy === "drop_oldest") {
-                    this.queue.shift();
-                    this.dropped += 1;
-                }
-                else {
-                    this.dropped += 1;
-                    return;
-                }
+        const normalizedEvent = normalizeEventPayload(event);
+        if (this.queue.length >= this.maxQueueSize) {
+            if (this.overflowPolicy === "drop_oldest") {
+                this.queue.shift();
+                this.dropped += 1;
             }
-            if (this.isClosed) {
+            else {
+                this.dropped += 1;
                 return;
             }
-            this.queue.push({
-                ...event,
-                environment: event.environment || this.environment,
-            });
         }
-        catch {
+        if (this.isClosed) {
             return;
         }
+        this.queue.push({
+            ...normalizedEvent,
+            environment: normalizedEvent.environment || this.environment,
+        });
     }
     async captureEventAndFlush(event) {
         await this.captureEvent(event);

package/dist/eventBuilder.d.ts

@@ -12,6 +12,7 @@ export interface EventRequest {
 export interface EventResponse {
     http_status?: number;
     latency_ms?: number;
+    output_tokens?: number;
     total_tokens?: number;
     error_type?: string;
     error_message?: string;
@@ -22,18 +23,32 @@ export interface EventPayload {
     requested_model: string | null;
     resolved_model: string | null;
     environment: string;
+    status?: string;
     request: EventRequest;
     response: EventResponse;
 }
 export interface BuildEventInput {
+    provider: string;
+    model?: string | null;
+    environment?: string;
+    ts?: string;
+    status?: string;
+    request?: EventRequest;
+    response?: EventResponse;
+}
+export interface InternalEventInput {
     provider: string;
     requested_model?: string | null;
     resolved_model?: string | null;
     environment?: string;
     ts?: string;
+    status?: string;
     request?: EventRequest;
     response?: EventResponse;
 }
+export declare function validateEventPayload(input: EventPayload): EventPayload;
+export declare function normalizeEventPayload(input: EventPayload | BuildEventInput): EventPayload;
+export declare function buildInternalEvent(input: InternalEventInput): EventPayload;
 export declare function buildEvent(input: BuildEventInput): EventPayload;
 export declare class EventBuilder {
     build(payload: BuildEventInput): EventPayload;

package/dist/eventBuilder.js

@@ -1,14 +1,174 @@
-export function buildEvent(input) {
+import { RHEONICValidationError } from "./providerModelValidation.js";
+const PUBLIC_EVENT_KEYS = new Set(["provider", "model", "environment", "ts", "status", "request", "response"]);
+const INTERNAL_EVENT_KEYS = new Set([
+    "provider",
+    "requested_model",
+    "resolved_model",
+    "environment",
+    "ts",
+    "status",
+    "request",
+    "response",
+]);
+const REQUEST_KEYS = new Set([
+    "endpoint",
+    "feature",
+    "request_fingerprint",
+    "input_tokens",
+    "input_tokens_estimate",
+    "token_explosion_tokens",
+    "max_output_tokens",
+    "protect_decision",
+    "protect_reason",
+]);
+const RESPONSE_KEYS = new Set(["http_status", "latency_ms", "output_tokens", "total_tokens", "error_type", "error_message"]);
+function failValidation(message) {
+    throw new RHEONICValidationError(message, "event", "", []);
+}
+function assertPlainObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        failValidation(`RHEONIC: ${label} must be an object.`);
+    }
+    return value;
+}
+function assertNoExtraKeys(record, allowedKeys, label) {
+    for (const key of Object.keys(record)) {
+        if (!allowedKeys.has(key)) {
+            failValidation(`RHEONIC: unexpected ${label} property: ${key}`);
+        }
+    }
+}
+function assertOptionalString(value, label) {
+    if (value !== undefined && value !== null && typeof value !== "string") {
+        failValidation(`RHEONIC: ${label} must be a string.`);
+    }
+}
+function assertOptionalNumber(value, label) {
+    if (value !== undefined && value !== null && typeof value !== "number") {
+        failValidation(`RHEONIC: ${label} must be a number.`);
+    }
+}
+function validateRequestShape(request) {
+    const record = assertPlainObject(request, "event.request");
+    assertNoExtraKeys(record, REQUEST_KEYS, "event.request");
+    assertOptionalString(record.endpoint, "event.request.endpoint");
+    assertOptionalString(record.feature, "event.request.feature");
+    assertOptionalString(record.request_fingerprint, "event.request.request_fingerprint");
+    assertOptionalNumber(record.input_tokens, "event.request.input_tokens");
+    assertOptionalNumber(record.input_tokens_estimate, "event.request.input_tokens_estimate");
+    assertOptionalNumber(record.token_explosion_tokens, "event.request.token_explosion_tokens");
+    assertOptionalNumber(record.max_output_tokens, "event.request.max_output_tokens");
+    assertOptionalString(record.protect_decision, "event.request.protect_decision");
+    assertOptionalString(record.protect_reason, "event.request.protect_reason");
+    return record;
+}
+function validateResponseShape(response) {
+    const record = assertPlainObject(response, "event.response");
+    assertNoExtraKeys(record, RESPONSE_KEYS, "event.response");
+    assertOptionalNumber(record.http_status, "event.response.http_status");
+    assertOptionalNumber(record.latency_ms, "event.response.latency_ms");
+    assertOptionalNumber(record.output_tokens, "event.response.output_tokens");
+    assertOptionalNumber(record.total_tokens, "event.response.total_tokens");
+    assertOptionalString(record.error_type, "event.response.error_type");
+    assertOptionalString(record.error_message, "event.response.error_message");
+    return record;
+}
+function validateBuildEventInput(input) {
+    const record = assertPlainObject(input, "event");
+    assertNoExtraKeys(record, PUBLIC_EVENT_KEYS, "event");
+    if (typeof record.provider !== "string" || record.provider.trim().length === 0) {
+        failValidation("RHEONIC: event.provider must be a non-empty string.");
+    }
+    assertOptionalString(record.model, "event.model");
+    assertOptionalString(record.environment, "event.environment");
+    assertOptionalString(record.ts, "event.ts");
+    assertOptionalString(record.status, "event.status");
+    if (record.request !== undefined) {
+        validateRequestShape(record.request);
+    }
+    if (record.response !== undefined) {
+        validateResponseShape(record.response);
+    }
+    return input;
+}
+function validateInternalEventInput(input) {
+    const record = assertPlainObject(input, "event");
+    assertNoExtraKeys(record, INTERNAL_EVENT_KEYS, "event");
+    if (typeof record.provider !== "string" || record.provider.trim().length === 0) {
+        failValidation("RHEONIC: event.provider must be a non-empty string.");
+    }
+    assertOptionalString(record.requested_model, "event.requested_model");
+    assertOptionalString(record.resolved_model, "event.resolved_model");
+    assertOptionalString(record.environment, "event.environment");
+    assertOptionalString(record.ts, "event.ts");
+    assertOptionalString(record.status, "event.status");
+    if (record.request !== undefined) {
+        validateRequestShape(record.request);
+    }
+    if (record.response !== undefined) {
+        validateResponseShape(record.response);
+    }
+    return input;
+}
+export function validateEventPayload(input) {
+    const record = assertPlainObject(input, "event");
+    assertNoExtraKeys(record, INTERNAL_EVENT_KEYS, "event");
+    for (const requiredKey of ["ts", "provider", "requested_model", "resolved_model", "environment", "request", "response"]) {
+        if (!Object.prototype.hasOwnProperty.call(record, requiredKey)) {
+            failValidation(`RHEONIC: event.${requiredKey} is required.`);
+        }
+    }
+    if (typeof record.ts !== "string" || record.ts.trim().length === 0) {
+        failValidation("RHEONIC: event.ts must be a non-empty string.");
+    }
+    if (typeof record.provider !== "string" || record.provider.trim().length === 0) {
+        failValidation("RHEONIC: event.provider must be a non-empty string.");
+    }
+    if (typeof record.environment !== "string" || record.environment.trim().length === 0) {
+        failValidation("RHEONIC: event.environment must be a non-empty string.");
+    }
+    assertOptionalString(record.requested_model, "event.requested_model");
+    assertOptionalString(record.resolved_model, "event.resolved_model");
+    assertOptionalString(record.status, "event.status");
+    validateRequestShape(record.request);
+    validateResponseShape(record.response);
+    return input;
+}
+export function normalizeEventPayload(input) {
+    const record = assertPlainObject(input, "event");
+    const isInternal = Object.prototype.hasOwnProperty.call(record, "requested_model")
+        || Object.prototype.hasOwnProperty.call(record, "resolved_model");
+    if (isInternal) {
+        return validateEventPayload(input);
+    }
+    return buildEvent(input);
+}
+export function buildInternalEvent(input) {
+    validateInternalEventInput(input);
     return {
         ts: input.ts ?? new Date().toISOString(),
         provider: input.provider,
         requested_model: input.requested_model ?? null,
         resolved_model: input.resolved_model ?? null,
         environment: input.environment ?? "dev",
+        ...(input.status !== undefined ? { status: input.status } : {}),
         request: input.request ?? {},
         response: input.response ?? {},
     };
 }
+export function buildEvent(input) {
+    validateBuildEventInput(input);
+    return buildInternalEvent({
+        provider: input.provider,
+        requested_model: input.model ?? null,
+        resolved_model: null,
+        environment: input.environment,
+        ts: input.ts,
+        status: input.status,
+        request: input.request,
+        response: input.response,
+    });
+}
 export class EventBuilder {
     build(payload) {
         return buildEvent(payload);

package/dist/protectEngine.d.ts

@@ -3,6 +3,7 @@ export type ProtectFailMode = "open" | "closed";
 export interface ProtectContext {
     provider: string;
     requested_model?: string | null;
+    environment?: string;
     feature?: string;
     max_output_tokens?: number;
     input_tokens_estimate?: number;

package/dist/protectEngine.js

@@ -71,6 +71,7 @@ export class ProtectEngine {
             timeout.unref?.();
             const startedAt = Date.now();
             try {
+                const requestBody = sanitizeProtectContext(context);
                 const response = await requestJson(`${this.baseUrl}/api/v1/protect/decision`, {
                     method: "POST",
                     headers: {
@@ -80,7 +81,7 @@ export class ProtectEngine {
                         "X-Span-ID": getSpanId(),
                         "X-Rheonic-Protect-Request-Id": requestId,
                     },
-                    body: JSON.stringify(context),
+                    body: JSON.stringify(requestBody),
                     signal: controller.signal,
                 });
                 clearTimeout(timeout);
@@ -236,6 +237,25 @@ export class ProtectEngine {
         }
     }
 }
+function sanitizeProtectContext(context) {
+    const payload = { provider: context.provider };
+    if (context.requested_model != null) {
+        payload.requested_model = context.requested_model;
+    }
+    if (context.environment != null) {
+        payload.environment = context.environment;
+    }
+    if (context.feature != null) {
+        payload.feature = context.feature;
+    }
+    if (context.max_output_tokens != null) {
+        payload.max_output_tokens = context.max_output_tokens;
+    }
+    if (context.input_tokens_estimate != null) {
+        payload.input_tokens_estimate = context.input_tokens_estimate;
+    }
+    return payload;
+}
 function parseClamp(value) {
     if (!value || typeof value !== "object") {
         return undefined;

package/dist/providers/anthropicAdapter.js

@@ -1,7 +1,7 @@
-import { buildEvent } from "../eventBuilder.js";
-import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
+import { buildInternalEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId, getSpanId, getTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
-import { validateProviderModel } from "../providerModelValidation.js";
+import { RHEONICValidationError, validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
 let estimatorOverrideForTests = null;
 export function __setInputTokenEstimatorForTests(estimator) {
@@ -10,12 +10,12 @@ export function __setInputTokenEstimatorForTests(estimator) {
 export function instrumentAnthropic(anthropicClient, options) {
     const targetCreate = anthropicClient?.messages?.create;
     if (typeof targetCreate !== "function") {
-        return anthropicClient;
+        throw new RHEONICValidationError("RHEONIC: instrumentAnthropic requires a client exposing messages.create.", "anthropic", "", ["anthropic"]);
     }
     const originalCreate = targetCreate.bind(anthropicClient.messages);
     anthropicClient.messages.create = async (...args) => {
-        const traceId = generateTraceId();
-        const spanId = generateSpanId();
+        const traceId = getTraceId() || generateTraceId();
+        const spanId = getSpanId() || generateSpanId();
         return bindTraceContext(traceId, spanId, async () => {
             const startedAt = Date.now();
             const requestPayload = extractRequestPayload(args);
@@ -54,10 +54,9 @@ export function instrumentAnthropic(anthropicClient, options) {
             markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
             try {
                 const response = await originalCreate(...callArgs);
-                await options.client.captureEventAndFlush(buildEvent({
+                const event = buildInternalEvent({
                     provider: "anthropic",
                     requested_model: requestedModel,
-                    resolved_model: extractResponseModel(response),
                     environment: options.environment ?? options.client.environment,
                     request: {
                         endpoint: options.endpoint,
@@ -72,14 +71,15 @@ export function instrumentAnthropic(anthropicClient, options) {
                         total_tokens: extractTotalTokens(response),
                         http_status: 200,
                     },
-                }));
+                });
+                event.resolved_model = extractResponseModel(response);
+                await options.client.captureEventAndFlush(event);
                 return response;
             }
             catch (error) {
-                await options.client.captureEventAndFlush(buildEvent({
+                await options.client.captureEventAndFlush(buildInternalEvent({
                     provider: "anthropic",
                     requested_model: requestedModel,
-                    resolved_model: null,
                     environment: options.environment ?? options.client.environment,
                     request: {
                         endpoint: options.endpoint,

package/dist/providers/googleAdapter.js

@@ -1,7 +1,7 @@
-import { buildEvent } from "../eventBuilder.js";
-import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
+import { buildInternalEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId, getSpanId, getTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
-import { validateProviderModel } from "../providerModelValidation.js";
+import { RHEONICValidationError, validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
 let estimatorOverrideForTests = null;
 export function __setInputTokenEstimatorForTests(estimator) {
@@ -10,12 +10,12 @@ export function __setInputTokenEstimatorForTests(estimator) {
 export function instrumentGoogle(googleModel, options) {
     const targetGenerate = resolveGenerateTarget(googleModel);
     if (!targetGenerate) {
-        return googleModel;
+        throw new RHEONICValidationError("RHEONIC: instrumentGoogle requires a client exposing generateContent or models.generateContent.", "google", "", ["google"]);
     }
     const originalGenerate = targetGenerate.fn.bind(targetGenerate.owner);
     targetGenerate.owner[targetGenerate.key] = async (...args) => {
-        const traceId = generateTraceId();
-        const spanId = generateSpanId();
+        const traceId = getTraceId() || generateTraceId();
+        const spanId = getSpanId() || generateSpanId();
         return bindTraceContext(traceId, spanId, async () => {
             const startedAt = Date.now();
             const requestedModel = extractRequestedModel(googleModel, args);
@@ -54,10 +54,9 @@ export function instrumentGoogle(googleModel, options) {
             markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
             try {
                 const response = await originalGenerate(...callArgs);
-                await options.client.captureEventAndFlush(buildEvent({
+                const event = buildInternalEvent({
                     provider: "google",
                     requested_model: requestedModel,
-                    resolved_model: extractResponseModel(response),
                     environment: options.environment ?? options.client.environment,
                     request: {
                         endpoint: options.endpoint,
@@ -72,14 +71,15 @@ export function instrumentGoogle(googleModel, options) {
                         total_tokens: extractTotalTokens(response),
                         http_status: 200,
                     },
-                }));
+                });
+                event.resolved_model = extractResponseModel(response);
+                await options.client.captureEventAndFlush(event);
                 return response;
             }
             catch (error) {
-                await options.client.captureEventAndFlush(buildEvent({
+                await options.client.captureEventAndFlush(buildInternalEvent({
                     provider: "google",
                     requested_model: requestedModel,
-                    resolved_model: null,
                     environment: options.environment ?? options.client.environment,
                     request: {
                         endpoint: options.endpoint,

package/dist/providers/openaiAdapter.js

@@ -1,7 +1,7 @@
-import { buildEvent } from "../eventBuilder.js";
-import { bindTraceContext, generateSpanId, generateTraceId } from "../logger.js";
+import { buildInternalEvent } from "../eventBuilder.js";
+import { bindTraceContext, generateSpanId, generateTraceId, getSpanId, getTraceId } from "../logger.js";
 import { RHEONICBlockedError } from "../protectEngine.js";
-import { validateProviderModel } from "../providerModelValidation.js";
+import { RHEONICValidationError, validateProviderModel } from "../providerModelValidation.js";
 import { estimateInputTokensFromRequest } from "../tokenEstimator.js";
 let estimatorOverrideForTests = null;
 export function __setInputTokenEstimatorForTests(estimator) {
@@ -10,12 +10,12 @@ export function __setInputTokenEstimatorForTests(estimator) {
 export function instrumentOpenAI(openaiClient, options) {
     const targetCreate = openaiClient?.chat?.completions?.create;
     if (typeof targetCreate !== "function") {
-        return openaiClient;
+        throw new RHEONICValidationError("RHEONIC: instrumentOpenAI requires a client exposing chat.completions.create.", "openai", "", ["openai"]);
     }
     const originalCreate = targetCreate.bind(openaiClient.chat.completions);
     openaiClient.chat.completions.create = async (...args) => {
-        const traceId = generateTraceId();
-        const spanId = generateSpanId();
+        const traceId = getTraceId() || generateTraceId();
+        const spanId = getSpanId() || generateSpanId();
         return bindTraceContext(traceId, spanId, async () => {
             const startedAt = Date.now();
             const model = extractRequestedModel(args);
@@ -55,15 +55,15 @@ export function instrumentOpenAI(openaiClient, options) {
             markClampAppliedIfChanged(protectDecision, extractMaxOutputTokens(args), extractMaxOutputTokens(callArgs));
             try {
                 const response = await originalCreate(...callArgs);
-                await options.client.captureEventAndFlush(buildEvent({
+                const event = buildInternalEvent({
                     provider: "openai",
                     requested_model: model,
-                    resolved_model: extractResponseModel(response),
                     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,
                     },
@@ -72,19 +72,21 @@ export function instrumentOpenAI(openaiClient, options) {
                         total_tokens: extractTotalTokens(response),
                         http_status: 200,
                     },
-                }));
+                });
+                event.resolved_model = extractResponseModel(response);
+                await options.client.captureEventAndFlush(event);
                 return response;
             }
             catch (error) {
-                await options.client.captureEventAndFlush(buildEvent({
+                await options.client.captureEventAndFlush(buildInternalEvent({
                     provider: "openai",
                     requested_model: model,
-                    resolved_model: null,
                     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,
                     },

package/dist/tokenEstimator.js

@@ -39,6 +39,17 @@ function extractTextForEstimation(request) {
     if (typeof request.prompt === "string") {
         return request.prompt;
     }
+    if (typeof request.contents === "string") {
+        return request.contents;
+    }
+    if (Array.isArray(request.contents)) {
+        try {
+            return JSON.stringify(request.contents);
+        }
+        catch {
+            return null;
+        }
+    }
     return null;
 }
 function getEncoder(model) {

package/package.json

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