agent-inspect 3.2.0 → 3.4.0

package/packages/core/dist/checks.cjs

@@ -580,6 +580,108 @@ function createRunDurationRule(options) {
     }
   };
 }
+function createMaxStepDurationRule(options) {
+  return {
+    id: "run.maxStepDuration",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const over = context.events.filter((event) => {
+        const duration = eventDurationMs(event);
+        return duration !== void 0 && duration > options.maxDurationMs;
+      });
+      if (over.length === 0) return [];
+      return [
+        failFinding(
+          "run.maxStepDuration",
+          `${over.length} step(s) exceeded max duration ${options.maxDurationMs}ms.`,
+          over.map((event) => eventEvidence(event, "durationMs")),
+          { maxDurationMs: options.maxDurationMs },
+          over.map((event) => ({
+            eventId: event.eventId,
+            name: event.name,
+            durationMs: eventDurationMs(event)
+          }))
+        )
+      ];
+    }
+  };
+}
+function createStallDetectionRule(options = {}) {
+  const requireEndedAt = options.requireEndedAt === true;
+  return {
+    id: "run.stall",
+    category: "run",
+    defaultSeverity: "warning",
+    evaluate(context) {
+      const findings = [];
+      const running = context.events.filter((event) => event.status === "running");
+      if (running.length > 0) {
+        findings.push(
+          failFinding(
+            "run.stall",
+            `Found ${running.length} event(s) still running (possible stall).`,
+            running.map((event) => eventEvidence(event, "status")),
+            "no running events",
+            running.length
+          )
+        );
+      }
+      if (requireEndedAt) {
+        const incomplete = context.events.filter(
+          (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
+        );
+        if (incomplete.length > 0) {
+          findings.push(
+            failFinding(
+              "run.stall",
+              `Found ${incomplete.length} started event(s) without endedAt.`,
+              incomplete.map((event) => eventEvidence(event, "endedAt")),
+              "endedAt for started events",
+              incomplete.length
+            )
+          );
+        }
+      }
+      return findings;
+    }
+  };
+}
+function createRequireCompletedRule() {
+  return {
+    id: "run.requireCompleted",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const findings = [];
+      const runStatus = context.selectedRun?.status;
+      if (runStatus === "running") {
+        findings.push(
+          failFinding(
+            "run.requireCompleted",
+            "Run is still running.",
+            runEvidence(context.selectedRun),
+            "completed run",
+            runStatus
+          )
+        );
+      }
+      const running = context.events.filter((event) => event.status === "running");
+      if (running.length > 0) {
+        findings.push(
+          failFinding(
+            "run.requireCompleted",
+            `Run has ${running.length} incomplete running event(s).`,
+            running.map((event) => eventEvidence(event, "status")),
+            "no running events",
+            running.length
+          )
+        );
+      }
+      return findings;
+    }
+  };
+}
 function createRunEventCountRule(options) {
   return {
     id: "run.eventCount",
@@ -1513,6 +1615,8 @@ exports.createBaselineRegressionRule = createBaselineRegressionRule;
 exports.createDecisionRule = createDecisionRule;
 exports.createGuardrailRule = createGuardrailRule;
 exports.createLlmUsageRule = createLlmUsageRule;
+exports.createMaxStepDurationRule = createMaxStepDurationRule;
+exports.createRequireCompletedRule = createRequireCompletedRule;
 exports.createRetrievalRule = createRetrievalRule;
 exports.createRunDepthRule = createRunDepthRule;
 exports.createRunDurationRule = createRunDurationRule;
@@ -1522,6 +1626,7 @@ exports.createSafetyOversizedAttributeRule = createSafetyOversizedAttributeRule;
 exports.createSafetyRawContentRule = createSafetyRawContentRule;
 exports.createSafetyRedactionRule = createSafetyRedactionRule;
 exports.createSafetySecretPatternRule = createSafetySecretPatternRule;
+exports.createStallDetectionRule = createStallDetectionRule;
 exports.createStructureCycleRule = createStructureCycleRule;
 exports.createStructureIncompleteRule = createStructureIncompleteRule;
 exports.createStructureOrphanRule = createStructureOrphanRule;