agentid-sdk 0.1.25 → 0.1.28

package/dist/{chunk-3PLUMWYC.mjs → chunk-W37A4DPR.mjs}

@@ -1149,6 +1149,79 @@ var PIIManager = class {
   }
 };
 
+// src/context-intent.ts
+var EDUCATIONAL_MARKERS = [
+  "explain",
+  "analysis",
+  "analyze",
+  "analyse",
+  "review",
+  "summarize",
+  "summarise",
+  "summary",
+  "plain-language explanation",
+  "red flags",
+  "security workshop",
+  "training",
+  "lesson",
+  "quoted attack",
+  "quoted example",
+  "attack example",
+  "security event",
+  "security log",
+  "audit log",
+  "incident report",
+  "trace timeline"
+];
+var WARNING_MARKERS = [
+  "dangerous",
+  "risky",
+  "risk",
+  "warning",
+  "warn",
+  "malicious",
+  "security indicator",
+  "red flags"
+];
+var NON_EXECUTION_MARKERS = [
+  "do not execute",
+  "do not run",
+  "do not return commands",
+  "do not output commands",
+  "do not provide executable steps",
+  "for explanation only",
+  "non-executable"
+];
+function normalizeIntentInput(input) {
+  return input.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\s+/g, " ").trim();
+}
+function hasAnyMarker(input, markers) {
+  return markers.some((marker) => input.includes(marker));
+}
+function classifyInjectionContextIntent(input) {
+  const normalized = normalizeIntentInput(input ?? "");
+  if (!normalized) {
+    return {
+      educational: false,
+      quotedExample: false,
+      warningOnly: false,
+      nonExecutableConstraint: false,
+      promptInjectionExempt: false
+    };
+  }
+  const educational = hasAnyMarker(normalized, EDUCATIONAL_MARKERS);
+  const warningOnly = hasAnyMarker(normalized, WARNING_MARKERS);
+  const nonExecutableConstraint = hasAnyMarker(normalized, NON_EXECUTION_MARKERS);
+  const quotedExample = /["'`]/.test(input) || normalized.includes("quoted") || normalized.includes("quote") || normalized.includes("phrase") || normalized.includes("attack example");
+  return {
+    educational,
+    quotedExample,
+    warningOnly,
+    nonExecutableConstraint,
+    promptInjectionExempt: educational && (quotedExample || warningOnly || nonExecutableConstraint || normalized.includes("prompt injection indicator") || normalized.includes("jailbreak prompt"))
+  };
+}
+
 // src/security.ts
 var MAX_ANALYSIS_WINDOW = 8192;
 var WINDOW_SLICE_SIZE = 4e3;
@@ -1311,6 +1384,10 @@ function findRegexMatch(prompt) {
   if (!prompt) {
     return null;
   }
+  const contextIntent = classifyInjectionContextIntent(prompt);
+  if (contextIntent.promptInjectionExempt) {
+    return null;
+  }
   const normalizedPrompt = normalizeForHeuristics(prompt);
   for (const rule of HEURISTIC_RULES) {
     try {
@@ -1444,7 +1521,8 @@ async function reportSecurityEvent(options) {
     language: options.language,
     ai_scan_status: options.aiStatus ?? null,
     reason: options.reason ?? null,
-    client_event_id: eventId
+    client_event_id: eventId,
+    ...options.telemetryMetadata ?? {}
   };
   if (options.storePii) {
     metadata.snippet = snippet;
@@ -1492,7 +1570,8 @@ var InjectionScanner = class _InjectionScanner {
       source: options?.source,
       systemId: options?.systemId,
       eventId: options?.eventId,
-      clientEventId: options?.clientEventId
+      clientEventId: options?.clientEventId,
+      telemetryMetadata: options?.telemetryMetadata
     });
   }
   async scan(params) {
@@ -1504,6 +1583,11 @@ var InjectionScanner = class _InjectionScanner {
     const storePii = params.storePii === true;
     const aiScanEnabled = params.aiScanEnabled !== false;
     const language = detectLanguageTag(prompt);
+    const scanStartedAt = Date.now();
+    const buildTelemetryMetadata = () => ({
+      ...params.telemetryMetadata ?? {},
+      sdk_local_scan_ms: Math.max(0, Date.now() - scanStartedAt)
+    });
     const regexMatch = findRegexMatch(prompt);
     if (regexMatch) {
       await reportSecurityEvent({
@@ -1518,7 +1602,8 @@ var InjectionScanner = class _InjectionScanner {
         language,
         systemId: params.systemId,
         eventId: params.eventId,
-        clientEventId: params.clientEventId
+        clientEventId: params.clientEventId,
+        telemetryMetadata: buildTelemetryMetadata()
       });
       throw new Error(`AgentID: Prompt injection blocked (${regexMatch.rule})`);
     }
@@ -1542,7 +1627,8 @@ var InjectionScanner = class _InjectionScanner {
         reason: "ai_scan_disabled_for_high_risk_language",
         systemId: params.systemId,
         eventId: params.eventId,
-        clientEventId: params.clientEventId
+        clientEventId: params.clientEventId,
+        telemetryMetadata: buildTelemetryMetadata()
       });
       return;
     }
@@ -1564,7 +1650,8 @@ var InjectionScanner = class _InjectionScanner {
         reason: aiResult.reason,
         systemId: params.systemId,
         eventId: params.eventId,
-        clientEventId: params.clientEventId
+        clientEventId: params.clientEventId,
+        telemetryMetadata: buildTelemetryMetadata()
       });
       return;
     }
@@ -1583,7 +1670,8 @@ var InjectionScanner = class _InjectionScanner {
         reason: aiResult.reason,
         systemId: params.systemId,
         eventId: params.eventId,
-        clientEventId: params.clientEventId
+        clientEventId: params.clientEventId,
+        telemetryMetadata: buildTelemetryMetadata()
       });
       throw new Error(`AgentID: Prompt injection blocked (${aiResult.reason})`);
     }
