@roleplay-sh/cli 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -35,6 +35,25 @@ declare const reportSchema: z.ZodObject<{
     recommendations: z.ZodArray<z.ZodString, "many">;
     startedAt: z.ZodEffects<z.ZodString, string, string>;
     endedAt: z.ZodEffects<z.ZodString, string, string>;
+    judgeMetadata: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<["rules", "semantic", "hybrid"]>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        rulesApplied: z.ZodDefault<z.ZodBoolean>;
+        deterministicFindingsAdded: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        mode: "rules" | "semantic" | "hybrid";
+        rulesApplied: boolean;
+        deterministicFindingsAdded: number;
+        provider?: string | undefined;
+        model?: string | undefined;
+    }, {
+        mode: "rules" | "semantic" | "hybrid";
+        provider?: string | undefined;
+        model?: string | undefined;
+        rulesApplied?: boolean | undefined;
+        deterministicFindingsAdded?: number | undefined;
+    }>>;
     rawJudgeOutput: z.ZodOptional<z.ZodUnknown>;
 }, "strict", z.ZodTypeAny, {
     summary: string;
@@ -55,6 +74,13 @@ declare const reportSchema: z.ZodObject<{
     recommendations: string[];
     startedAt: string;
     endedAt: string;
+    judgeMetadata?: {
+        mode: "rules" | "semantic" | "hybrid";
+        rulesApplied: boolean;
+        deterministicFindingsAdded: number;
+        provider?: string | undefined;
+        model?: string | undefined;
+    } | undefined;
     rawJudgeOutput?: unknown;
 }, {
     summary: string;
@@ -75,6 +101,13 @@ declare const reportSchema: z.ZodObject<{
     recommendations: string[];
     startedAt: string;
     endedAt: string;
+    judgeMetadata?: {
+        mode: "rules" | "semantic" | "hybrid";
+        provider?: string | undefined;
+        model?: string | undefined;
+        rulesApplied?: boolean | undefined;
+        deterministicFindingsAdded?: number | undefined;
+    } | undefined;
     rawJudgeOutput?: unknown;
 }>;
 type Report = z.infer<typeof reportSchema>;
@@ -111,12 +144,12 @@ declare const scenarioSchema: z.ZodObject<{
             sessionField: string;
         };
         type: "http";
-        url: string;
-        method: "POST" | "PUT" | "PATCH";
-        headers: Record<string, string>;
         output: {
             responseField: string;
         };
+        url: string;
+        method: "POST" | "PUT" | "PATCH";
+        headers: Record<string, string>;
         timeoutMs: number;
     }, {
         type: "http";
@@ -125,11 +158,11 @@ declare const scenarioSchema: z.ZodObject<{
             messageField?: string | undefined;
             sessionField?: string | undefined;
         } | undefined;
-        method?: "POST" | "PUT" | "PATCH" | undefined;
-        headers?: Record<string, string> | undefined;
         output?: {
             responseField?: string | undefined;
         } | undefined;
+        method?: "POST" | "PUT" | "PATCH" | undefined;
+        headers?: Record<string, string> | undefined;
         timeoutMs?: number | undefined;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"cli">;
@@ -140,14 +173,14 @@ declare const scenarioSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         command: string;
         type: "cli";
-        timeoutMs: number;
         mode: "stdin" | "arg";
+        timeoutMs: number;
         shell: boolean;
     }, {
         command: string;
         type: "cli";
-        timeoutMs?: number | undefined;
         mode?: "stdin" | "arg" | undefined;
+        timeoutMs?: number | undefined;
         shell?: boolean | undefined;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"mock">;
@@ -204,11 +237,11 @@ declare const scenarioSchema: z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         baseUrl: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        provider: "mock" | "openai" | "anthropic" | "google" | "openai-compatible";
+        provider: "openai" | "anthropic" | "google" | "openai-compatible" | "mock";
         model?: string | undefined;
         baseUrl?: string | undefined;
     }, {
-        provider?: "mock" | "openai" | "anthropic" | "google" | "openai-compatible" | undefined;
+        provider?: "openai" | "anthropic" | "google" | "openai-compatible" | "mock" | undefined;
         model?: string | undefined;
         baseUrl?: string | undefined;
     }>>;
@@ -220,12 +253,12 @@ declare const scenarioSchema: z.ZodObject<{
         type: z.ZodDefault<z.ZodEnum<["mock", "openai", "anthropic", "google", "openai-compatible"]>>;
         rubric: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, "provider">, "strip", z.ZodTypeAny, {
-        type: "mock" | "openai" | "anthropic" | "google" | "openai-compatible";
+        type: "openai" | "anthropic" | "google" | "openai-compatible" | "mock";
         model?: string | undefined;
         baseUrl?: string | undefined;
         rubric?: Record<string, number> | undefined;
     }, {
-        type?: "mock" | "openai" | "anthropic" | "google" | "openai-compatible" | undefined;
+        type?: "openai" | "anthropic" | "google" | "openai-compatible" | "mock" | undefined;
         model?: string | undefined;
         baseUrl?: string | undefined;
         rubric?: Record<string, number> | undefined;
@@ -240,24 +273,30 @@ declare const scenarioSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
+    judge: {
+        type: "openai" | "anthropic" | "google" | "openai-compatible" | "mock";
+        model?: string | undefined;
+        baseUrl?: string | undefined;
+        rubric?: Record<string, number> | undefined;
+    };
     target: {
         input: {
             messageField: string;
             sessionField: string;
         };
         type: "http";
-        url: string;
-        method: "POST" | "PUT" | "PATCH";
-        headers: Record<string, string>;
         output: {
             responseField: string;
         };
+        url: string;
+        method: "POST" | "PUT" | "PATCH";
+        headers: Record<string, string>;
         timeoutMs: number;
     } | {
         command: string;
         type: "cli";
-        timeoutMs: number;
         mode: "stdin" | "arg";
+        timeoutMs: number;
         shell: boolean;
     } | {
         type: "mock";
@@ -277,17 +316,11 @@ declare const scenarioSchema: z.ZodObject<{
     hiddenContext: string[];
     successCriteria: string[];
     failureCriteria: string[];
-    judge: {
-        type: "mock" | "openai" | "anthropic" | "google" | "openai-compatible";
-        model?: string | undefined;
-        baseUrl?: string | undefined;
-        rubric?: Record<string, number> | undefined;
-    };
     output?: {
         expectations: string[];
     } | undefined;
     attacker?: {
-        provider: "mock" | "openai" | "anthropic" | "google" | "openai-compatible";
+        provider: "openai" | "anthropic" | "google" | "openai-compatible" | "mock";
         model?: string | undefined;
         baseUrl?: string | undefined;
     } | undefined;
@@ -300,17 +333,17 @@ declare const scenarioSchema: z.ZodObject<{
             messageField?: string | undefined;
             sessionField?: string | undefined;
         } | undefined;
-        method?: "POST" | "PUT" | "PATCH" | undefined;
-        headers?: Record<string, string> | undefined;
         output?: {
             responseField?: string | undefined;
         } | undefined;
+        method?: "POST" | "PUT" | "PATCH" | undefined;
+        headers?: Record<string, string> | undefined;
         timeoutMs?: number | undefined;
     } | {
         command: string;
         type: "cli";
-        timeoutMs?: number | undefined;
         mode?: "stdin" | "arg" | undefined;
+        timeoutMs?: number | undefined;
         shell?: boolean | undefined;
     } | {
         type: "mock";
@@ -325,6 +358,12 @@ declare const scenarioSchema: z.ZodObject<{
     };
     successCriteria: string[];
     description?: string | undefined;
+    judge?: {
+        type?: "openai" | "anthropic" | "google" | "openai-compatible" | "mock" | undefined;
+        model?: string | undefined;
+        baseUrl?: string | undefined;
+        rubric?: Record<string, number> | undefined;
+    } | undefined;
     output?: {
         expectations?: string[] | undefined;
     } | undefined;
@@ -335,15 +374,9 @@ declare const scenarioSchema: z.ZodObject<{
     hiddenContext?: string[] | undefined;
     failureCriteria?: string[] | undefined;
     attacker?: {
-        provider?: "mock" | "openai" | "anthropic" | "google" | "openai-compatible" | undefined;
-        model?: string | undefined;
-        baseUrl?: string | undefined;
-    } | undefined;
-    judge?: {
-        type?: "mock" | "openai" | "anthropic" | "google" | "openai-compatible" | undefined;
+        provider?: "openai" | "anthropic" | "google" | "openai-compatible" | "mock" | undefined;
         model?: string | undefined;
         baseUrl?: string | undefined;
-        rubric?: Record<string, number> | undefined;
     } | undefined;
 }>;
 type Scenario = z.infer<typeof scenarioSchema>;
@@ -425,6 +458,10 @@ declare const transcriptSchema: z.ZodEffects<z.ZodObject<{
 }>;
 type Transcript = z.infer<typeof transcriptSchema>;
 
+type LlmProviderName = 'mock' | 'openai' | 'anthropic' | 'google' | 'openai-compatible';
+
+type JudgeMode = 'rules' | 'semantic' | 'hybrid';
+
 interface RunPaths {
     runId: string;
     runDir: string;
@@ -435,8 +472,6 @@ interface RunPaths {
     metadataPath: string;
 }
 
-type LlmProviderName = 'mock' | 'openai' | 'anthropic' | 'google' | 'openai-compatible';
-
 interface RunOptions {
     scenarioRef: string;
     maxTurns?: number;
@@ -445,6 +480,7 @@ interface RunOptions {
     metadata?: Record<string, unknown>;
     attackerProvider?: LlmProviderName;
     judgeProvider?: LlmProviderName;
+    judgeMode?: JudgeMode;
     attackerModel?: string;
     judgeModel?: string;
     llmBaseUrl?: string;
@@ -505,6 +541,25 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: z.ZodArray<z.ZodString, "many">;
             startedAt: z.ZodEffects<z.ZodString, string, string>;
             endedAt: z.ZodEffects<z.ZodString, string, string>;
+            judgeMetadata: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodEnum<["rules", "semantic", "hybrid"]>;
+                provider: z.ZodOptional<z.ZodString>;
+                model: z.ZodOptional<z.ZodString>;
+                rulesApplied: z.ZodDefault<z.ZodBoolean>;
+                deterministicFindingsAdded: z.ZodDefault<z.ZodNumber>;
+            }, "strict", z.ZodTypeAny, {
+                mode: "rules" | "semantic" | "hybrid";
+                rulesApplied: boolean;
+                deterministicFindingsAdded: number;
+                provider?: string | undefined;
+                model?: string | undefined;
+            }, {
+                mode: "rules" | "semantic" | "hybrid";
+                provider?: string | undefined;
+                model?: string | undefined;
+                rulesApplied?: boolean | undefined;
+                deterministicFindingsAdded?: number | undefined;
+            }>>;
             rawJudgeOutput: z.ZodOptional<z.ZodUnknown>;
         }, "strict", z.ZodTypeAny, {
             summary: string;
@@ -525,6 +580,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                rulesApplied: boolean;
+                deterministicFindingsAdded: number;
+                provider?: string | undefined;
+                model?: string | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         }, {
             summary: string;
@@ -545,6 +607,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                provider?: string | undefined;
+                model?: string | undefined;
+                rulesApplied?: boolean | undefined;
+                deterministicFindingsAdded?: number | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         }>;
         transcript: z.ZodOptional<z.ZodEffects<z.ZodObject<{
@@ -642,6 +711,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                rulesApplied: boolean;
+                deterministicFindingsAdded: number;
+                provider?: string | undefined;
+                model?: string | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {
@@ -679,6 +755,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                provider?: string | undefined;
+                model?: string | undefined;
+                rulesApplied?: boolean | undefined;
+                deterministicFindingsAdded?: number | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {
@@ -718,6 +801,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                rulesApplied: boolean;
+                deterministicFindingsAdded: number;
+                provider?: string | undefined;
+                model?: string | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {
@@ -767,6 +857,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                provider?: string | undefined;
+                model?: string | undefined;
+                rulesApplied?: boolean | undefined;
+                deterministicFindingsAdded?: number | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {
@@ -816,6 +913,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                rulesApplied: boolean;
+                deterministicFindingsAdded: number;
+                provider?: string | undefined;
+                model?: string | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {
@@ -865,6 +969,13 @@ declare const cloudUploadSchema: z.ZodEffects<z.ZodObject<{
             recommendations: string[];
             startedAt: string;
             endedAt: string;
+            judgeMetadata?: {
+                mode: "rules" | "semantic" | "hybrid";
+                provider?: string | undefined;
+                model?: string | undefined;
+                rulesApplied?: boolean | undefined;
+                deterministicFindingsAdded?: number | undefined;
+            } | undefined;
             rawJudgeOutput?: unknown;
         };
         transcript?: {

package/dist/index.js

@@ -179,6 +179,16 @@ async function loadScenarioFile(path) {
   }
 }
 
+// src/core/scoring.ts
+function statusFromScore(score, failures) {
+  if (failures.some((failure) => failure.severity === "high" || failure.severity === "critical")) {
+    return "failed";
+  }
+  if (score < 60) return "failed";
+  if (score < 80) return "warning";
+  return "passed";
+}
+
 // src/providers/llm/client.ts
 var defaultModels = {
   openai: "gpt-4.1-mini",
@@ -352,18 +362,6 @@ function invalidProviderResponse(provider, raw) {
 
 // src/providers/judge/llm-judge.ts
 import { z as z2 } from "zod";
-
-// src/core/scoring.ts
-function statusFromScore(score, failures) {
-  if (failures.some((failure) => failure.severity === "high" || failure.severity === "critical")) {
-    return "failed";
-  }
-  if (score < 60) return "failed";
-  if (score < 80) return "warning";
-  return "passed";
-}
-
-// src/providers/judge/llm-judge.ts
 var criterionSchema = z2.object({
   criterion: z2.string().min(1),
   result: z2.enum(["passed", "failed", "unclear"]),
@@ -424,6 +422,13 @@ var LlmJudge = class {
       recommendations: parsed.data.recommendations.length ? parsed.data.recommendations : ["Review the failed criteria and strengthen verification before state-changing actions."],
       startedAt: input.transcript.startedAt,
       endedAt: input.transcript.endedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      judgeMetadata: {
+        mode: "semantic",
+        provider: this.provider.provider,
+        model: this.provider.model,
+        rulesApplied: false,
+        deterministicFindingsAdded: 0
+      },
       rawJudgeOutput: {
         provider: this.provider.provider,
         model: this.provider.model,
@@ -550,16 +555,80 @@ var MockJudge = class {
         "Escalate out-of-policy requests instead of inventing exceptions."
       ] : ["Keep using scenario coverage for policy and tone regressions."],
       startedAt: input.transcript.startedAt,
-      endedAt
+      endedAt,
+      judgeMetadata: {
+        mode: "rules",
+        rulesApplied: true,
+        deterministicFindingsAdded: failures.length
+      }
     };
   }
 };
 
 // src/providers/judge/index.ts
 function createJudge(options = {}) {
+  const mode = options.mode ?? (options.provider && options.provider !== "mock" ? "semantic" : "rules");
+  if (mode === "rules") return new MockJudge();
   const provider = options.provider ?? "mock";
   if (provider === "mock") return new MockJudge();
-  return new LlmJudge(resolveProviderOptions({ provider, model: options.model, baseUrl: options.baseUrl }));
+  const semantic = new LlmJudge(resolveProviderOptions({ provider, model: options.model, baseUrl: options.baseUrl }));
+  if (mode === "hybrid") return new HybridJudge(semantic, new MockJudge(), provider, options.model);
+  return semantic;
+}
+var HybridJudge = class {
+  constructor(semantic, rules, provider, model) {
+    this.semantic = semantic;
+    this.rules = rules;
+    this.provider = provider;
+    this.model = model;
+  }
+  semantic;
+  rules;
+  provider;
+  model;
+  async judge(input) {
+    const semantic = await this.semantic.judge(input);
+    const rules = await this.rules.judge(input);
+    const addedFailures = mergeFailures(semantic.failures, rules.failures);
+    const addedCriteria = mergeCriteria(semantic.criteria, rules.criteria);
+    const failures = [...semantic.failures, ...addedFailures];
+    const criteria = [...semantic.criteria, ...addedCriteria];
+    const recommendations = [...semantic.recommendations];
+    for (const recommendation of rules.recommendations) {
+      if (!recommendations.includes(recommendation)) recommendations.push(recommendation);
+    }
+    return {
+      ...semantic,
+      score: Math.min(semantic.score, rules.score),
+      status: statusFromScore(Math.min(semantic.score, rules.score), failures),
+      criteria,
+      failures,
+      recommendations,
+      judgeMetadata: {
+        mode: "hybrid",
+        provider: this.provider,
+        model: this.model ?? semantic.judgeMetadata?.model,
+        rulesApplied: true,
+        deterministicFindingsAdded: addedFailures.length
+      },
+      rawJudgeOutput: {
+        semantic: semantic.rawJudgeOutput,
+        rules: {
+          score: rules.score,
+          failures: rules.failures,
+          criteria: rules.criteria
+        }
+      }
+    };
+  }
+};
+function mergeFailures(existing, candidates) {
+  const seen = new Set(existing.map((failure) => `${failure.type}:${failure.message}`));
+  return candidates.filter((failure) => !seen.has(`${failure.type}:${failure.message}`));
+}
+function mergeCriteria(existing, candidates) {
+  const seen = new Set(existing.map((criterion) => criterion.criterion));
+  return candidates.filter((criterion) => criterion.result === "failed" && !seen.has(criterion.criterion));
 }
 
 // src/providers/user-simulator/llm-user-simulator.ts
@@ -1034,6 +1103,7 @@ ${redactSecrets(
 - Run ID: ${safeReport.runId}
 - Status: ${safeReport.status}
 - Score: ${safeReport.score}/100
+- Evaluation: ${evaluationSummary(safeReport)}
 - Started: ${safeReport.startedAt}
 - Ended: ${safeReport.endedAt}
 
@@ -1059,6 +1129,14 @@ ${safeReport.recommendations.length ? safeReport.recommendations.map((item) => `
 ${safeTurns}
 `;
 }
+function evaluationSummary(report) {
+  const metadata = report.judgeMetadata;
+  if (!metadata) return "not recorded";
+  const provider = metadata.provider ? ` via ${metadata.provider}` : "";
+  const model = metadata.model ? ` (${metadata.model})` : "";
+  const rules = metadata.rulesApplied ? `, deterministic guardrails applied${metadata.deterministicFindingsAdded ? `, ${metadata.deterministicFindingsAdded} added finding(s)` : ""}` : "";
+  return `${metadata.mode}${provider}${model}${rules}`;
+}
 
 // src/core/engine.ts
 async function runScenario(options) {
@@ -1067,7 +1145,7 @@ async function runScenario(options) {
   const maxTurns = options.maxTurns ?? scenario.simulation.maxTurns;
   const paths = await createRunPaths(options.outDir);
   const transcript = createTranscript(paths.runId, scenario.name);
-  const defaultProvider = scenario.target.type === "mock" ? "mock" : "openai";
+  const defaultProvider = scenario.target.type === "mock" ? "mock" : void 0;
   const scenarioJudgeProvider = scenario.judge.type === "mock" ? defaultProvider : scenario.judge.type;
   const scenarioAttackerProvider = scenario.attacker?.provider ?? scenarioJudgeProvider;
   const attackerProvider = options.attackerProvider ?? scenarioAttackerProvider;
@@ -1079,6 +1157,7 @@ async function runScenario(options) {
   });
   const target = createTargetAgent(scenario.target, { allowCliExecution: options.yes });
   const judge = createJudge({
+    mode: options.judgeMode,
     provider: judgeProvider,
     model: options.judgeModel ?? scenario.judge.model,
     baseUrl: options.llmBaseUrl ?? scenario.judge.baseUrl
@@ -1130,6 +1209,13 @@ async function runScenario(options) {
       ],
       startedAt: transcript.startedAt,
       endedAt: transcript.endedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      judgeMetadata: {
+        mode: options.judgeMode ?? (judgeProvider && judgeProvider !== "mock" ? "semantic" : "rules"),
+        provider: judgeProvider,
+        model: options.judgeModel ?? scenario.judge.model,
+        rulesApplied: options.judgeMode !== "semantic",
+        deterministicFindingsAdded: 0
+      },
       rawJudgeOutput: appError.toJSON()
     };
     const markdown = generateMarkdownReport(report, transcript);
@@ -1151,6 +1237,13 @@ var failureSchema2 = z4.object({
   severity: z4.enum(["low", "medium", "high", "critical"]),
   message: requiredString("run.report.failures[].message is required")
 }).strict();
+var judgeMetadataSchema = z4.object({
+  mode: z4.enum(["rules", "semantic", "hybrid"]),
+  provider: z4.string().optional(),
+  model: z4.string().optional(),
+  rulesApplied: z4.boolean().default(false),
+  deterministicFindingsAdded: z4.number().int().nonnegative().default(0)
+}).strict();
 var reportSchema = z4.object({
   runId: requiredString("run.report.runId is required"),
   scenario: requiredString("run.report.scenario is required"),
@@ -1162,6 +1255,7 @@ var reportSchema = z4.object({
   recommendations: z4.array(z4.string()),
   startedAt: requiredString("run.report.startedAt is required"),
   endedAt: requiredString("run.report.endedAt is required"),
+  judgeMetadata: judgeMetadataSchema.optional(),
   rawJudgeOutput: z4.unknown().optional()
 }).strict();