jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/motivation-source/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const motivationSourceVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
     intrinsic: "intrinsic";
     extrinsic: "extrinsic";
-    unclear: "unclear";
     mixed: "mixed";
     not_stated: "not_stated";
 }>;
@@ -23,17 +23,17 @@ export declare const motivationSourceResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
+        unclear: "unclear";
         intrinsic: "intrinsic";
         extrinsic: "extrinsic";
-        unclear: "unclear";
         mixed: "mixed";
         not_stated: "not_stated";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
         intrinsic: "intrinsic";
         extrinsic: "extrinsic";
-        unclear: "unclear";
         mixed: "mixed";
         not_stated: "not_stated";
     }>, z.ZodNumber>;

package/dist/recipes/move-explanation-fit/demo.json

@@ -0,0 +1,13 @@
+{
+  "input": {
+    "move": "Knight from g1 to f3",
+    "explanation": "Developing the knight to f3 defends the pawn on e4 against the black knight's threat and prepares to castle kingside.",
+    "state": "Chess, White to move. White pieces: king e1, queen d1, rooks a1 and h1, bishops c1 and f1, knights b1 and g1, pawns a2 b2 c2 d2 e2 f2 g2 h2. Black pieces: king e8, queen d8, rooks a8 and h8, bishops c8 and f8, knights b8 and f6, pawns a7 b7 c7 d7 e7 f7 g7 h7. Move 2: Black has just played knight g8 to f6.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.07 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/move-explanation-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MoveExplanationFitInput, MoveExplanationFitResult } from './schema.js';
+export declare function moveExplanationFit(input: MoveExplanationFitInput, options?: RecipeOptions): Promise<MoveExplanationFitResult>;
+export { moveExplanationFitInputSchema, moveExplanationFitResultSchema, moveExplanationFitVerdictSchema, } from './schema.js';
+export type { MoveExplanationFitInput, MoveExplanationFitResult, MoveExplanationFitVerdict, } from './schema.js';

package/dist/recipes/move-explanation-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { moveExplanationFitInputSchema, moveExplanationFitResultSchema } from './schema.js';
+export async function moveExplanationFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = moveExplanationFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does explanation give a reason for move that is consistent with state? Check that the pieces, positions, threats, resources, and turn order that explanation relies on are actually present in state, and that the reason it gives actually concerns move rather than a different action. Treat the explanation as consistent when every fact it cites can be found in state and the reasoning connects to move. Treat it as inconsistent when it cites something absent from or contradicted by state, or when it justifies a different move. Do not judge whether move is a good move.', {
+        true: 'Every fact the explanation relies on is present in the state as described, and the reasoning given is about the move in question.',
+        false: 'The explanation cites a piece, position, threat, or resource that the state does not contain or contradicts, or its reasoning justifies a different move.',
+    }, options);
+    return moveExplanationFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'consistent' : 'inconsistent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { moveExplanationFitInputSchema, moveExplanationFitResultSchema, moveExplanationFitVerdictSchema, } from './schema.js';

package/dist/recipes/move-explanation-fit/schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const moveExplanationFitVerdictSchema: z.ZodEnum<{
+    consistent: "consistent";
+    inconsistent: "inconsistent";
+}>;
+export declare const moveExplanationFitInputSchema: z.ZodObject<{
+    move: z.ZodString;
+    explanation: z.ZodString;
+    state: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const moveExplanationFitResultSchema: 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";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        consistent: "consistent";
+        inconsistent: "inconsistent";
+    }>;
+}, z.core.$strip>;
+export type MoveExplanationFitVerdict = z.infer<typeof moveExplanationFitVerdictSchema>;
+export type MoveExplanationFitInput = z.infer<typeof moveExplanationFitInputSchema>;
+export type MoveExplanationFitResult = z.infer<typeof moveExplanationFitResultSchema>;

