jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/answer-coverage/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const answerCoverageVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
-    answered: "answered";
     partial: "partial";
+    answered: "answered";
     missing: "missing";
 }>;
 export declare const answerCoverageInputSchema: z.ZodObject<{
@@ -32,15 +32,15 @@ export declare const answerCoverageResultSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             unclear: "unclear";
-            answered: "answered";
             partial: "partial";
+            answered: "answered";
             missing: "missing";
         }>;
         confidence: z.ZodNumber;
         probabilities: z.ZodRecord<z.ZodEnum<{
             unclear: "unclear";
-            answered: "answered";
             partial: "partial";
+            answered: "answered";
             missing: "missing";
         }>, z.ZodNumber>;
     }, z.core.$strip>>;

package/dist/recipes/answer-disclosures/demo.json

@@ -0,0 +1,16 @@
+{
+  "input": {
+    "draft": "Based on the 2024 pricing page, the Team plan includes SSO. I am not certain this still applies to accounts created before March, and I have not checked the enterprise tier. I am assuming you are on a monthly plan.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesUncertainty": { "type": "noul", "noul": 0.95 },
+      "statesLimitations": { "type": "noul", "noul": 0.9 },
+      "citesSources": { "type": "noul", "noul": 0.88 },
+      "statesAssumptions": { "type": "noul", "noul": 0.94 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/answer-disclosures/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AnswerDisclosuresInput, AnswerDisclosuresResult } from './schema.js';
+export declare function answerDisclosures(input: AnswerDisclosuresInput, options?: RecipeOptions): Promise<AnswerDisclosuresResult>;
+export { answerDisclosuresInputSchema, answerDisclosuresResultSchema, answerDisclosuresLabelSchema, } from './schema.js';
+export type { AnswerDisclosuresInput, AnswerDisclosuresResult, AnswerDisclosuresLabel, } from './schema.js';

package/dist/recipes/answer-disclosures/index.js

@@ -0,0 +1,41 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { answerDisclosuresInputSchema, answerDisclosuresResultSchema } from './schema.js';
+export async function answerDisclosures(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = answerDisclosuresInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesUncertainty: {
+            instruction: 'Does draft explicitly express uncertainty about any of its own claims, such as hedging, confidence qualifiers, or saying it may be wrong?',
+            criteria: {
+                true: 'The draft explicitly signals uncertainty about at least one claim.',
+                false: 'The draft presents its claims without any uncertainty signal.',
+            },
+        },
+        statesLimitations: {
+            instruction: 'Does draft explicitly state what it does not cover, cannot do, or where its answer stops applying?',
+            criteria: {
+                true: 'The draft states at least one limitation or boundary of its answer.',
+                false: 'The draft states no limitation.',
+            },
+        },
+        citesSources: {
+            instruction: 'Does draft attribute any of its claims to a named source, document, reference, or link?',
+            criteria: {
+                true: 'The draft attributes at least one claim to an identifiable source.',
+                false: 'The draft attributes nothing to a source.',
+            },
+        },
+        statesAssumptions: {
+            instruction: 'Does draft explicitly name an assumption it is making about the request, the reader, or the situation?',
+            criteria: {
+                true: 'The draft names at least one assumption it relies on.',
+                false: 'The draft names no assumption.',
+            },
+        },
+    }, options);
+    return answerDisclosuresResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { answerDisclosuresInputSchema, answerDisclosuresResultSchema, answerDisclosuresLabelSchema, } from './schema.js';

package/dist/recipes/answer-disclosures/schema.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const answerDisclosuresLabelSchema: z.ZodEnum<{
+    statesUncertainty: "statesUncertainty";
+    statesLimitations: "statesLimitations";
+    citesSources: "citesSources";
+    statesAssumptions: "statesAssumptions";
+}>;
+export declare const answerDisclosuresInputSchema: z.ZodObject<{
+    draft: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const answerDisclosuresResultSchema: 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<{
+        statesUncertainty: "statesUncertainty";
+        statesLimitations: "statesLimitations";
+        citesSources: "citesSources";
+        statesAssumptions: "statesAssumptions";
+    }>>;
+    labels: z.ZodObject<{
+        statesUncertainty: 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>;
+        statesLimitations: 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>;
+        citesSources: 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>;
+        statesAssumptions: 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 AnswerDisclosuresLabel = z.infer<typeof answerDisclosuresLabelSchema>;
+export type AnswerDisclosuresInput = z.infer<typeof answerDisclosuresInputSchema>;
+export type AnswerDisclosuresResult = z.infer<typeof answerDisclosuresResultSchema>;

package/dist/recipes/answer-disclosures/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const answerDisclosuresLabelSchema = z.enum([
+    'statesUncertainty',
+    'statesLimitations',
+    'citesSources',
+    'statesAssumptions',
+]);
+export const answerDisclosuresInputSchema = z.object({
+    draft: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const answerDisclosuresResultSchema = labelsResultSchema.extend({
+    detected: z.array(answerDisclosuresLabelSchema),
+    labels: z.object({
+        statesUncertainty: labelCheckSchema,
+        statesLimitations: labelCheckSchema,
+        citesSources: labelCheckSchema,
+        statesAssumptions: labelCheckSchema,
+    }),
+});

package/dist/recipes/answer-grade/demo.json

@@ -0,0 +1,20 @@
+{
+  "input": {
+    "question": "Explain why the sky appears blue during the day.",
+    "answer": "Sunlight contains all colors. When it passes through the atmosphere, gas molecules scatter shorter wavelengths like blue much more than longer wavelengths like red, so blue light reaches our eyes from every direction in the sky.",
+    "rubric": "Full credit requires: (1) sunlight is made of many wavelengths; (2) atmospheric molecules scatter light; (3) shorter wavelengths scatter more strongly (Rayleigh scattering); (4) explains why violet is not the dominant perceived color.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.95,
+        "confidence": 0.81,
+        "probabilities": { "0": 0.0, "1": 0.02, "2": 0.09, "3": 0.81, "4": 0.08 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/answer-grade/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AnswerGradeInput, AnswerGradeResult } from './schema.js';
+export declare function answerGrade(input: AnswerGradeInput, options?: RecipeOptions): Promise<AnswerGradeResult>;
+export { answerGradeInputSchema, answerGradeResultSchema, answerGradeVerdictSchema, } from './schema.js';
+export type { AnswerGradeInput, AnswerGradeResult, AnswerGradeVerdict } from './schema.js';

package/dist/recipes/answer-grade/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { answerGradeInputSchema, answerGradeResultSchema, answerGradeVerdictSchema, } from './schema.js';
+export async function answerGrade(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = answerGradeInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How well does answer meet rubric as a response to question? Judge only against the criteria rubric states. Ignore length, style, and effort unless rubric names them. Do not reward content that rubric does not ask for.', [
+        'The answer meets none of the rubric criteria or does not address the question.',
+        'The answer meets a small part of one or two rubric criteria and misses the rest.',
+        'The answer meets some rubric criteria fully but leaves major criteria unmet.',
+        'The answer meets most rubric criteria with only minor omissions or errors.',
+        'The answer meets every rubric criterion without omissions or errors.',
+    ], options);
+    return answerGradeResultSchema.parse({
+        ...decision,
+        grade: answerGradeVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { answerGradeInputSchema, answerGradeResultSchema, answerGradeVerdictSchema, } from './schema.js';

package/dist/recipes/answer-grade/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const answerGradeVerdictSchema: z.ZodEnum<{
+    none: "none";
+    partial: "partial";
+    minimal: "minimal";
+    mostly: "mostly";
+    full: "full";
+}>;
+export declare const answerGradeInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    answer: z.ZodString;
+    rubric: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const answerGradeResultSchema: 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>;
+    grade: z.ZodEnum<{
+        none: "none";
+        partial: "partial";
+        minimal: "minimal";
+        mostly: "mostly";
+        full: "full";
+    }>;
+}, z.core.$strip>;
+export type AnswerGradeVerdict = z.infer<typeof answerGradeVerdictSchema>;
+export type AnswerGradeInput = z.infer<typeof answerGradeInputSchema>;
+export type AnswerGradeResult = z.infer<typeof answerGradeResultSchema>;

package/dist/recipes/answer-grade/schema.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const answerGradeVerdictSchema = z.enum(['none', 'minimal', 'partial', 'mostly', 'full']);
+export const answerGradeInputSchema = z.object({
+    question: nonEmptyText,
+    answer: nonEmptyText,
+    rubric: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const answerGradeResultSchema = scoreResultSchema.extend({
+    grade: answerGradeVerdictSchema,
+});

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const answerabilityVerdictSchema: z.ZodEnum<{
-    conflicting: "conflicting";
     partial: "partial";
+    conflicting: "conflicting";
     sufficient: "sufficient";
     insufficient: "insufficient";
 }>;
@@ -28,16 +28,16 @@ export declare const answerabilityResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        conflicting: "conflicting";
         partial: "partial";
+        conflicting: "conflicting";
         sufficient: "sufficient";
         insufficient: "insufficient";
     }>;
     canAnswer: z.ZodBoolean;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        conflicting: "conflicting";
         partial: "partial";
+        conflicting: "conflicting";
         sufficient: "sufficient";
         insufficient: "insufficient";
     }>, z.ZodNumber>;

package/dist/recipes/appeal-grounds-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "appeal": "I am appealing the denial dated September 3. The letter says my household income is $4,200 per month, which is over the limit. That number includes my adult son's wages, but he moved out in March and no longer lives with me; I told the office this at my interview. My actual household income is my own $2,600 per month. Please correct the income figure and reconsider my application.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "factual_error",
+        "confidence": 0.86,
+        "probabilities": {
+          "factual_error": 0.86,
+          "procedural_error": 0.01,
+          "new_evidence": 0.06,
+          "hardship": 0.02,
+          "misapplied_rule": 0.03,
+          "other": 0.01,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/appeal-grounds-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AppealGroundsKindInput, AppealGroundsKindResult } from './schema.js';
+export declare function appealGroundsKind(input: AppealGroundsKindInput, options?: RecipeOptions): Promise<AppealGroundsKindResult>;
+export { appealGroundsKindInputSchema, appealGroundsKindResultSchema, appealGroundsKindVerdictSchema, } from './schema.js';
+export type { AppealGroundsKindInput, AppealGroundsKindResult, AppealGroundsKindVerdict, } from './schema.js';

package/dist/recipes/appeal-grounds-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { appealGroundsKindInputSchema, appealGroundsKindResultSchema } from './schema.js';
+export async function appealGroundsKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = appealGroundsKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Read the appeal and decide what ground it primarily asserts, based only on the argument the appellant makes. Pick the single ground the appeal presses most: factual_error when the appellant says the decision rested on a wrong fact; procedural_error when they say the process was not followed; new_evidence when they offer information that was not available before; hardship when they ask for relief because of the consequences rather than disputing the decision; misapplied_rule when they accept the facts but say the wrong rule or interpretation was applied. Use other when the appeal clearly contests a decision on a ground that fits none of these, and unclear when the text does not make a recognizable argument against a decision. Do not judge whether the appeal has merit.', {
+        factual_error: 'The appellant says the decision relied on a fact that is wrong, such as an incorrect income figure, date, address, or record.',
+        procedural_error: 'The appellant says the required process was not followed, such as a missed notice, a hearing they were not told about, or a deadline the agency did not honor.',
+        new_evidence: 'The appellant offers documents or information that were not available or not considered when the decision was made, without disputing how the earlier facts were handled.',
+        hardship: 'The appellant asks for relief because of the consequences of the decision, such as loss of housing, health, or income, rather than arguing the decision was wrong.',
+        misapplied_rule: 'The appellant accepts the facts but says the wrong rule, threshold, or interpretation was applied to them.',
+        other: 'The appeal clearly contests a decision on a ground that fits none of the named types, such as bias, inconsistency with a similar case, or a request for discretion.',
+        unclear: 'The text does not make a recognizable argument against a decision, or it is too vague to tell which ground it asserts.',
+    }, options);
+    return appealGroundsKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { appealGroundsKindInputSchema, appealGroundsKindResultSchema, appealGroundsKindVerdictSchema, } from './schema.js';

package/dist/recipes/appeal-grounds-kind/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const appealGroundsKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    factual_error: "factual_error";
+    procedural_error: "procedural_error";
+    new_evidence: "new_evidence";
+    hardship: "hardship";
+    misapplied_rule: "misapplied_rule";
+    other: "other";
+}>;
+export declare const appealGroundsKindInputSchema: z.ZodObject<{
+    appeal: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const appealGroundsKindResultSchema: 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";
+        factual_error: "factual_error";
+        procedural_error: "procedural_error";
+        new_evidence: "new_evidence";
+        hardship: "hardship";
+        misapplied_rule: "misapplied_rule";
+        other: "other";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        factual_error: "factual_error";
+        procedural_error: "procedural_error";
+        new_evidence: "new_evidence";
+        hardship: "hardship";
+        misapplied_rule: "misapplied_rule";
+        other: "other";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type AppealGroundsKindVerdict = z.infer<typeof appealGroundsKindVerdictSchema>;
+export type AppealGroundsKindInput = z.infer<typeof appealGroundsKindInputSchema>;
+export type AppealGroundsKindResult = z.infer<typeof appealGroundsKindResultSchema>;

package/dist/recipes/appeal-grounds-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const appealGroundsKindVerdictSchema = z.enum([
+    'factual_error',
+    'procedural_error',
+    'new_evidence',
+    'hardship',
+    'misapplied_rule',
+    'other',
+    'unclear',
+]);
+export const appealGroundsKindInputSchema = z.object({
+    appeal: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const appealGroundsKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: appealGroundsKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(appealGroundsKindVerdictSchema, probability),
+});

package/dist/recipes/appointment-request-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "message": "Hi, I am scheduled with Dr. Nguyen on Thursday at 2pm but my work shift changed. Is there anything available Friday morning instead?",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "reschedule",
+        "confidence": 0.9,
+        "probabilities": {
+          "schedule": 0.05,
+          "reschedule": 0.9,
+          "cancel": 0.02,
+          "results": 0.01,
+          "refill": 0,
+          "question": 0.01,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/appointment-request-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AppointmentRequestKindInput, AppointmentRequestKindResult } from './schema.js';
+export declare function appointmentRequestKind(input: AppointmentRequestKindInput, options?: RecipeOptions): Promise<AppointmentRequestKindResult>;
+export { appointmentRequestKindInputSchema, appointmentRequestKindResultSchema, appointmentRequestKindVerdictSchema, } from './schema.js';
+export type { AppointmentRequestKindInput, AppointmentRequestKindResult, AppointmentRequestKindVerdict, } from './schema.js';

package/dist/recipes/appointment-request-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { appointmentRequestKindInputSchema, appointmentRequestKindResultSchema } from './schema.js';
+export async function appointmentRequestKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = appointmentRequestKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What does the patient primarily want from message? Choose the single main request: booking a new appointment, moving an existing one, cancelling one, getting test results, refilling a prescription, or asking a question that needs an answer rather than one of those actions. Judge the stated request, not what the patient might additionally need. When two requests carry equal weight or the wording does not say what is wanted, answer unclear.', {
+        schedule: 'The patient asks to book a new appointment.',
+        reschedule: 'The patient asks to move an existing appointment to a different time.',
+        cancel: 'The patient asks to cancel an existing appointment without booking another.',
+        results: 'The patient asks for test or lab results or an explanation of them.',
+        refill: 'The patient asks for a prescription to be refilled or renewed.',
+        question: 'The patient asks a question that needs an answer rather than an appointment, result, or refill action.',
+        unclear: 'The message names no clear request, or names several requests of equal weight.',
+    }, options);
+    return appointmentRequestKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { appointmentRequestKindInputSchema, appointmentRequestKindResultSchema, appointmentRequestKindVerdictSchema, } from './schema.js';

package/dist/recipes/appointment-request-kind/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const appointmentRequestKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    question: "question";
+    schedule: "schedule";
+    reschedule: "reschedule";
+    cancel: "cancel";
+    results: "results";
+    refill: "refill";
+}>;
+export declare const appointmentRequestKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const appointmentRequestKindResultSchema: 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";
+        question: "question";
+        schedule: "schedule";
+        reschedule: "reschedule";
+        cancel: "cancel";
+        results: "results";
+        refill: "refill";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        question: "question";
+        schedule: "schedule";
+        reschedule: "reschedule";
+        cancel: "cancel";
+        results: "results";
+        refill: "refill";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type AppointmentRequestKindVerdict = z.infer<typeof appointmentRequestKindVerdictSchema>;
+export type AppointmentRequestKindInput = z.infer<typeof appointmentRequestKindInputSchema>;
+export type AppointmentRequestKindResult = z.infer<typeof appointmentRequestKindResultSchema>;

package/dist/recipes/appointment-request-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const appointmentRequestKindVerdictSchema = z.enum([
+    'schedule',
+    'reschedule',
+    'cancel',
+    'results',
+    'refill',
+    'question',
+    'unclear',
+]);
+export const appointmentRequestKindInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const appointmentRequestKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: appointmentRequestKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(appointmentRequestKindVerdictSchema, probability),
+});

