jev-recipes 0.2.0 → 0.4.0

package/dist/recipes/citation-needed/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const citationNeededVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
     needed: "needed";
+    unclear: "unclear";
     unnecessary: "unnecessary";
 }>;
 export declare const citationNeededInputSchema: z.ZodObject<{
@@ -20,14 +20,14 @@ export declare const citationNeededResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
         needed: "needed";
+        unclear: "unclear";
         unnecessary: "unnecessary";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
         needed: "needed";
+        unclear: "unclear";
         unnecessary: "unnecessary";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/claim-stance/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "claim": "The report says all tests passed.",
+    "response": "No. The report lists two failing tests."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "denies",
+        "confidence": 0.96,
+        "probabilities": {
+          "affirms": 0.01,
+          "denies": 0.96,
+          "mixed": 0.01,
+          "not_addressed": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/claim-stance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClaimStanceInput, ClaimStanceResult } from './schema.js';
+export declare function claimStance(input: ClaimStanceInput, options?: RecipeOptions): Promise<ClaimStanceResult>;
+export { claimStanceInputSchema, claimStanceResultSchema, claimStanceVerdictSchema, } from './schema.js';
+export type { ClaimStanceInput, ClaimStanceResult, ClaimStanceVerdict } from './schema.js';

package/dist/recipes/claim-stance/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { claimStanceInputSchema, claimStanceResultSchema } from './schema.js';
+export async function claimStance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = claimStanceInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "What position does response itself express toward claim, interpreted using context? Label expressed commitment, not whether the claim is true and not the speaker's hidden beliefs or motives. Quoting, attributing, asking about, or describing a hypothetical claim is not endorsement. Polite acknowledgment of a person is not agreement with the claim. Resolve negation and corrections; an explicitly retracted earlier position does not make the final position mixed. Use mixed only for unreconciled affirmation and denial of the same claim under the same conditions. Expressed uncertainty about the claim is unclear, not not_addressed. Do not turn this label into a judgment of sycophancy or deception.", {
+        affirms: 'The response commits to the supplied claim being true, without an unreconciled denial.',
+        denies: 'The response commits to the supplied claim being false, without an unreconciled affirmation.',
+        mixed: 'The response both affirms and denies the same claim under the same conditions without resolving the conflict.',
+        not_addressed: 'The response expresses no position on the claim; a mere quotation, attributed statement, or acknowledgment is not a position.',
+        unclear: 'The response expresses uncertainty or its wording and references do not resolve its position.',
+    }, options);
+    return claimStanceResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { claimStanceInputSchema, claimStanceResultSchema, claimStanceVerdictSchema, } from './schema.js';

