agent-inspect 6.8.0 → 6.9.0

package/packages/core/dist/checks.cjs

@@ -273,8 +273,35 @@ var DEFAULT_RAW_CONTENT_KEYS = [
   "toolinput",
   "tool_input",
   "tooloutput",
-  "tool_output"
+  "tool_output",
+  // Framework / agent metadata that carries user or task text
+  "currenttask",
+  "current_task",
+  "task",
+  "userinput",
+  "user_input",
+  "requesttext",
+  "request_text",
+  "conversationtext",
+  "conversation_text"
 ];
+var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = ["tokenUsage", "usage"];
+var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
+  "input",
+  "output",
+  "total",
+  "cached",
+  "input_tokens",
+  "inputtokens",
+  "output_tokens",
+  "outputtokens",
+  "total_tokens",
+  "totaltokens",
+  "prompt_tokens",
+  "prompttokens",
+  "completion_tokens",
+  "completiontokens"
+]);
 var DEFAULT_SECRET_PATTERNS = [
   { id: "bearer-token", pattern: /Bearer\s+[A-Za-z0-9._~+/-]{12,}=*/ },
   { id: "openai-key", pattern: /sk-[A-Za-z0-9_-]{16,}/ },
@@ -452,7 +479,11 @@ function normalizeFinding(rule, finding) {
     message: finding.message,
     ...finding.expected !== void 0 ? { expected: finding.expected } : {},
     ...finding.actual !== void 0 ? { actual: finding.actual } : {},
-    evidence: [...finding.evidence ?? []]
+    evidence: [...finding.evidence ?? []],
+    ...finding.category !== void 0 ? { category: finding.category } : {},
+    ...finding.confidence !== void 0 ? { confidence: finding.confidence } : {},
+    ...finding.detector !== void 0 ? { detector: finding.detector } : {},
+    ...finding.action !== void 0 ? { action: finding.action } : {}
   };
 }
 function summarize(findings, diagnostics) {
@@ -510,15 +541,19 @@ function eventEvidence(event, path3) {
 function runEvidence(run) {
   return run ? [{ runId: run.runId, name: run.name, status: run.status }] : [];
 }
-function failFinding(ruleId, message, evidence, expected, actual) {
+function failFinding(ruleId, message, evidence, expected, actual, meta) {
   return {
     ruleId,
-    severity: "error",
-    status: "fail",
+    severity: meta?.severity ?? "error",
+    status: meta?.status ?? "fail",
     message,
     ...expected !== void 0 ? { expected } : {},
     ...actual !== void 0 ? { actual } : {},
-    evidence: [...evidence]
+    evidence: [...evidence],
+    ...meta?.category !== void 0 ? { category: meta.category } : {},
+    ...meta?.confidence !== void 0 ? { confidence: meta.confidence } : {},
+    ...meta?.detector !== void 0 ? { detector: meta.detector } : {},
+    ...meta?.action !== void 0 ? { action: meta.action } : {}
   };
 }
 function toolName(event) {
@@ -650,6 +685,19 @@ function isRawContentKey(key, forbiddenKeys) {
   const normalized = normalizedKey(key);
   return forbiddenKeys.some((forbidden) => normalized === normalizedKey(forbidden));
 }
+function isSafeRawContentMetricPath(path3, key, safePathPrefixes) {
+  const leaf = normalizedKey(key ?? lastPathSegment(path3));
+  if (!SAFE_USAGE_LEAF_KEYS.has(leaf)) return false;
+  const parts = path3.split(".").filter(Boolean);
+  if (parts.length < 2) return false;
+  const parent = parts[parts.length - 2] ?? "";
+  const parentNorm = normalizedKey(parent);
+  return safePathPrefixes.some((prefix) => parentNorm === normalizedKey(prefix));
+}
+function isRawContentPath(path3, key, forbiddenKeys, safePathPrefixes) {
+  if (isSafeRawContentMetricPath(path3, key, safePathPrefixes)) return false;
+  return isRawContentKey(key ?? lastPathSegment(path3), forbiddenKeys);
+}
 function parentMarkedUnresolved(event) {
   if (booleanAttr(event, [
     "parentUnresolved",
@@ -1533,7 +1581,13 @@ function createSafetyRedactionRule(options = {}) {
               `Sensitive-looking field at ${entry.path} is not redacted.`,
               [eventEvidence(event, entry.path)],
               "redaction marker",
-              { path: entry.path, valueType: valueType(entry.value) }
+              { path: entry.path, valueType: valueType(entry.value) },
+              {
+                category: "credential",
+                confidence: "high",
+                detector: "safety.redaction",
+                action: "redact"
+              }
             )
           );
         }
@@ -1544,6 +1598,7 @@ function createSafetyRedactionRule(options = {}) {
 }
 function createSafetyRawContentRule(options = {}) {
   const forbiddenKeys = options.forbiddenKeys ?? DEFAULT_RAW_CONTENT_KEYS;
+  const safePathPrefixes = options.safePathPrefixes ?? DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES;
   return {
     id: "safety.rawPrompt",
     category: "safety",
@@ -1553,14 +1608,20 @@ function createSafetyRawContentRule(options = {}) {
       for (const event of context.events) {
         for (const entry of eventValueEntries(event, { includeSummaries: options.includeSummaries })) {
           const key = entry.key ?? lastPathSegment(entry.path);
-          if (!isRawContentKey(key, forbiddenKeys)) continue;
+          if (!isRawContentPath(entry.path, key, forbiddenKeys, safePathPrefixes)) continue;
           findings.push(
             failFinding(
               "safety.rawPrompt",
               `Raw content-like field ${entry.path} is present.`,
               [eventEvidence(event, entry.path)],
               "metadata-only trace fields",
-              { path: entry.path, valueType: valueType(entry.value) }
+              { path: entry.path, valueType: valueType(entry.value) },
+              {
+                category: "raw-content",
+                confidence: "high",
+                detector: "safety.rawPrompt",
+                action: "redact-or-omit"
+              }
             )
           );
         }
@@ -1592,7 +1653,13 @@ function createSafetySecretPatternRule(options = {}) {
                 `Secret-like pattern ${pattern.id} matched at ${entry.path}.`,
                 [eventEvidence(event, entry.path)],
                 "no secret-like strings",
-                { pattern: pattern.id, path: entry.path }
+                { pattern: pattern.id, path: entry.path },
+                {
+                  category: "credential",
+                  confidence: "high",
+                  detector: pattern.id,
+                  action: "redact"
+                }
               )
             );
             break;
@@ -1619,7 +1686,13 @@ function createSafetyOversizedAttributeRule(options) {
                 `String at ${entry.path} exceeds ${options.maxStringLength} characters.`,
                 [eventEvidence(event, entry.path)],
                 { maxStringLength: options.maxStringLength },
-                { path: entry.path, length: entry.value.length }
+                { path: entry.path, length: entry.value.length },
+                {
+                  category: "size",
+                  confidence: "high",
+                  detector: "safety.oversizedAttribute",
+                  action: "truncate-or-omit"
+                }
               )
             );
           }
@@ -1630,7 +1703,13 @@ function createSafetyOversizedAttributeRule(options) {
                 `Array at ${entry.path} exceeds ${options.maxArrayLength} items.`,
                 [eventEvidence(event, entry.path)],
                 { maxArrayLength: options.maxArrayLength },
-                { path: entry.path, length: entry.value.length }
+                { path: entry.path, length: entry.value.length },
+                {
+                  category: "size",
+                  confidence: "high",
+                  detector: "safety.oversizedAttribute",
+                  action: "truncate-or-omit"
+                }
               )
             );
           }
@@ -1641,7 +1720,13 @@ function createSafetyOversizedAttributeRule(options) {
                 `Object at ${entry.path} exceeds ${options.maxObjectKeys} keys.`,
                 [eventEvidence(event, entry.path)],
                 { maxObjectKeys: options.maxObjectKeys },
-                { path: entry.path, keys: Object.keys(entry.value).length }
+                { path: entry.path, keys: Object.keys(entry.value).length },
+                {
+                  category: "size",
+                  confidence: "high",
+                  detector: "safety.oversizedAttribute",
+                  action: "truncate-or-omit"
+                }
               )
             );
           }
@@ -1654,7 +1739,13 @@ function createSafetyOversizedAttributeRule(options) {
                   `Value at ${entry.path} exceeds ${options.maxSerializedBytes} serialized bytes.`,
                   [eventEvidence(event, entry.path)],
                   { maxSerializedBytes: options.maxSerializedBytes },
-                  { path: entry.path, bytes }
+                  { path: entry.path, bytes },
+                  {
+                    category: "size",
+                    confidence: "high",
+                    detector: "safety.oversizedAttribute",
+                    action: "truncate-or-omit"
+                  }
                 )
               );
             }