package/dist/recipes/move-explanation-fit/schema.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const moveExplanationFitVerdictSchema = z.enum(['consistent', 'inconsistent']);
+export const moveExplanationFitInputSchema = z.object({
+    move: nonEmptyText,
+    explanation: nonEmptyText,
+    state: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const moveExplanationFitResultSchema = gateResultSchema.extend({
+    verdict: moveExplanationFitVerdictSchema,
+});

package/dist/recipes/narrative-consistency/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "narrative": "I was at the office all afternoon on Thursday and got home around 7 pm to find the kitchen flooded. The dishwasher supply hose had split. I heard the hose burst at about 2 pm and shut off the water right away, so the water only ran for a few minutes. Even so, the water reached the hallway and the two bedrooms, and the flooring in all three rooms will need replacing. Nothing outside the kitchen was affected.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.07 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/narrative-consistency/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NarrativeConsistencyInput, NarrativeConsistencyResult } from './schema.js';
+export declare function narrativeConsistency(input: NarrativeConsistencyInput, options?: RecipeOptions): Promise<NarrativeConsistencyResult>;
+export { narrativeConsistencyInputSchema, narrativeConsistencyResultSchema, narrativeConsistencyVerdictSchema, } from './schema.js';
+export type { NarrativeConsistencyInput, NarrativeConsistencyResult, NarrativeConsistencyVerdict, } from './schema.js';

package/dist/recipes/narrative-consistency/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { narrativeConsistencyInputSchema, narrativeConsistencyResultSchema } from './schema.js';
+export async function narrativeConsistency(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = narrativeConsistencyInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Judge whether the statements in narrative are consistent with one another. Look for contradictions in the sequence or timing of events, in what is said to have caused what, and in the extent or amount of what happened. Treat the narrative as the only source: do not compare it against outside facts, and do not treat vagueness or missing detail as a contradiction.', {
+        true: 'No statement in the narrative contradicts another; the timeline, causes, and extents described can all be true at once.',
+        false: 'At least two statements in the narrative cannot both be true, such as an event placed at two incompatible times, a cause that conflicts with the described sequence, or an extent stated two different ways.',
+    }, options);
+    return narrativeConsistencyResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'consistent' : 'contradictory',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { narrativeConsistencyInputSchema, narrativeConsistencyResultSchema, narrativeConsistencyVerdictSchema, } from './schema.js';

package/dist/recipes/narrative-consistency/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const narrativeConsistencyVerdictSchema: z.ZodEnum<{
+    consistent: "consistent";
+    contradictory: "contradictory";
+}>;
+export declare const narrativeConsistencyInputSchema: z.ZodObject<{
+    narrative: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const narrativeConsistencyResultSchema: 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";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        consistent: "consistent";
+        contradictory: "contradictory";
+    }>;
+}, z.core.$strip>;
+export type NarrativeConsistencyVerdict = z.infer<typeof narrativeConsistencyVerdictSchema>;
+export type NarrativeConsistencyInput = z.infer<typeof narrativeConsistencyInputSchema>;
+export type NarrativeConsistencyResult = z.infer<typeof narrativeConsistencyResultSchema>;