package/dist/recipes/claim-stance/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const claimStanceVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    affirms: "affirms";
+    denies: "denies";
+    mixed: "mixed";
+    not_addressed: "not_addressed";
+}>;
+export declare const claimStanceInputSchema: z.ZodObject<{
+    claim: z.ZodString;
+    response: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const claimStanceResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        unclear: "unclear";
+        affirms: "affirms";
+        denies: "denies";
+        mixed: "mixed";
+        not_addressed: "not_addressed";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        affirms: "affirms";
+        denies: "denies";
+        mixed: "mixed";
+        not_addressed: "not_addressed";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ClaimStanceInput = z.infer<typeof claimStanceInputSchema>;
+export type ClaimStanceResult = z.infer<typeof claimStanceResultSchema>;
+export type ClaimStanceVerdict = z.infer<typeof claimStanceVerdictSchema>;

package/dist/recipes/claim-stance/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const claimStanceVerdictSchema = z.enum([
+    'affirms',
+    'denies',
+    'mixed',
+    'not_addressed',
+    'unclear',
+]);
+export const claimStanceInputSchema = z.object({
+    claim: nonEmptyText.describe('One proposition whose stance should be labeled; its truth is evaluated separately.'),
+    response: nonEmptyText.describe('The response whose expressed position should be labeled.'),
+    context: nonEmptyText
+        .describe('Supplied context needed to resolve references in the response.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const claimStanceResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: claimStanceVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(claimStanceVerdictSchema, probability),
+});

package/dist/recipes/clarify/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const requirementVerdictSchema: z.ZodEnum<{
     ambiguous: "ambiguous";
-    present: "present";
     missing: "missing";
+    present: "present";
 }>;
 export declare const clarifyRequirementSchema: z.ZodObject<{
     id: z.ZodString;
@@ -38,14 +38,14 @@ export declare const clarifyResultSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             ambiguous: "ambiguous";
-            present: "present";
             missing: "missing";
+            present: "present";
         }>;
         confidence: z.ZodNumber;
         probabilities: z.ZodRecord<z.ZodEnum<{
             ambiguous: "ambiguous";
-            present: "present";
             missing: "missing";
+            present: "present";
         }>, z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/recipes/constraint-strength/demo.json

@@ -0,0 +1,25 @@
+{
+  "input": {
+    "statement": "Prefer a CSV export, but JSON is fine if that is easier."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "preferred",
+        "confidence": 0.96,
+        "probabilities": {
+          "required": 0.013333333333333334,
+          "preferred": 0.96,
+          "optional": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

package/dist/recipes/constraint-strength/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ConstraintStrengthInput, ConstraintStrengthResult } from './schema.js';
+export declare function constraintStrength(input: ConstraintStrengthInput, options?: RecipeOptions): Promise<ConstraintStrengthResult>;
+export { constraintStrengthInputSchema, constraintStrengthResultSchema, constraintStrengthVerdictSchema, } from './schema.js';
+export type { ConstraintStrengthInput, ConstraintStrengthResult, ConstraintStrengthVerdict, } from './schema.js';

package/dist/recipes/constraint-strength/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { constraintStrengthInputSchema, constraintStrengthResultSchema } from './schema.js';
+export async function constraintStrength(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = constraintStrengthInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How binding is the single constraint expressed by statement in context? Interpret the expressed wording and qualifications, not hidden intent or keyword matches alone. A prohibition can be required. A stated preference is preferred when alternatives remain acceptable; optional requires explicit discretion with no stated preference. A condition describes when a constraint applies and does not by itself make the constraint optional. Do not infer authority, permission, consent, or a lasting user preference. Choose unclear for unresolved mixed constraints, hypothetical wording, or text that does not establish a constraint.', {
+        required: 'The statement presents an obligation or prohibition that must be met whenever its stated condition applies.',
+        preferred: 'The statement favors an outcome but explicitly or unambiguously allows alternatives.',
+        optional: 'The statement explicitly leaves the choice open without favoring an outcome.',
+        unclear: 'The wording or context does not establish one constraint with a clear level of obligation.',
+    }, options);
+    return constraintStrengthResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { constraintStrengthInputSchema, constraintStrengthResultSchema, constraintStrengthVerdictSchema, } from './schema.js';

package/dist/recipes/constraint-strength/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const constraintStrengthVerdictSchema: z.ZodEnum<{
+    optional: "optional";
+    unclear: "unclear";
+    required: "required";
+    preferred: "preferred";
+}>;
+export declare const constraintStrengthInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const constraintStrengthResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        optional: "optional";
+        unclear: "unclear";
+        required: "required";
+        preferred: "preferred";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        optional: "optional";
+        unclear: "unclear";
+        required: "required";
+        preferred: "preferred";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ConstraintStrengthInput = z.infer<typeof constraintStrengthInputSchema>;
+export type ConstraintStrengthResult = z.infer<typeof constraintStrengthResultSchema>;
+export type ConstraintStrengthVerdict = z.infer<typeof constraintStrengthVerdictSchema>;

package/dist/recipes/constraint-strength/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const constraintStrengthVerdictSchema = z.enum([
+    'required',
+    'preferred',
+    'optional',
+    'unclear',
+]);
+export const constraintStrengthInputSchema = z.object({
+    statement: nonEmptyText.describe('One constraint or preference to interpret.'),
+    context: nonEmptyText
+        .describe('The surrounding request and any qualifications that clarify its force.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const constraintStrengthResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: constraintStrengthVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(constraintStrengthVerdictSchema, probability),
+});

package/dist/recipes/document-role/schema.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare const documentRoleVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
-    other: "other";
     reference: "reference";
     troubleshooting: "troubleshooting";
+    unclear: "unclear";
     policy: "policy";
     tutorial: "tutorial";
     release_note: "release_note";
+    other: "other";
 }>;
 export declare const documentRoleInputSchema: z.ZodObject<{
     document: z.ZodString;
@@ -23,23 +23,23 @@ export declare const documentRoleResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
-        other: "other";
         reference: "reference";
         troubleshooting: "troubleshooting";
+        unclear: "unclear";
         policy: "policy";
         tutorial: "tutorial";
         release_note: "release_note";
+        other: "other";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
-        other: "other";
         reference: "reference";
         troubleshooting: "troubleshooting";
+        unclear: "unclear";
         policy: "policy";
         tutorial: "tutorial";
         release_note: "release_note";
+        other: "other";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type DocumentRoleInput = z.infer<typeof documentRoleInputSchema>;

package/dist/recipes/evidence-conflict/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const evidenceConflictVerdictSchema: z.ZodEnum<{
-    conflicting: "conflicting";
-    unclear: "unclear";
     compatible: "compatible";
+    unclear: "unclear";
+    conflicting: "conflicting";
     different_scope: "different_scope";
 }>;
 export declare const evidenceConflictInputSchema: z.ZodObject<{
@@ -22,16 +22,16 @@ export declare const evidenceConflictResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        conflicting: "conflicting";
-        unclear: "unclear";
         compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
         different_scope: "different_scope";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        conflicting: "conflicting";
-        unclear: "unclear";
         compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
         different_scope: "different_scope";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/feedback-kind/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const feedbackKindVerdictSchema: z.ZodEnum<{
-    question: "question";
     unclear: "unclear";
+    question: "question";
     other: "other";
     bug_report: "bug_report";
     feature_request: "feature_request";
@@ -24,8 +24,8 @@ export declare const feedbackKindResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        question: "question";
         unclear: "unclear";
+        question: "question";
         other: "other";
         bug_report: "bug_report";
         feature_request: "feature_request";
@@ -34,8 +34,8 @@ export declare const feedbackKindResultSchema: z.ZodObject<{
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        question: "question";
         unclear: "unclear";
+        question: "question";
         other: "other";
         bug_report: "bug_report";
         feature_request: "feature_request";

package/dist/recipes/freshness-needed/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const freshnessNeededVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
-    current: "current";
     stable: "stable";
+    current: "current";
 }>;
 export declare const freshnessNeededInputSchema: z.ZodObject<{
     question: z.ZodString;
@@ -20,14 +20,14 @@ export declare const freshnessNeededResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
-        current: "current";
         stable: "stable";
+        current: "current";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
-        current: "current";
         stable: "stable";
+        current: "current";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type FreshnessNeededInput = z.infer<typeof freshnessNeededInputSchema>;

package/dist/recipes/handoff/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const handoffVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
     matches: "matches";
     does_not_match: "does_not_match";
-    unclear: "unclear";
 }>;
 export declare const handoffRuleSchema: z.ZodObject<{
     id: z.ZodString;
@@ -41,15 +41,15 @@ export declare const handoffResultSchema: z.ZodObject<{
             review: "review";
         }>;
         verdict: z.ZodEnum<{
+            unclear: "unclear";
             matches: "matches";
             does_not_match: "does_not_match";
-            unclear: "unclear";
         }>;
         confidence: z.ZodNumber;
         probabilities: z.ZodRecord<z.ZodEnum<{
+            unclear: "unclear";
             matches: "matches";
             does_not_match: "does_not_match";
-            unclear: "unclear";
         }>, z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/recipes/instruction-conflict/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "firstInstruction": "Send the report as a PDF attachment.",
+    "secondInstruction": "Send the report only as plain text in the email body; do not attach any files.",
+    "context": "Both instructions apply to the same outgoing report email."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "conflicting",
+        "confidence": 0.96,
+        "probabilities": {
+          "compatible": 0.013333333333333334,
+          "conflicting": 0.96,
+          "different_scope": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

package/dist/recipes/instruction-conflict/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { InstructionConflictInput, InstructionConflictResult } from './schema.js';
+export declare function instructionConflict(input: InstructionConflictInput, options?: RecipeOptions): Promise<InstructionConflictResult>;
+export { instructionConflictInputSchema, instructionConflictResultSchema, instructionConflictVerdictSchema, } from './schema.js';
+export type { InstructionConflictInput, InstructionConflictResult, InstructionConflictVerdict, } from './schema.js';

package/dist/recipes/instruction-conflict/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { instructionConflictInputSchema, instructionConflictResultSchema } from './schema.js';
+export async function instructionConflict(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = instructionConflictInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Can firstInstruction and secondInstruction both be followed in context? Compare their required behavior, including prohibitions, conditions, and exceptions. A preference is not a mandatory requirement. Different wording is not a conflict. Choose conflicting only when applicable requirements cannot both be followed under the same supplied circumstances. Do not choose which instruction wins or infer authority from its wording. If their applicable scope is unresolved, choose unclear.', {
+        compatible: 'The instructions share an applicable scope and their requirements can both be followed.',
+        conflicting: 'Both instructions apply under the same supplied circumstances and require mutually incompatible behavior.',
+        different_scope: 'The instructions explicitly apply to separate circumstances, so their requirements do not compete.',
+        unclear: 'Their meaning, scope, or conditions leave it unresolved whether both can be followed.',
+    }, options);
+    return instructionConflictResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { instructionConflictInputSchema, instructionConflictResultSchema, instructionConflictVerdictSchema, } from './schema.js';

package/dist/recipes/instruction-conflict/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const instructionConflictVerdictSchema: z.ZodEnum<{
+    compatible: "compatible";
+    unclear: "unclear";
+    conflicting: "conflicting";
+    different_scope: "different_scope";
+}>;
+export declare const instructionConflictInputSchema: z.ZodObject<{
+    firstInstruction: z.ZodString;
+    secondInstruction: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const instructionConflictResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
+        different_scope: "different_scope";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        compatible: "compatible";
+        unclear: "unclear";
+        conflicting: "conflicting";
+        different_scope: "different_scope";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type InstructionConflictInput = z.infer<typeof instructionConflictInputSchema>;
+export type InstructionConflictResult = z.infer<typeof instructionConflictResultSchema>;
+export type InstructionConflictVerdict = z.infer<typeof instructionConflictVerdictSchema>;

package/dist/recipes/instruction-conflict/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const instructionConflictVerdictSchema = z.enum([
+    'compatible',
+    'conflicting',
+    'different_scope',
+    'unclear',
+]);
+export const instructionConflictInputSchema = z.object({
+    firstInstruction: nonEmptyText.describe('The first instruction to compare.'),
+    secondInstruction: nonEmptyText.describe('The second instruction to compare.'),
+    context: nonEmptyText
+        .describe('The task and circumstances in which the instructions may apply.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const instructionConflictResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: instructionConflictVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(instructionConflictVerdictSchema, probability),
+});

package/dist/recipes/passage-duplicate/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const passageDuplicateVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
     duplicate: "duplicate";
+    unclear: "unclear";
     overlapping: "overlapping";
     distinct: "distinct";
 }>;
@@ -21,15 +21,15 @@ export declare const passageDuplicateResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
         duplicate: "duplicate";
+        unclear: "unclear";
         overlapping: "overlapping";
         distinct: "distinct";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
         duplicate: "duplicate";
+        unclear: "unclear";
         overlapping: "overlapping";
         distinct: "distinct";
     }>, z.ZodNumber>;

package/dist/recipes/preference-kind/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const preferenceKindVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
-    fact: "fact";
     preference: "preference";
+    fact: "fact";
+    unclear: "unclear";
     temporary_request: "temporary_request";
 }>;
 export declare const preferenceKindInputSchema: z.ZodObject<{
@@ -21,16 +21,16 @@ export declare const preferenceKindResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
-        fact: "fact";
         preference: "preference";
+        fact: "fact";
+        unclear: "unclear";
         temporary_request: "temporary_request";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
-        fact: "fact";
         preference: "preference";
+        fact: "fact";
+        unclear: "unclear";
         temporary_request: "temporary_request";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/promise-check/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const promiseCheckVerdictSchema: z.ZodEnum<{
-    unsupported: "unsupported";
     unclear: "unclear";
+    unsupported: "unsupported";
     within_commitments: "within_commitments";
 }>;
 export declare const promiseCheckInputSchema: z.ZodObject<{
@@ -20,14 +20,14 @@ export declare const promiseCheckResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unsupported: "unsupported";
         unclear: "unclear";
+        unsupported: "unsupported";
         within_commitments: "within_commitments";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unsupported: "unsupported";
         unclear: "unclear";
+        unsupported: "unsupported";
         within_commitments: "within_commitments";
     }>, z.ZodNumber>;
 }, z.core.$strip>;