package/dist/recipes/breaking-change-signal/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "change": "Rename the userId field in the /v1/orders response to customerId and remove the deprecated legacyStatus field from the same payload.",
+    "context": "Public REST API consumed by three partner integrations and the mobile app.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.95 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/breaking-change-signal/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { BreakingChangeSignalInput, BreakingChangeSignalResult } from './schema.js';
+export declare function breakingChangeSignal(input: BreakingChangeSignalInput, options?: RecipeOptions): Promise<BreakingChangeSignalResult>;
+export { breakingChangeSignalInputSchema, breakingChangeSignalResultSchema, breakingChangeSignalVerdictSchema, } from './schema.js';
+export type { BreakingChangeSignalInput, BreakingChangeSignalResult, BreakingChangeSignalVerdict, } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { breakingChangeSignalInputSchema, breakingChangeSignalResultSchema } from './schema.js';
+export async function breakingChangeSignal(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = breakingChangeSignalInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does change describe a change that would break existing callers, integrations, stored data, or documented behavior, given any context? Count removed or renamed public fields, functions, endpoints, or options; changed types, defaults, or return shapes; stricter validation; and incompatible data or schema changes. Purely additive changes, internal refactors, and bug fixes that restore documented behavior do not count.', {
+        true: 'The change would break existing callers, integrations, stored data, or documented behavior.',
+        false: 'The change preserves existing callers, integrations, stored data, and documented behavior.',
+    }, options);
+    return breakingChangeSignalResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'breaking' : 'compatible',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { breakingChangeSignalInputSchema, breakingChangeSignalResultSchema, breakingChangeSignalVerdictSchema, } from './schema.js';

package/dist/recipes/breaking-change-signal/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const breakingChangeSignalVerdictSchema: z.ZodEnum<{
+    compatible: "compatible";
+    breaking: "breaking";
+}>;
+export declare const breakingChangeSignalInputSchema: z.ZodObject<{
+    change: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const breakingChangeSignalResultSchema: 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<{
+        compatible: "compatible";
+        breaking: "breaking";
+    }>;
+}, z.core.$strip>;
+export type BreakingChangeSignalVerdict = z.infer<typeof breakingChangeSignalVerdictSchema>;
+export type BreakingChangeSignalInput = z.infer<typeof breakingChangeSignalInputSchema>;
+export type BreakingChangeSignalResult = z.infer<typeof breakingChangeSignalResultSchema>;