jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/product-match/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const productMatchVerdictSchema: z.ZodEnum<{
+    mismatched: "mismatched";
+    matches: "matches";
+}>;
+export declare const productMatchInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    listing: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const productMatchResultSchema: 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<{
+        mismatched: "mismatched";
+        matches: "matches";
+    }>;
+}, z.core.$strip>;
+export type ProductMatchVerdict = z.infer<typeof productMatchVerdictSchema>;
+export type ProductMatchInput = z.infer<typeof productMatchInputSchema>;
+export type ProductMatchResult = z.infer<typeof productMatchResultSchema>;

package/dist/recipes/product-match/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const productMatchVerdictSchema = z.enum(['matches', 'mismatched']);
+export const productMatchInputSchema = z.object({
+    request: nonEmptyText,
+    listing: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const productMatchResultSchema = gateResultSchema.extend({
+    verdict: productMatchVerdictSchema,
+});

package/dist/recipes/progress-stall/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "transcript": "Step 14: ran `npm test` -> 3 failures in date-utils.test.ts (timezone offset). Step 15: opened src/date-utils.ts, read formatDate. Step 16: ran `npm test` -> same 3 failures. Step 17: opened src/date-utils.ts, read formatDate again. Step 18: ran `npm test` -> same 3 failures. Step 19: opened src/date-utils.ts, read formatDate. Step 20: ran `npm test` -> same 3 failures.",
+    "objective": "Make the date-utils test suite pass without changing the expected values in the tests.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.94 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/progress-stall/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ProgressStallInput, ProgressStallResult } from './schema.js';
+export declare function progressStall(input: ProgressStallInput, options?: RecipeOptions): Promise<ProgressStallResult>;
+export { progressStallInputSchema, progressStallResultSchema, progressStallVerdictSchema, } from './schema.js';
+export type { ProgressStallInput, ProgressStallResult, ProgressStallVerdict } from './schema.js';

package/dist/recipes/progress-stall/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { progressStallInputSchema, progressStallResultSchema } from './schema.js';
+export async function progressStall(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = progressStallInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does transcript, the recent steps an agent has taken, show the agent failing to make progress toward objective? Count a stall when the agent repeats the same or near-identical actions, cycles between a small set of states, re-reads or re-derives information it already has, or keeps hitting the same error without changing approach. Do not count a stall when each step adds new information, narrows the problem, or tries a materially different approach, even if objective is not yet reached.', {
+        true: 'The recent steps repeat, circle, or reprocess the same information without moving toward the objective.',
+        false: 'The recent steps each add information or change approach in a way that moves toward the objective.',
+    }, options);
+    return progressStallResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'stalled' : 'progressing',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { progressStallInputSchema, progressStallResultSchema, progressStallVerdictSchema, } from './schema.js';

package/dist/recipes/progress-stall/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const progressStallVerdictSchema: z.ZodEnum<{
+    stalled: "stalled";
+    progressing: "progressing";
+}>;
+export declare const progressStallInputSchema: z.ZodObject<{
+    transcript: z.ZodString;
+    objective: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const progressStallResultSchema: 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<{
+        stalled: "stalled";
+        progressing: "progressing";
+    }>;
+}, z.core.$strip>;
+export type ProgressStallVerdict = z.infer<typeof progressStallVerdictSchema>;
+export type ProgressStallInput = z.infer<typeof progressStallInputSchema>;
+export type ProgressStallResult = z.infer<typeof progressStallResultSchema>;

package/dist/recipes/progress-stall/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const progressStallVerdictSchema = z.enum(['stalled', 'progressing']);
+export const progressStallInputSchema = z.object({
+    transcript: nonEmptyText,
+    objective: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const progressStallResultSchema = gateResultSchema.extend({
+    verdict: progressStallVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "proposal": "Riverbend Youth Literacy Program. In Riverbend County, 38% of third graders read below grade level, and both public library branches ended their after-school programs in 2024, leaving no free reading support outside school hours. We request $48,000 to run a twice-weekly after-school reading program at three elementary schools during the 2026-27 school year. Objectives: enroll 90 students in grades 2 and 3, and raise participants' reading level by at least one grade band by May 2027. Activities: recruit and train 12 volunteer tutors in September; run 60-minute small-group sessions on Tuesdays and Thursdays from October through May; hold a family reading night at each school every quarter. Budget: program coordinator (0.5 FTE) $30,000; books and materials $9,000; tutor training and background checks $4,000; snacks and family nights $5,000.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesNeed": { "type": "noul", "noul": 0.95 },
+      "statesObjectives": { "type": "noul", "noul": 0.91 },
+      "statesActivities": { "type": "noul", "noul": 0.94 },
+      "statesBudget": { "type": "noul", "noul": 0.93 },
+      "statesEvaluation": { "type": "noul", "noul": 0.09 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ProposalFacetsInput, ProposalFacetsResult } from './schema.js';
+export declare function proposalFacets(input: ProposalFacetsInput, options?: RecipeOptions): Promise<ProposalFacetsResult>;
+export { proposalFacetsInputSchema, proposalFacetsResultSchema, proposalFacetsLabelSchema, } from './schema.js';
+export type { ProposalFacetsInput, ProposalFacetsResult, ProposalFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { proposalFacetsInputSchema, proposalFacetsResultSchema } from './schema.js';
+export async function proposalFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = proposalFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesNeed: {
+            instruction: 'Does proposal describe the problem, gap, or population condition that the proposed work addresses?',
+            criteria: {
+                true: 'The proposal describes a specific problem or gap, with or without supporting figures, that the work is meant to address.',
+                false: 'The proposal describes only what it will do or who the applicant is, without saying what problem the work addresses.',
+            },
+        },
+        statesObjectives: {
+            instruction: 'Does proposal state at least one objective with a measurable target, such as a number served, a percentage change, or an observable outcome by a stated point?',
+            criteria: {
+                true: 'The proposal states at least one intended outcome with a number, percentage, or other observable target.',
+                false: 'The proposal states goals only in general terms, such as improving lives or raising awareness, with no measurable target.',
+            },
+        },
+        statesActivities: {
+            instruction: 'Does proposal describe the specific activities the applicant will carry out, such as sessions, services, events, or deliverables?',
+            criteria: {
+                true: 'The proposal names concrete activities the applicant will perform, with at least some detail on what, who, or how often.',
+                false: 'The proposal names no specific activities, or describes the work only as a program or initiative without saying what will be done.',
+            },
+        },
+        statesBudget: {
+            instruction: 'Does proposal give the cost of the work, as a requested amount, a total budget, line items, or a combination?',
+            criteria: {
+                true: 'The proposal states at least one monetary figure for what the work will cost or what is requested.',
+                false: 'The proposal gives no monetary figure for the work.',
+            },
+        },
+        statesEvaluation: {
+            instruction: 'Does proposal say how the applicant will measure or assess whether the objectives were achieved, such as assessments, surveys, data collection, or a comparison?',
+            criteria: {
+                true: 'The proposal describes at least one method, instrument, or data source it will use to judge whether the work achieved its objectives.',
+                false: 'The proposal states objectives or outcomes without saying how their achievement will be measured or assessed.',
+            },
+        },
+    }, options);
+    return proposalFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { proposalFacetsInputSchema, proposalFacetsResultSchema, proposalFacetsLabelSchema, } from './schema.js';

package/dist/recipes/proposal-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const proposalFacetsLabelSchema: z.ZodEnum<{
+    statesBudget: "statesBudget";
+    statesNeed: "statesNeed";
+    statesObjectives: "statesObjectives";
+    statesActivities: "statesActivities";
+    statesEvaluation: "statesEvaluation";
+}>;
+export declare const proposalFacetsInputSchema: z.ZodObject<{
+    proposal: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const proposalFacetsResultSchema: 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";
+    }>;
+    detected: z.ZodArray<z.ZodEnum<{
+        statesBudget: "statesBudget";
+        statesNeed: "statesNeed";
+        statesObjectives: "statesObjectives";
+        statesActivities: "statesActivities";
+        statesEvaluation: "statesEvaluation";
+    }>>;
+    labels: z.ZodObject<{
+        statesNeed: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesObjectives: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesActivities: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesBudget: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesEvaluation: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProposalFacetsLabel = z.infer<typeof proposalFacetsLabelSchema>;
+export type ProposalFacetsInput = z.infer<typeof proposalFacetsInputSchema>;
+export type ProposalFacetsResult = z.infer<typeof proposalFacetsResultSchema>;

package/dist/recipes/proposal-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const proposalFacetsLabelSchema = z.enum([
+    'statesNeed',
+    'statesObjectives',
+    'statesActivities',
+    'statesBudget',
+    'statesEvaluation',
+]);
+export const proposalFacetsInputSchema = z.object({
+    proposal: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const proposalFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(proposalFacetsLabelSchema),
+    labels: z.object({
+        statesNeed: labelCheckSchema,
+        statesObjectives: labelCheckSchema,
+        statesActivities: labelCheckSchema,
+        statesBudget: labelCheckSchema,
+        statesEvaluation: labelCheckSchema,
+    }),
+});

package/dist/recipes/qualification-evidence/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "requirement": "At least three years of experience operating Kubernetes clusters in production.",
+    "profile": "Platform Engineer, Northwind Logistics, 2020 to present. Own the production Kubernetes platform (EKS, 12 clusters, 400 services). Led the migration from self-managed clusters to EKS in 2022 with zero customer-facing downtime. On-call rotation for cluster incidents; wrote the runbooks for node pool upgrades and etcd recovery. Skills: Kubernetes, Terraform, Go, Prometheus.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.94 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/qualification-evidence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QualificationEvidenceInput, QualificationEvidenceResult } from './schema.js';
+export declare function qualificationEvidence(input: QualificationEvidenceInput, options?: RecipeOptions): Promise<QualificationEvidenceResult>;
+export { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema, qualificationEvidenceVerdictSchema, } from './schema.js';
+export type { QualificationEvidenceInput, QualificationEvidenceResult, QualificationEvidenceVerdict, } from './schema.js';

package/dist/recipes/qualification-evidence/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema } from './schema.js';
+export async function qualificationEvidence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = qualificationEvidenceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does profile contain concrete evidence that the candidate meets requirement? Count described work, projects, outcomes, credentials, or durations that demonstrate the requirement in practice. Do not count a bare keyword, a skills-list entry, or a self-description with nothing behind it. Judge only what profile states; do not infer unstated experience.', {
+        true: 'The profile describes specific work or credentials that demonstrate the requirement.',
+        false: 'The profile mentions the requirement only as a keyword or claim, or does not address it.',
+    }, options);
+    return qualificationEvidenceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'evidenced' : 'unevidenced',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { qualificationEvidenceInputSchema, qualificationEvidenceResultSchema, qualificationEvidenceVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const qualificationEvidenceVerdictSchema: z.ZodEnum<{
+    evidenced: "evidenced";
+    unevidenced: "unevidenced";
+}>;
+export declare const qualificationEvidenceInputSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    profile: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const qualificationEvidenceResultSchema: 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<{
+        evidenced: "evidenced";
+        unevidenced: "unevidenced";
+    }>;
+}, z.core.$strip>;
+export type QualificationEvidenceVerdict = z.infer<typeof qualificationEvidenceVerdictSchema>;
+export type QualificationEvidenceInput = z.infer<typeof qualificationEvidenceInputSchema>;
+export type QualificationEvidenceResult = z.infer<typeof qualificationEvidenceResultSchema>;

package/dist/recipes/qualification-evidence/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const qualificationEvidenceVerdictSchema = z.enum(['evidenced', 'unevidenced']);
+export const qualificationEvidenceInputSchema = z.object({
+    requirement: nonEmptyText,
+    profile: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const qualificationEvidenceResultSchema = gateResultSchema.extend({
+    verdict: qualificationEvidenceVerdictSchema,
+});

package/dist/recipes/query-equivalence/schema.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const queryEquivalenceVerdictSchema: z.ZodEnum<{
     related: "related";
     unclear: "unclear";
-    equivalent: "equivalent";
     different: "different";
+    equivalent: "equivalent";
 }>;
 export declare const queryEquivalenceInputSchema: z.ZodObject<{
     firstQuestion: z.ZodString;
@@ -24,15 +24,15 @@ export declare const queryEquivalenceResultSchema: z.ZodObject<{
     verdict: z.ZodEnum<{
         related: "related";
         unclear: "unclear";
-        equivalent: "equivalent";
         different: "different";
+        equivalent: "equivalent";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         related: "related";
         unclear: "unclear";
-        equivalent: "equivalent";
         different: "different";
+        equivalent: "equivalent";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type QueryEquivalenceInput = z.infer<typeof queryEquivalenceInputSchema>;

package/dist/recipes/question-relevance/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "question": "You mentioned you have young kids. How would you handle the on-call rotation, and do you plan to have more children in the next couple of years?",
+    "role": "Site Reliability Engineer. Requirements: 3+ years running production services, experience with incident response, participation in a weekly on-call rotation, strong Linux and networking fundamentals.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.05 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/question-relevance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QuestionRelevanceInput, QuestionRelevanceResult } from './schema.js';
+export declare function questionRelevance(input: QuestionRelevanceInput, options?: RecipeOptions): Promise<QuestionRelevanceResult>;
+export { questionRelevanceInputSchema, questionRelevanceResultSchema, questionRelevanceVerdictSchema, } from './schema.js';
+export type { QuestionRelevanceInput, QuestionRelevanceResult, QuestionRelevanceVerdict, } from './schema.js';

package/dist/recipes/question-relevance/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { questionRelevanceInputSchema, questionRelevanceResultSchema } from './schema.js';
+export async function questionRelevance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = questionRelevanceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does question ask only about matters relevant to the requirements of role? Count skills, experience, availability, work authorization, and ability to perform the stated duties as relevant. Count personal circumstances unrelated to the work, such as family plans, age, health, religion, origin, or private life, as unrelated. A question is unrelated if any part of it probes such circumstances, even when another part is about the work.', {
+        true: 'Every part of the question concerns the stated requirements or duties of the role.',
+        false: 'Some part of the question probes personal circumstances unrelated to the role.',
+    }, options);
+    return questionRelevanceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'relevant' : 'unrelated',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { questionRelevanceInputSchema, questionRelevanceResultSchema, questionRelevanceVerdictSchema, } from './schema.js';

package/dist/recipes/question-relevance/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const questionRelevanceVerdictSchema: z.ZodEnum<{
+    unrelated: "unrelated";
+    relevant: "relevant";
+}>;
+export declare const questionRelevanceInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    role: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const questionRelevanceResultSchema: 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<{
+        unrelated: "unrelated";
+        relevant: "relevant";
+    }>;
+}, z.core.$strip>;
+export type QuestionRelevanceVerdict = z.infer<typeof questionRelevanceVerdictSchema>;
+export type QuestionRelevanceInput = z.infer<typeof questionRelevanceInputSchema>;
+export type QuestionRelevanceResult = z.infer<typeof questionRelevanceResultSchema>;

package/dist/recipes/question-relevance/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const questionRelevanceVerdictSchema = z.enum(['relevant', 'unrelated']);
+export const questionRelevanceInputSchema = z.object({
+    question: nonEmptyText,
+    role: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const questionRelevanceResultSchema = gateResultSchema.extend({
+    verdict: questionRelevanceVerdictSchema,
+});

package/dist/recipes/reconciliation-match/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "record": "2024-03-14 | Adobe Creative Cloud team subscription, monthly, design team | Vendor: Adobe Inc.",
+    "statementLine": "03/16 ADOBE *CREATIVE CLD 800-833-6687 CA PURCHASE",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.9 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/reconciliation-match/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReconciliationMatchInput, ReconciliationMatchResult } from './schema.js';
+export declare function reconciliationMatch(input: ReconciliationMatchInput, options?: RecipeOptions): Promise<ReconciliationMatchResult>;
+export { reconciliationMatchInputSchema, reconciliationMatchResultSchema, reconciliationMatchVerdictSchema, } from './schema.js';
+export type { ReconciliationMatchInput, ReconciliationMatchResult, ReconciliationMatchVerdict, } from './schema.js';

package/dist/recipes/reconciliation-match/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { reconciliationMatchInputSchema, reconciliationMatchResultSchema } from './schema.js';
+export async function reconciliationMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reconciliationMatchInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Read the ledger record and the statementLine from a bank or card statement. Decide whether they describe the same transaction by comparing who was paid, what the payment was for, and when it happened, as each is worded. Allow for abbreviations, processor names, and posting delays of a few days that are normal for statements. Do not rely on amounts or exact dates matching; the caller checks those separately.', {
+        true: 'The payee, purpose, and timing wording of the two entries are consistent with a single transaction, allowing for abbreviated descriptors, processor names, and normal posting delays.',
+        false: 'The wording points to different payees, different purposes, or timing too far apart to be the same transaction.',
+    }, options);
+    return reconciliationMatchResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'same' : 'different',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { reconciliationMatchInputSchema, reconciliationMatchResultSchema, reconciliationMatchVerdictSchema, } from './schema.js';

package/dist/recipes/reconciliation-match/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const reconciliationMatchVerdictSchema: z.ZodEnum<{
+    same: "same";
+    different: "different";
+}>;
+export declare const reconciliationMatchInputSchema: z.ZodObject<{
+    record: z.ZodString;
+    statementLine: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reconciliationMatchResultSchema: 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<{
+        same: "same";
+        different: "different";
+    }>;
+}, z.core.$strip>;
+export type ReconciliationMatchVerdict = z.infer<typeof reconciliationMatchVerdictSchema>;
+export type ReconciliationMatchInput = z.infer<typeof reconciliationMatchInputSchema>;
+export type ReconciliationMatchResult = z.infer<typeof reconciliationMatchResultSchema>;

package/dist/recipes/reconciliation-match/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const reconciliationMatchVerdictSchema = z.enum(['same', 'different']);
+export const reconciliationMatchInputSchema = z.object({
+    record: nonEmptyText,
+    statementLine: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reconciliationMatchResultSchema = gateResultSchema.extend({
+    verdict: reconciliationMatchVerdictSchema,
+});

package/dist/recipes/repetition-level/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "recentMaterial": "C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 | C4 E4 G4 E4 (all quarter notes, same dynamic, no rests)",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.94,
+        "confidence": 0.85,
+        "probabilities": { "0": 0.01, "1": 0.01, "2": 0.07, "3": 0.85, "4": 0.06 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/repetition-level/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RepetitionLevelInput, RepetitionLevelResult } from './schema.js';
+export declare function repetitionLevel(input: RepetitionLevelInput, options?: RecipeOptions): Promise<RepetitionLevelResult>;
+export { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';
+export type { RepetitionLevelInput, RepetitionLevelResult, RepetitionLevelVerdict, } from './schema.js';