@@ -1595,7 +1683,7 @@ function getInjectionScanner() {
 
 // src/sdk-version.ts
 var FALLBACK_SDK_VERSION = "js-0.0.0-dev";
-var AGENTID_SDK_VERSION_HEADER = "js-0.1.25".trim().length > 0 ? "js-0.1.25" : FALLBACK_SDK_VERSION;
+var AGENTID_SDK_VERSION_HEADER = "js-0.1.28".trim().length > 0 ? "js-0.1.28" : FALLBACK_SDK_VERSION;
 
 // src/local-security-enforcer.ts
 var DEFAULT_FAIL_OPEN_CONFIG = {
@@ -1708,8 +1796,8 @@ var LocalSecurityEnforcer = class {
 
 // src/capability-config.ts
 var CONFIG_TTL_MS = 5 * 60 * 1e3;
-var CONFIG_TIMEOUT_MS = 8e3;
-var CONFIG_RETRY_DELAY_MS = 1e3;
+var CONFIG_TIMEOUT_MS = 1500;
+var CONFIG_RETRY_DELAY_MS = 150;
 var MAX_CAPABILITY_CACHE_ENTRIES = 500;
 var CapabilityConfigFetchError = class extends Error {
   constructor(message, params) {
@@ -2050,6 +2138,19 @@ function normalizeIngestTimeoutMs(value) {
   }
   return rounded;
 }
+function setFiniteDurationMetadata(metadata, key, value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    metadata[key] = Math.max(0, Math.trunc(value));
+  }
+}
+function buildSdkTimingMetadata(params) {
+  const metadata = {};
+  setFiniteDurationMetadata(metadata, "sdk_config_fetch_ms", params.sdkConfigFetchMs);
+  setFiniteDurationMetadata(metadata, "sdk_local_scan_ms", params.sdkLocalScanMs);
+  setFiniteDurationMetadata(metadata, "sdk_guard_ms", params.sdkGuardMs);
+  setFiniteDurationMetadata(metadata, "sdk_ingest_ms", params.sdkIngestMs);
+  return metadata;
+}
 function resolveConfiguredApiKey(value) {
   const explicit = typeof value === "string" ? value.trim() : "";
   const fromEnv = globalThis.process?.env?.AGENTID_API_KEY ?? "";
@@ -2063,6 +2164,9 @@ function isInfrastructureGuardReason(reason) {
   if (!reason) return false;
   return reason === "system_failure" || reason === "system_failure_db_unavailable" || reason === "logging_failed" || reason === "server_error" || reason === "guard_unreachable" || reason === "api_key_pepper_missing" || reason === "encryption_key_missing";
 }
+function isGuardFailureEligibleForLocalFallback(reason) {
+  return reason === "network_error_strict_mode" || reason === "server_error" || isInfrastructureGuardReason(reason);
+}
 function isFailCloseIngestReason(reason) {
   if (!reason) return false;
   return reason === "system_failure" || reason === "system_failure_db_unavailable" || reason === "server_error" || reason === "redis_rate_limit_unavailable" || reason === "redis_quota_unavailable" || reason === "redis_token_quota_unavailable";
@@ -2272,6 +2376,7 @@ var AgentID = class {
     this.baseUrl = normalizeBaseUrl3(config.baseUrl ?? "https://app.getagentid.com/api/v1");
     this.configuredPiiMasking = typeof config.piiMasking === "boolean" ? config.piiMasking : null;
     this.checkInjection = config.checkInjection !== false;
+    this.clientFastFail = config.clientFastFail === true || config.client_fast_fail === true;
     this.aiScanEnabled = config.aiScanEnabled !== false;
     this.storePii = config.storePii === true;
     this.strictMode = config.strictMode === true;
@@ -2374,6 +2479,14 @@ var AgentID = class {
       force
     });
   }
+  async getCapabilityConfigWithTelemetry(force = false, options) {
+    const configStartedAt = Date.now();
+    const capabilityConfig = await this.getCapabilityConfig(force, options);
+    return {
+      capabilityConfig,
+      sdkConfigFetchMs: Math.max(0, Date.now() - configStartedAt)
+    };
+  }
   getCachedCapabilityConfig(options) {
     const effectiveApiKey = this.resolveApiKey(options?.apiKey);
     return getCachedCapabilityConfig({
@@ -2417,37 +2530,45 @@ var AgentID = class {
     }
     return config.block_on_heuristic;
   }
-  async prepareInputForDispatch(params, options) {
-    const effectiveApiKey = this.resolveApiKey(options?.apiKey);
-    const capabilityConfig = await this.getCapabilityConfig(false, options);
-    if (!params.skipInjectionScan && params.input && this.shouldRunLocalInjectionScan(capabilityConfig)) {
+  async applyLocalPolicyChecks(params) {
+    const localScanStartedAt = Date.now();
+    if (params.runPromptInjectionCheck && params.input && this.shouldRunLocalInjectionScan(params.capabilityConfig)) {
       await this.injectionScanner.scan({
         prompt: params.input,
-        apiKey: effectiveApiKey,
+        apiKey: params.apiKey,
         baseUrl: this.baseUrl,
         aiScanEnabled: this.aiScanEnabled,
         storePii: this.storePii,
         piiManager: this.pii,
-        source: "js_sdk"
+        source: "js_sdk",
+        systemId: params.systemId,
+        eventId: params.clientEventId,
+        clientEventId: params.clientEventId,
+        telemetryMetadata: buildSdkTimingMetadata({
+          sdkConfigFetchMs: params.sdkConfigFetchMs
+        })
       });
     }
     try {
       const enforced = this.localEnforcer.enforce({
         input: params.input,
         stream: params.stream,
-        config: capabilityConfig
+        config: params.capabilityConfig
       });
+      const sdkLocalScanMs = Math.max(0, Date.now() - localScanStartedAt);
       for (const event of enforced.events) {
         this.logSecurityPolicyViolation({
           systemId: params.systemId,
           violationType: event.violationType,
           actionTaken: event.actionTaken,
-          apiKey: effectiveApiKey
+          apiKey: params.apiKey,
+          sdkConfigFetchMs: params.sdkConfigFetchMs,
+          sdkLocalScanMs
         });
       }
       return {
         sanitizedInput: enforced.sanitizedInput,
-        capabilityConfig
+        sdkLocalScanMs
       };
     } catch (error) {
       if (error instanceof SecurityPolicyViolationError) {
@@ -2455,17 +2576,76 @@ var AgentID = class {
           systemId: params.systemId,
           violationType: error.violationType,
           actionTaken: error.actionTaken,
-          apiKey: effectiveApiKey
+          apiKey: params.apiKey,
+          sdkConfigFetchMs: params.sdkConfigFetchMs,
+          sdkLocalScanMs: Math.max(0, Date.now() - localScanStartedAt)
         });
       }
       throw error;
     }
   }
+  async prepareInputForDispatch(params, options) {
+    const effectiveApiKey = this.resolveApiKey(options?.apiKey);
+    const { capabilityConfig, sdkConfigFetchMs } = await this.getCapabilityConfigWithTelemetry(
+      false,
+      options
+    );
+    if (!this.clientFastFail) {
+      return {
+        sanitizedInput: params.input,
+        capabilityConfig,
+        sdkConfigFetchMs,
+        sdkLocalScanMs: 0
+      };
+    }
+    const enforced = await this.applyLocalPolicyChecks({
+      input: params.input,
+      systemId: params.systemId,
+      stream: params.stream,
+      capabilityConfig,
+      apiKey: effectiveApiKey,
+      clientEventId: params.clientEventId,
+      sdkConfigFetchMs,
+      runPromptInjectionCheck: !params.skipInjectionScan
+    });
+    return {
+      sanitizedInput: enforced.sanitizedInput,
+      capabilityConfig,
+      sdkConfigFetchMs,
+      sdkLocalScanMs: enforced.sdkLocalScanMs
+    };
+  }
+  async applyLocalFallbackForGuardFailure(params, options) {
+    const effectiveApiKey = this.resolveApiKey(options?.apiKey);
+    const resolvedConfig = params.capabilityConfig && typeof params.sdkConfigFetchMs === "number" ? {
+      capabilityConfig: params.capabilityConfig,
+      sdkConfigFetchMs: params.sdkConfigFetchMs
+    } : await this.getCapabilityConfigWithTelemetry(false, options);
+    const enforced = await this.applyLocalPolicyChecks({
+      input: params.input,
+      systemId: params.systemId,
+      stream: params.stream,
+      capabilityConfig: resolvedConfig.capabilityConfig,
+      apiKey: effectiveApiKey,
+      clientEventId: params.clientEventId,
+      sdkConfigFetchMs: resolvedConfig.sdkConfigFetchMs,
+      runPromptInjectionCheck: true
+    });
+    return {
+      sanitizedInput: enforced.sanitizedInput,
+      capabilityConfig: resolvedConfig.capabilityConfig,
+      sdkConfigFetchMs: resolvedConfig.sdkConfigFetchMs,
+      sdkLocalScanMs: enforced.sdkLocalScanMs
+    };
+  }
   async scanPromptInjection(input, options) {
     if (!input) {
       return;
     }
-    const capabilityConfig = await this.getCapabilityConfig(false, options);
+    const { capabilityConfig, sdkConfigFetchMs } = await this.getCapabilityConfigWithTelemetry(
+      false,
+      options
+    );
     if (!this.shouldRunLocalInjectionScan(capabilityConfig)) {
       return;
     }
@@ -2480,7 +2660,10 @@ var AgentID = class {
       source: "js_sdk",
       systemId: options?.systemId,
       eventId: options?.clientEventId,
-      clientEventId: options?.clientEventId
+      clientEventId: options?.clientEventId,
+      telemetryMetadata: buildSdkTimingMetadata({
+        sdkConfigFetchMs
+      })
     });
   }
   withMaskedOpenAIRequest(req, maskedText) {
@@ -2529,7 +2712,11 @@ var AgentID = class {
         system_id: params.systemId,
         violation_type: params.violationType,
         input_snippet: "[REDACTED_SAMPLE]",
-        action_taken: params.actionTaken
+        action_taken: params.actionTaken,
+        ...buildSdkTimingMetadata({
+          sdkConfigFetchMs: params.sdkConfigFetchMs,
+          sdkLocalScanMs: params.sdkLocalScanMs
+        })
       }
     }, { apiKey: params.apiKey });
   }
@@ -2555,6 +2742,42 @@ var AgentID = class {
       { apiKey: params.apiKey }
     );
   }
+  async finalizeIngestTelemetry(params) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      Math.min(this.ingestTimeoutMs, 2e3)
+    );
+    try {
+      const response = await fetch(`${this.baseUrl}/ingest/finalize`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-agentid-api-key": params.apiKey,
+          "x-correlation-id": params.clientEventId,
+          "X-AgentID-SDK-Version": AGENTID_SDK_VERSION_HEADER
+        },
+        body: JSON.stringify({
+          client_event_id: params.clientEventId,
+          system_id: params.systemId,
+          sdk_ingest_ms: params.sdkIngestMs
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        console.warn(
+          `[AgentID] Ingest telemetry finalize failed (status=${response.status}, client_event_id=${params.clientEventId}).`
+        );
+      }
+    } catch (error) {
+      const label = error && typeof error === "object" && error.name === "AbortError" ? "timeout" : "network";
+      console.warn(
+        `[AgentID] Ingest telemetry finalize failed (${label}, client_event_id=${params.clientEventId}).`
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
   /**
    * GUARD: Checks limits, PII, and security before execution.
    * strictMode=false (default): FAIL-OPEN on connectivity/timeouts.
@@ -2712,15 +2935,16 @@ var AgentID = class {
     }
     return withGuardLatency({ allowed: true, reason: "guard_unreachable" });
   }
-  async sendIngest(params, options) {
+  async sendIngest(params, options, internal) {
+    const ingestStartedAt = Date.now();
     const effectiveApiKey = this.resolveApiKey(options?.apiKey);
-    const eventId = createEventId2(params.event_id);
+    const transportEventId = createEventId2(internal?.transportEventId ?? params.event_id);
     const timestamp = params.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
     const metadata = {
       ...params.metadata ?? {}
     };
     const metadataClientEventId = typeof metadata.client_event_id === "string" && isUuidLike2(metadata.client_event_id) ? metadata.client_event_id : null;
-    const canonicalClientEventId = metadataClientEventId ?? eventId;
+    const canonicalClientEventId = metadataClientEventId ?? transportEventId;
     if (!metadataClientEventId) {
       metadata.client_event_id = canonicalClientEventId;
     }
@@ -2730,7 +2954,7 @@ var AgentID = class {
     void this.getCapabilityConfig(false, { apiKey: effectiveApiKey }).catch(() => void 0);
     const payload = {
       ...params,
-      event_id: canonicalClientEventId,
+      event_id: internal?.transportEventId ? transportEventId : canonicalClientEventId,
       timestamp,
       input: sanitizeIngestText(params.input),
       output: sanitizeIngestText(params.output),
@@ -2755,6 +2979,14 @@ var AgentID = class {
         });
         const responseBody = await safeReadJson2(response);
         if (response.ok) {
+          if (!internal?.disableFinalize) {
+            void this.finalizeIngestTelemetry({
+              apiKey: effectiveApiKey,
+              clientEventId: canonicalClientEventId,
+              systemId: params.system_id,
+              sdkIngestMs: Math.max(0, Date.now() - ingestStartedAt)
+            });
+          }
           return { ok: true, status: response.status, reason: null };
         }
         const reason = responseBody && typeof responseBody === "object" && typeof responseBody.reason === "string" ? responseBody.reason ?? null : null;
@@ -2815,6 +3047,13 @@ var AgentID = class {
     }
     return text;
   }
+  extractStreamChunkUsage(chunk) {
+    if (!chunk || typeof chunk !== "object") {
+      return void 0;
+    }
+    const usage = chunk.usage;
+    return usage && typeof usage === "object" && !Array.isArray(usage) ? usage : void 0;
+  }
   wrapCompletion(completion) {
     if (typeof completion === "string") {
       const masked = this.pii.anonymize(completion);
@@ -2838,7 +3077,9 @@ var AgentID = class {
     const source = completion;
     const collector = createCompletionChunkCollector();
     const extractStreamChunkText = this.extractStreamChunkText.bind(this);
+    const extractStreamChunkUsage = this.extractStreamChunkUsage.bind(this);
     const piiManager = this.pii;
+    let lastUsage;
     let resolveDone = null;
     let rejectDone = null;
     const done = new Promise((resolve, reject) => {
@@ -2853,6 +3094,10 @@ var AgentID = class {
             if (chunkText) {
               await collector.push(chunkText);
             }
+            const chunkUsage = extractStreamChunkUsage(chunk);
+            if (chunkUsage) {
+              lastUsage = chunkUsage;
+            }
             yield chunk;
           }
           await collector.close();
@@ -2862,7 +3107,8 @@ var AgentID = class {
             mode: "static",
             rawOutput,
             transformedOutput: masked.maskedText,
-            outputMasked: masked.maskedText !== rawOutput
+            outputMasked: masked.maskedText !== rawOutput,
+            usage: lastUsage
           });
         } catch (error) {
           await collector.abort(error);
@@ -2912,7 +3158,7 @@ var AgentID = class {
    * Wrap an OpenAI client once; AgentID will automatically:
    * - run guard() before chat.completions.create
    * - measure latency
-   * - fire-and-forget ingest logging
+   * - persist ingest telemetry for the wrapped call
    */
   wrapOpenAI(openai, options) {
     const systemId = options.system_id;
@@ -2955,20 +3201,19 @@ var AgentID = class {
                 let createArgs = normalizedCreateArgs;
                 let mapping = {};
                 let shouldDeanonymize = false;
+                let sdkConfigFetchMs = 0;
+                let sdkLocalScanMs = 0;
                 if (userText) {
-                  await this.scanPromptInjection(userText, {
-                    ...requestOptions,
-                    clientEventId,
-                    systemId
-                  });
                   const prepared = await this.prepareInputForDispatch({
                     input: userText,
                     systemId,
                     stream,
-                    skipInjectionScan: true
+                    clientEventId
                   }, requestOptions);
                   capabilityConfig = prepared.capabilityConfig;
                   maskedText = prepared.sanitizedInput;
+                  sdkConfigFetchMs = prepared.sdkConfigFetchMs ?? 0;
+                  sdkLocalScanMs = prepared.sdkLocalScanMs ?? 0;
                   if (maskedText !== userText) {
                     maskedReq = this.withMaskedOpenAIRequest(
                       req,
@@ -3009,14 +3254,46 @@ var AgentID = class {
                   user_id: options.user_id,
                   client_event_id: clientEventId,
                   expected_languages: expectedLanguages,
+                  request_identity: options.request_identity,
                   client_capabilities: this.buildClientCapabilities(
                     "openai",
                     false,
                     capabilityConfig
                   )
                 }, requestOptions);
+                let localFallbackApplied = false;
+                let localFallbackReason = null;
                 if (!verdict.allowed) {
-                  throw new SecurityBlockError(verdict.reason ?? "guard_denied");
+                  if (effectiveStrictMode && isGuardFailureEligibleForLocalFallback(verdict.reason)) {
+                    localFallbackApplied = true;
+                    localFallbackReason = verdict.reason ?? "guard_unreachable";
+                    if (sdkLocalScanMs === 0) {
+                      const fallback = await this.applyLocalPolicyChecks({
+                        input: maskedText,
+                        systemId,
+                        stream,
+                        capabilityConfig,
+                        apiKey: effectiveApiKey,
+                        clientEventId,
+                        sdkConfigFetchMs,
+                        runPromptInjectionCheck: true
+                      });
+                      maskedText = fallback.sanitizedInput;
+                      sdkLocalScanMs = fallback.sdkLocalScanMs;
+                    }
+                  } else {
+                    throw new SecurityBlockError(verdict.reason ?? "guard_denied");
+                  }
+                }
+                const currentRequestInput = adapter.extractInput(maskedReq);
+                if (maskedText !== currentRequestInput) {
+                  maskedReq = this.withMaskedOpenAIRequest(
+                    req,
+                    maskedText
+                  );
+                  const nextCreateArgs = [...normalizedCreateArgs];
+                  nextCreateArgs[0] = maskedReq;
+                  createArgs = nextCreateArgs;
                 }
                 const canonicalClientEventId = typeof verdict.client_event_id === "string" && isUuidLike2(verdict.client_event_id) ? verdict.client_event_id : clientEventId;
                 const guardEventId = typeof verdict.guard_event_id === "string" && verdict.guard_event_id.length > 0 ? verdict.guard_event_id : null;
@@ -3053,10 +3330,11 @@ var AgentID = class {
                         event_id: canonicalClientEventId,
                         system_id: systemId,
                         user_id: options.user_id,
+                        request_identity: options.request_identity,
                         input: maskedText,
                         output: outputForLog,
                         model: adapter.getModelName(maskedReq),
-                        usage: void 0,
+                        usage: result.usage,
                         latency: modelLatencyMs2,
                         event_type: "complete",
                         metadata: {
@@ -3067,12 +3345,19 @@ var AgentID = class {
                           simulated_decision: verdict.simulated_decision ?? null,
                           simulated_output_decision: isShadowMode && result.outputMasked ? "masked" : "allowed",
                           response_streamed: true,
+                          sdk_local_fallback_applied: localFallbackApplied,
+                          sdk_local_fallback_reason: localFallbackReason,
                           guard_latency_ms: guardLatencyMs,
                           model_latency_ms: modelLatencyMs2,
                           total_pipeline_latency_ms: totalPipelineLatencyMs2,
                           guard_event_id: guardEventId,
                           client_event_id: canonicalClientEventId,
-                          transparency
+                          transparency,
+                          ...buildSdkTimingMetadata({
+                            sdkConfigFetchMs,
+                            sdkLocalScanMs,
+                            sdkGuardMs: guardLatencyMs
+                          })
                         },
                         client_capabilities: this.buildClientCapabilities(
                           "openai",
@@ -3112,6 +3397,7 @@ var AgentID = class {
                     event_id: canonicalClientEventId,
                     system_id: systemId,
                     user_id: options.user_id,
+                    request_identity: options.request_identity,
                     input: maskedText,
                     output: outputForLog,
                     model,
@@ -3126,12 +3412,19 @@ var AgentID = class {
                       simulated_decision: verdict.simulated_decision ?? null,
                       simulated_output_decision: isShadowMode && wrappedCompletion.outputMasked ? "masked" : "allowed",
                       response_streamed: false,
+                      sdk_local_fallback_applied: localFallbackApplied,
+                      sdk_local_fallback_reason: localFallbackReason,
                       guard_latency_ms: guardLatencyMs,
                       model_latency_ms: modelLatencyMs,
                       total_pipeline_latency_ms: totalPipelineLatencyMs,
                       guard_event_id: guardEventId,
                       client_event_id: canonicalClientEventId,
-                      transparency
+                      transparency,
+                      ...buildSdkTimingMetadata({
+                        sdkConfigFetchMs,
+                        sdkLocalScanMs,
+                        sdkGuardMs: guardLatencyMs
+                      })
                     },
                     client_capabilities: this.buildClientCapabilities(
                       "openai",

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { T as TransparencyMetadata } from './agentid-B5Y1g2Ko.mjs';
-export { A as AgentID, D as DependencyError, G as GuardParams, a as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions, S as SecurityBlockError } from './agentid-B5Y1g2Ko.mjs';
+import { T as TransparencyMetadata } from './agentid-agvYW2vW.mjs';
+export { A as AgentID, D as DependencyError, G as GuardParams, a as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions, S as SecurityBlockError } from './agentid-agvYW2vW.mjs';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type PIIMapping = Record<string, string>;
@@ -16,7 +16,7 @@ declare class PIIManager {
     deanonymize(text: string, mapping: PIIMapping): string;
 }
 
-type TokenUsage = Record<string, number>;
+type TokenUsage = Record<string, unknown>;
 interface LLMAdapter {
     extractInput(req: unknown): string | null;
     getModelName(req: unknown, res?: unknown): string;
@@ -43,6 +43,7 @@ type InjectionScanParams = {
     systemId?: string;
     eventId?: string;
     clientEventId?: string;
+    telemetryMetadata?: Record<string, unknown>;
 };
 declare function scanWithRegex(prompt: string): string | null;
 declare class InjectionScanner {
@@ -55,6 +56,7 @@ declare class InjectionScanner {
         systemId?: string;
         eventId?: string;
         clientEventId?: string;
+        telemetryMetadata?: Record<string, unknown>;
     }): Promise<void>;
     scan(params: InjectionScanParams): Promise<void>;
 }