package/dist/recipes/narrative-consistency/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const narrativeConsistencyVerdictSchema = z.enum(['consistent', 'contradictory']);
+export const narrativeConsistencyInputSchema = z.object({
+    narrative: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const narrativeConsistencyResultSchema = gateResultSchema.extend({
+    verdict: narrativeConsistencyVerdictSchema,
+});

package/dist/recipes/next-chord/demo.json

@@ -0,0 +1,29 @@
+{
+  "input": {
+    "progression": "C - Am - F - G",
+    "key": "C major",
+    "style": "pop ballad, end of the first verse",
+    "candidates": [
+      { "id": "c", "text": "C (return to the tonic)" },
+      { "id": "am", "text": "Am (deceptive move to the submediant)" }
+    ],
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "candidate_0",
+        "confidence": 0.88,
+        "probabilities": {
+          "candidate_0": 0.88,
+          "candidate_1": 0.08,
+          "none": 0.02,
+          "ambiguous": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/next-chord/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NextChordInput, NextChordResult } from './schema.js';
+export declare function nextChord(input: NextChordInput, options?: RecipeOptions): Promise<NextChordResult>;
+export { nextChordInputSchema, nextChordResultSchema } from './schema.js';
+export type { NextChordInput, NextChordResult } from './schema.js';

package/dist/recipes/next-chord/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { nextChordInputSchema } from './schema.js';
+export async function nextChord(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = nextChordInputSchema.parse(input);
+    return selectCandidate(state, state.candidates, 'Which candidate in candidates best continues progression, given key and style when they are supplied? Judge the harmonic function the last chord of progression sets up, whether each candidate resolves, prolongs, or sidesteps that expectation, and which move a listener in the stated style would find most convincing at this point. Choose none when holding the current chord or resting is the most musical continuation. Choose ambiguous when several candidates fit equally well. Do not compute key membership or voice leading; judge the harmonic sense of what is described.', minConfidence, options);
+}
+export { nextChordInputSchema, nextChordResultSchema } from './schema.js';

package/dist/recipes/next-chord/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const nextChordInputSchema: z.ZodObject<{
+    progression: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    key: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const nextChordResultSchema: 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<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NextChordInput = z.infer<typeof nextChordInputSchema>;
+export type NextChordResult = z.infer<typeof nextChordResultSchema>;

package/dist/recipes/next-chord/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const nextChordInputSchema = z.object({
+    progression: nonEmptyText,
+    candidates: textItemsSchema,
+    key: nonEmptyText.optional(),
+    style: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const nextChordResultSchema = selectionResultSchema;

package/dist/recipes/next-duration/demo.json

@@ -0,0 +1,29 @@
+{
+  "input": {
+    "meter": "3/4",
+    "recentRhythm": "quarter quarter quarter | quarter quarter",
+    "style": "steady waltz accompaniment",
+    "candidates": [
+      { "id": "quarter", "text": "quarter note (keeps the one-two-three)" },
+      { "id": "half", "text": "half note (held across the bar line)" }
+    ],
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "candidate_0",
+        "confidence": 0.9,
+        "probabilities": {
+          "candidate_0": 0.9,
+          "candidate_1": 0.05,
+          "none": 0.03,
+          "ambiguous": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/next-duration/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NextDurationInput, NextDurationResult } from './schema.js';
+export declare function nextDuration(input: NextDurationInput, options?: RecipeOptions): Promise<NextDurationResult>;
+export { nextDurationInputSchema, nextDurationResultSchema } from './schema.js';
+export type { NextDurationInput, NextDurationResult } from './schema.js';

package/dist/recipes/next-duration/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { nextDurationInputSchema } from './schema.js';
+export async function nextDuration(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = nextDurationInputSchema.parse(input);
+    return selectCandidate(state, state.candidates, 'Which candidate in candidates best continues recentRhythm within meter, given style when it is supplied? Judge the pulse and subdivision recentRhythm has established, whether each candidate keeps, completes, or breaks that pattern, and which choice a listener in the stated style would find most natural at this point in the bar. Choose none when a rest is the most musical continuation. Choose ambiguous when several candidates fit equally well. Do not add up beats or check bar arithmetic; judge the rhythmic sense of what is described.', minConfidence, options);
+}
+export { nextDurationInputSchema, nextDurationResultSchema } from './schema.js';

package/dist/recipes/next-duration/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const nextDurationInputSchema: z.ZodObject<{
+    meter: z.ZodString;
+    recentRhythm: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    style: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const nextDurationResultSchema: 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<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NextDurationInput = z.infer<typeof nextDurationInputSchema>;
+export type NextDurationResult = z.infer<typeof nextDurationResultSchema>;

package/dist/recipes/next-duration/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const nextDurationInputSchema = z.object({
+    meter: nonEmptyText,
+    recentRhythm: nonEmptyText,
+    candidates: textItemsSchema,
+    style: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const nextDurationResultSchema = selectionResultSchema;

package/dist/recipes/next-note/demo.json

@@ -0,0 +1,29 @@
+{
+  "input": {
+    "recentNotes": "C4 E4 G4 E4 D4",
+    "key": "C major",
+    "style": "gentle lullaby",
+    "candidates": [
+      { "id": "c5", "text": "C5 (octave leap up to the tonic)" },
+      { "id": "b3", "text": "B3 (leading tone just below)" }
+    ],
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "candidate_1",
+        "confidence": 0.9,
+        "probabilities": {
+          "candidate_0": 0.05,
+          "candidate_1": 0.9,
+          "none": 0.03,
+          "ambiguous": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/next-note/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NextNoteInput, NextNoteResult } from './schema.js';
+export declare function nextNote(input: NextNoteInput, options?: RecipeOptions): Promise<NextNoteResult>;
+export { nextNoteInputSchema, nextNoteResultSchema } from './schema.js';
+export type { NextNoteInput, NextNoteResult } from './schema.js';

package/dist/recipes/next-note/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { nextNoteInputSchema } from './schema.js';
+export async function nextNote(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = nextNoteInputSchema.parse(input);
+    return selectCandidate(state, state.candidates, 'Which candidate in candidates best continues the melody in recentNotes, given key and style when they are supplied? Judge the contour of recentNotes, the size of the interval each candidate would create, whether it extends or answers the motif, and where the phrase seems to be heading, and prefer the candidate a listener in the stated style would find most natural. Choose none when a rest or silence would be the most musical continuation. Choose ambiguous when several candidates fit equally well. Do not compute scale membership or interval arithmetic; judge the musical sense of what is described.', minConfidence, options);
+}
+export { nextNoteInputSchema, nextNoteResultSchema } from './schema.js';

package/dist/recipes/next-note/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const nextNoteInputSchema: z.ZodObject<{
+    recentNotes: z.ZodString;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    key: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const nextNoteResultSchema: 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<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NextNoteInput = z.infer<typeof nextNoteInputSchema>;
+export type NextNoteResult = z.infer<typeof nextNoteResultSchema>;

package/dist/recipes/next-note/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const nextNoteInputSchema = z.object({
+    recentNotes: nonEmptyText,
+    candidates: textItemsSchema,
+    key: nonEmptyText.optional(),
+    style: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const nextNoteResultSchema = selectionResultSchema;

package/dist/recipes/notice-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "notice": "County Housing Assistance Program\nNotice of Missing Documentation\n\nCase number: HA-2026-44817\n\nDear Ms. Okafor,\n\nWe are reviewing your application for rental assistance. To continue processing it, we need a copy of your most recent 30 days of pay stubs and a signed copy of your current lease.\n\nPlease submit these documents by October 10, 2026. You may upload them through the resident portal or bring them to our office at 300 Civic Center Drive, Suite 110, Monday through Friday, 8:30 AM to 4:30 PM.\n\nIf we do not receive the documents by that date, your application will be closed and you will need to reapply.\n\nIf you have questions, call your case worker, Daniel Ruiz, at (555) 014-2270.\n\nSincerely,\nCounty Housing Assistance Program",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesAction": { "type": "noul", "noul": 0.98 },
+      "statesDeadline": { "type": "noul", "noul": 0.97 },
+      "statesConsequence": { "type": "noul", "noul": 0.96 },
+      "statesContact": { "type": "noul", "noul": 0.95 },
+      "statesAppealRight": { "type": "noul", "noul": 0.04 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/notice-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NoticeFacetsInput, NoticeFacetsResult } from './schema.js';
+export declare function noticeFacets(input: NoticeFacetsInput, options?: RecipeOptions): Promise<NoticeFacetsResult>;
+export { noticeFacetsInputSchema, noticeFacetsResultSchema, noticeFacetsLabelSchema, } from './schema.js';
+export type { NoticeFacetsInput, NoticeFacetsResult, NoticeFacetsLabel } from './schema.js';

package/dist/recipes/notice-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { noticeFacetsInputSchema, noticeFacetsResultSchema } from './schema.js';
+export async function noticeFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = noticeFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesAction: {
+            instruction: 'Does notice tell the recipient something they must or should do, such as submit documents, pay, respond, or attend?',
+            criteria: {
+                true: 'The text names a specific action the recipient is asked or required to take.',
+                false: 'The text informs the recipient of something without asking them to do anything.',
+            },
+        },
+        statesDeadline: {
+            instruction: 'Does notice state a date or time period by which the recipient must act?',
+            criteria: {
+                true: 'The text gives a date, or a number of days from a stated event, by which something must happen.',
+                false: 'The text sets no date or period for the recipient to act.',
+            },
+        },
+        statesConsequence: {
+            instruction: 'Does notice state what will happen if the recipient does not act?',
+            criteria: {
+                true: 'The text describes an outcome that follows from not acting, such as denial, termination, a penalty, or a default decision.',
+                false: 'The text does not say what happens if the recipient does nothing.',
+            },
+        },
+        statesContact: {
+            instruction: 'Does notice give a way to reach someone with questions, such as a phone number, email address, office, or case worker?',
+            criteria: {
+                true: 'The text gives a phone number, email address, office location, web portal, or named person to contact.',
+                false: 'The text gives no way to reach anyone with questions.',
+            },
+        },
+        statesAppealRight: {
+            instruction: 'Does notice tell the recipient they may appeal, request a hearing, or otherwise contest the decision?',
+            criteria: {
+                true: 'The text mentions a right to appeal, request a hearing, request reconsideration, or otherwise contest the decision, with or without instructions.',
+                false: 'The text does not mention any way to contest the decision.',
+            },
+        },
+    }, options);
+    return noticeFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { noticeFacetsInputSchema, noticeFacetsResultSchema, noticeFacetsLabelSchema, } from './schema.js';