jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/breaking-change-signal/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const breakingChangeSignalVerdictSchema = z.enum(['breaking', 'compatible']);
+export const breakingChangeSignalInputSchema = z.object({
+    change: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const breakingChangeSignalResultSchema = gateResultSchema.extend({
+    verdict: breakingChangeSignalVerdictSchema,
+});

package/dist/recipes/budget-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "plan": "1. Clone the repository and install dependencies. 2. Run the full test suite to record the baseline (about 12 minutes). 3. For each of the 9 failing tests, read the test, read the code under test, propose a fix, apply it, and rerun the full suite. 4. Open a pull request with a summary of every fix.",
+    "budget": "At most 20 tool calls and 30 minutes of wall-clock time. No more than 5 full test-suite runs.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.08 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/budget-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { BudgetFitInput, BudgetFitResult } from './schema.js';
+export declare function budgetFit(input: BudgetFitInput, options?: RecipeOptions): Promise<BudgetFitResult>;
+export { budgetFitInputSchema, budgetFitResultSchema, budgetFitVerdictSchema } from './schema.js';
+export type { BudgetFitInput, BudgetFitResult, BudgetFitVerdict } from './schema.js';

package/dist/recipes/budget-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { budgetFitInputSchema, budgetFitResultSchema } from './schema.js';
+export async function budgetFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = budgetFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does plan, as described, plausibly fit within budget, the stated limits on steps, time, cost, or calls? Estimate the steps, tool calls, elapsed time, and spend the plan would realistically need, including retries and waiting that the plan implies, and compare each against the matching limit in budget. Count the plan as exceeding when any single limit would plausibly be crossed. Treat a limit budget does not mention as unconstrained.', {
+        true: 'The plan plausibly completes within every limit the budget states.',
+        false: 'The plan would plausibly cross at least one limit the budget states.',
+    }, options);
+    return budgetFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'exceeds',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { budgetFitInputSchema, budgetFitResultSchema, budgetFitVerdictSchema } from './schema.js';

package/dist/recipes/budget-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const budgetFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    exceeds: "exceeds";
+}>;
+export declare const budgetFitInputSchema: z.ZodObject<{
+    plan: z.ZodString;
+    budget: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const budgetFitResultSchema: 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<{
+        fits: "fits";
+        exceeds: "exceeds";
+    }>;
+}, z.core.$strip>;
+export type BudgetFitVerdict = z.infer<typeof budgetFitVerdictSchema>;
+export type BudgetFitInput = z.infer<typeof budgetFitInputSchema>;
+export type BudgetFitResult = z.infer<typeof budgetFitResultSchema>;

package/dist/recipes/budget-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const budgetFitVerdictSchema = z.enum(['fits', 'exceeds']);
+export const budgetFitInputSchema = z.object({
+    plan: nonEmptyText,
+    budget: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const budgetFitResultSchema = gateResultSchema.extend({
+    verdict: budgetFitVerdictSchema,
+});

package/dist/recipes/budget-narrative-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "lineItems": "Program coordinator salary (0.5 FTE): $30,000\nBooks and materials: $9,000\nTutor training and background checks: $4,000\nSnacks and family reading nights: $5,000\nTotal: $48,000",
+    "narrative": "Personnel. A half-time program coordinator ($30,000) will recruit and schedule tutors, coordinate with the three partner schools, and track attendance. Books and materials ($9,000) cover levelled readers for 90 students, reading logs, and consumables for the school year. Tutor training and background checks ($4,000) fund a two-day orientation and state background screening for 12 volunteers. Travel ($2,400) reimburses the coordinator's mileage between the three school sites at the standard rate.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.06 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/budget-narrative-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { BudgetNarrativeFitInput, BudgetNarrativeFitResult } from './schema.js';
+export declare function budgetNarrativeFit(input: BudgetNarrativeFitInput, options?: RecipeOptions): Promise<BudgetNarrativeFitResult>;
+export { budgetNarrativeFitInputSchema, budgetNarrativeFitResultSchema, budgetNarrativeFitVerdictSchema, } from './schema.js';
+export type { BudgetNarrativeFitInput, BudgetNarrativeFitResult, BudgetNarrativeFitVerdict, } from './schema.js';

package/dist/recipes/budget-narrative-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { budgetNarrativeFitInputSchema, budgetNarrativeFitResultSchema } from './schema.js';
+export async function budgetNarrativeFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = budgetNarrativeFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does narrative explain every line item in lineItems, and does every expense narrative explains correspond to an item in lineItems? Match items by what the expense is for, not by exact wording, order, or heading; a narrative paragraph may cover an item under a different name or fold two listed items into one sentence. Do not check whether the amounts agree, add up, or are reasonable. Judge only coverage in both directions.', {
+        true: 'Every line item in lineItems has an explanation in narrative, and every expense narrative explains corresponds to a listed line item.',
+        false: 'At least one listed line item has no explanation in narrative, or narrative explains an expense that lineItems does not contain.',
+    }, options);
+    return budgetNarrativeFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'aligned' : 'misaligned',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { budgetNarrativeFitInputSchema, budgetNarrativeFitResultSchema, budgetNarrativeFitVerdictSchema, } from './schema.js';

package/dist/recipes/budget-narrative-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const budgetNarrativeFitVerdictSchema: z.ZodEnum<{
+    aligned: "aligned";
+    misaligned: "misaligned";
+}>;
+export declare const budgetNarrativeFitInputSchema: z.ZodObject<{
+    lineItems: z.ZodString;
+    narrative: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const budgetNarrativeFitResultSchema: 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<{
+        aligned: "aligned";
+        misaligned: "misaligned";
+    }>;
+}, z.core.$strip>;
+export type BudgetNarrativeFitVerdict = z.infer<typeof budgetNarrativeFitVerdictSchema>;
+export type BudgetNarrativeFitInput = z.infer<typeof budgetNarrativeFitInputSchema>;
+export type BudgetNarrativeFitResult = z.infer<typeof budgetNarrativeFitResultSchema>;

package/dist/recipes/budget-narrative-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const budgetNarrativeFitVerdictSchema = z.enum(['aligned', 'misaligned']);
+export const budgetNarrativeFitInputSchema = z.object({
+    lineItems: nonEmptyText,
+    narrative: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const budgetNarrativeFitResultSchema = gateResultSchema.extend({
+    verdict: budgetNarrativeFitVerdictSchema,
+});

package/dist/recipes/bug-report-completeness/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "report": "Steps: 1. Open the Reports tab. 2. Choose a date range ending today. 3. Click Export CSV. Expected: a CSV downloads with rows for the whole range. Actual: the download contains only rows up to yesterday and today's rows are missing.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.92,
+        "confidence": 0.85,
+        "probabilities": { "0": 0, "1": 0.01, "2": 0.1, "3": 0.85, "4": 0.04 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/bug-report-completeness/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { BugReportCompletenessInput, BugReportCompletenessResult } from './schema.js';
+export declare function bugReportCompleteness(input: BugReportCompletenessInput, options?: RecipeOptions): Promise<BugReportCompletenessResult>;
+export { bugReportCompletenessInputSchema, bugReportCompletenessResultSchema, bugReportCompletenessVerdictSchema, } from './schema.js';
+export type { BugReportCompletenessInput, BugReportCompletenessResult, BugReportCompletenessVerdict, } from './schema.js';

package/dist/recipes/bug-report-completeness/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { bugReportCompletenessInputSchema, bugReportCompletenessResultSchema, bugReportCompletenessVerdictSchema, } from './schema.js';
+export async function bugReportCompleteness(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = bugReportCompletenessInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How complete is report for someone to reproduce and triage it? Check for steps to reproduce, the expected behavior, the actual behavior, and the environment or version. Judge what is present, not how politely or how long it is written.', [
+        'The report is only a complaint or request for help with no described symptom.',
+        'The report describes a symptom but gives no steps to reproduce and no expected behavior.',
+        'The report gives either steps to reproduce or expected-versus-actual behavior, but not both.',
+        'The report gives steps, expected behavior, and actual behavior but omits the environment or version.',
+        'The report gives steps, expected behavior, actual behavior, and the environment or version.',
+    ], options);
+    return bugReportCompletenessResultSchema.parse({
+        ...decision,
+        completeness: bugReportCompletenessVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { bugReportCompletenessInputSchema, bugReportCompletenessResultSchema, bugReportCompletenessVerdictSchema, } from './schema.js';

package/dist/recipes/bug-report-completeness/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const bugReportCompletenessVerdictSchema: z.ZodEnum<{
+    complete: "complete";
+    partial: "partial";
+    symptom: "symptom";
+    bare: "bare";
+    nearly: "nearly";
+}>;
+export declare const bugReportCompletenessInputSchema: z.ZodObject<{
+    report: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const bugReportCompletenessResultSchema: 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";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    completeness: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        symptom: "symptom";
+        bare: "bare";
+        nearly: "nearly";
+    }>;
+}, z.core.$strip>;
+export type BugReportCompletenessVerdict = z.infer<typeof bugReportCompletenessVerdictSchema>;
+export type BugReportCompletenessInput = z.infer<typeof bugReportCompletenessInputSchema>;
+export type BugReportCompletenessResult = z.infer<typeof bugReportCompletenessResultSchema>;

package/dist/recipes/bug-report-completeness/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const bugReportCompletenessVerdictSchema = z.enum([
+    'bare',
+    'symptom',
+    'partial',
+    'nearly',
+    'complete',
+]);
+export const bugReportCompletenessInputSchema = z.object({
+    report: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const bugReportCompletenessResultSchema = scoreResultSchema.extend({
+    completeness: bugReportCompletenessVerdictSchema,
+});

package/dist/recipes/buying-intent/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "message": "We've narrowed it down to you and one other vendor. Can you confirm whether the Team plan includes SSO, and what the annual price would be for 40 seats?",
+    "context": "Reply from a prospect who attended a product demo last week.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.06,
+        "confidence": 0.84,
+        "probabilities": { "0": 0.01, "1": 0.04, "2": 0.84, "3": 0.1, "4": 0.01 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/buying-intent/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { BuyingIntentInput, BuyingIntentResult } from './schema.js';
+export declare function buyingIntent(input: BuyingIntentInput, options?: RecipeOptions): Promise<BuyingIntentResult>;
+export { buyingIntentInputSchema, buyingIntentResultSchema, buyingIntentVerdictSchema, } from './schema.js';
+export type { BuyingIntentInput, BuyingIntentResult, BuyingIntentVerdict } from './schema.js';

package/dist/recipes/buying-intent/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { buyingIntentInputSchema, buyingIntentResultSchema, buyingIntentVerdictSchema, } from './schema.js';
+export async function buyingIntent(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = buyingIntentInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How strong is the purchase intent expressed in message, given any context? Judge what the sender says about buying, evaluating, or starting with the product or service, not their politeness or enthusiasm.', [
+        'The message expresses no interest in buying or explicitly declines.',
+        'The message shows curiosity or general research with no evaluation of fit for the sender.',
+        'The message actively evaluates the offer by comparing options or asking about fit, pricing, or terms.',
+        'The message signals readiness to buy pending one specific named blocker such as approval, a discount, or a feature.',
+        'The message commits to buying by asking how to pay, sign, or start.',
+    ], options);
+    return buyingIntentResultSchema.parse({
+        ...decision,
+        intent: buyingIntentVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { buyingIntentInputSchema, buyingIntentResultSchema, buyingIntentVerdictSchema, } from './schema.js';

package/dist/recipes/buying-intent/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const buyingIntentVerdictSchema: z.ZodEnum<{
+    ready: "ready";
+    none: "none";
+    curious: "curious";
+    evaluating: "evaluating";
+    committed: "committed";
+}>;
+export declare const buyingIntentInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const buyingIntentResultSchema: 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";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    intent: z.ZodEnum<{
+        ready: "ready";
+        none: "none";
+        curious: "curious";
+        evaluating: "evaluating";
+        committed: "committed";
+    }>;
+}, z.core.$strip>;
+export type BuyingIntentVerdict = z.infer<typeof buyingIntentVerdictSchema>;
+export type BuyingIntentInput = z.infer<typeof buyingIntentInputSchema>;
+export type BuyingIntentResult = z.infer<typeof buyingIntentResultSchema>;

package/dist/recipes/buying-intent/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const buyingIntentVerdictSchema = z.enum([
+    'none',
+    'curious',
+    'evaluating',
+    'ready',
+    'committed',
+]);
+export const buyingIntentInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const buyingIntentResultSchema = scoreResultSchema.extend({
+    intent: buyingIntentVerdictSchema,
+});

package/dist/recipes/care-urgency-wording/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "message": "My daughter has had a fever of 101 since last night and now she says her ear really hurts. She is drinking fine and otherwise seems okay. Can someone see her today or tomorrow? I do not think it is an emergency, but I would rather not wait until next week.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.02,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.02, "1": 0.06, "2": 0.82, "3": 0.08, "4": 0.02 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/care-urgency-wording/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CareUrgencyWordingInput, CareUrgencyWordingResult } from './schema.js';
+export declare function careUrgencyWording(input: CareUrgencyWordingInput, options?: RecipeOptions): Promise<CareUrgencyWordingResult>;
+export { careUrgencyWordingInputSchema, careUrgencyWordingResultSchema, careUrgencyWordingVerdictSchema, } from './schema.js';
+export type { CareUrgencyWordingInput, CareUrgencyWordingResult, CareUrgencyWordingVerdict, } from './schema.js';

package/dist/recipes/care-urgency-wording/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { careUrgencyWordingInputSchema, careUrgencyWordingResultSchema, careUrgencyWordingVerdictSchema, } from './schema.js';
+export async function careUrgencyWording(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = careUrgencyWordingInputSchema.parse(input);
+    const decision = await evaluateScore(state, "How urgent is the care that message asks for, judged only by what the patient's wording requests or says about timing? Read stated timeframes, explicit urgency words, and any described inability to wait. Do not assess whether the described symptoms are medically serious, and do not raise or lower the level based on your own clinical view of the condition.", [
+        'The message asks for care with no time pressure, such as a checkup, a routine follow-up, or a matter the patient says can wait for the next available slot.',
+        'The message asks to be seen in the coming days or weeks, or says the matter is not urgent but should not be left indefinitely.',
+        'The message asks to be seen within a day or two, or says the problem is worsening and the patient wants it looked at quickly.',
+        'The message asks to be seen today or right away, says the patient cannot wait, or asks whether to go to urgent care.',
+        'The message frames the situation as an emergency, or asks whether to call emergency services or go to the emergency room now.',
+    ], options);
+    return careUrgencyWordingResultSchema.parse({
+        ...decision,
+        urgency: careUrgencyWordingVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { careUrgencyWordingInputSchema, careUrgencyWordingResultSchema, careUrgencyWordingVerdictSchema, } from './schema.js';

package/dist/recipes/care-urgency-wording/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const careUrgencyWordingVerdictSchema: z.ZodEnum<{
+    routine: "routine";
+    soon: "soon";
+    prompt: "prompt";
+    urgent: "urgent";
+    emergency: "emergency";
+}>;
+export declare const careUrgencyWordingInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const careUrgencyWordingResultSchema: 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";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    urgency: z.ZodEnum<{
+        routine: "routine";
+        soon: "soon";
+        prompt: "prompt";
+        urgent: "urgent";
+        emergency: "emergency";
+    }>;
+}, z.core.$strip>;
+export type CareUrgencyWordingVerdict = z.infer<typeof careUrgencyWordingVerdictSchema>;
+export type CareUrgencyWordingInput = z.infer<typeof careUrgencyWordingInputSchema>;
+export type CareUrgencyWordingResult = z.infer<typeof careUrgencyWordingResultSchema>;

package/dist/recipes/care-urgency-wording/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const careUrgencyWordingVerdictSchema = z.enum([
+    'routine',
+    'soon',
+    'prompt',
+    'urgent',
+    'emergency',
+]);
+export const careUrgencyWordingInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const careUrgencyWordingResultSchema = scoreResultSchema.extend({
+    urgency: careUrgencyWordingVerdictSchema,
+});

package/dist/recipes/category-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "item": "Replacement HEPA filter for the AirPure 300 series purifier. Two-pack, captures 99.97% of particles down to 0.3 microns. Compatible with models AP-300, AP-310, and AP-320.",
+    "category": "Air Purifiers: standalone air purifying appliances for home or office use. Excludes replacement filters, parts, and accessories, which belong under Air Purifier Accessories.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.04 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/category-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CategoryFitInput, CategoryFitResult } from './schema.js';
+export declare function categoryFit(input: CategoryFitInput, options?: RecipeOptions): Promise<CategoryFitResult>;
+export { categoryFitInputSchema, categoryFitResultSchema, categoryFitVerdictSchema, } from './schema.js';
+export type { CategoryFitInput, CategoryFitResult, CategoryFitVerdict } from './schema.js';

package/dist/recipes/category-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { categoryFitInputSchema, categoryFitResultSchema } from './schema.js';
+export async function categoryFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = categoryFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does the product described by item belong under category as defined? Judge the kind of product item describes against the scope category states, including any inclusions or exclusions it lists. An accessory, part, or related product belongs only if the category definition covers it. Judge only the supplied text.', {
+        true: 'The item is the kind of product the category definition covers.',
+        false: 'The item falls outside the category definition or belongs to a different kind of product.',
+    }, options);
+    return categoryFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'misfiled',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { categoryFitInputSchema, categoryFitResultSchema, categoryFitVerdictSchema, } from './schema.js';

package/dist/recipes/category-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const categoryFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    misfiled: "misfiled";
+}>;
+export declare const categoryFitInputSchema: z.ZodObject<{
+    item: z.ZodString;
+    category: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const categoryFitResultSchema: 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<{
+        fits: "fits";
+        misfiled: "misfiled";
+    }>;
+}, z.core.$strip>;
+export type CategoryFitVerdict = z.infer<typeof categoryFitVerdictSchema>;
+export type CategoryFitInput = z.infer<typeof categoryFitInputSchema>;
+export type CategoryFitResult = z.infer<typeof categoryFitResultSchema>;

package/dist/recipes/category-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const categoryFitVerdictSchema = z.enum(['fits', 'misfiled']);
+export const categoryFitInputSchema = z.object({
+    item: nonEmptyText,
+    category: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const categoryFitResultSchema = gateResultSchema.extend({
+    verdict: categoryFitVerdictSchema,
+});

package/dist/recipes/causal-language-strength/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "statement": "Adolescents who reported more screen time in the hour before bed also reported poorer sleep quality (r = 0.31, p < .001). Because the data are cross-sectional, our design does not permit causal conclusions.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 1.09,
+        "confidence": 0.9,
+        "probabilities": { "0": 0.01, "1": 0.9, "2": 0.08, "3": 0.01, "4": 0 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/causal-language-strength/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CausalLanguageStrengthInput, CausalLanguageStrengthResult } from './schema.js';
+export declare function causalLanguageStrength(input: CausalLanguageStrengthInput, options?: RecipeOptions): Promise<CausalLanguageStrengthResult>;
+export { causalLanguageStrengthInputSchema, causalLanguageStrengthResultSchema, causalLanguageStrengthVerdictSchema, } from './schema.js';
+export type { CausalLanguageStrengthInput, CausalLanguageStrengthResult, CausalLanguageStrengthVerdict, } from './schema.js';

package/dist/recipes/causal-language-strength/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { causalLanguageStrengthInputSchema, causalLanguageStrengthResultSchema, causalLanguageStrengthVerdictSchema, } from './schema.js';
+export async function causalLanguageStrength(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = causalLanguageStrengthInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How strong is the causal claim in the wording of statement? Judge only the language that links the factors: correlational verbs such as associated with or linked to, suggestive phrases such as may contribute to or consistent with a causal role, hedged causal verbs such as likely causes or appears to reduce, and unhedged causal verbs such as causes, prevents, or leads to. Weigh explicit disclaimers about causation. Do not judge whether the claim is true or whether the study design would justify it.', [
+        'The statement claims no relationship between factors, or describes a single factor without linking it to an outcome.',
+        'The statement reports a correlation, link, or co-occurrence between factors and either disclaims causation or uses no causal verb.',
+        'The statement reports an association and raises a causal interpretation as a possibility, using phrases such as may contribute to or is consistent with a causal effect.',
+        'The statement makes a causal claim as its main point but softens it with words such as likely, appears to, or probably.',
+        'The statement states that one factor causes, prevents, improves, or leads to another as a fact, with no hedge or disclaimer.',
+    ], options);
+    return causalLanguageStrengthResultSchema.parse({
+        ...decision,
+        causality: causalLanguageStrengthVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { causalLanguageStrengthInputSchema, causalLanguageStrengthResultSchema, causalLanguageStrengthVerdictSchema, } from './schema.js';