jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/politeness-level/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { politenessLevelInputSchema, politenessLevelResultSchema, politenessLevelVerdictSchema, } from './schema.js';
+export async function politenessLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = politenessLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, "How polite is the wording of message toward its recipient, given any context? Judge the expressed wording only, not the writer's intent or the recipient's reaction.", [
+        'The wording is hostile or insulting toward the recipient.',
+        'The wording is curt or dismissive, with no softening or courtesy.',
+        'The wording is neutral and businesslike, neither rude nor notably courteous.',
+        'The wording is courteous, using greetings, thanks, or softened requests.',
+        'The wording is deferential or effusively polite, with repeated thanks, apologies, or honorifics.',
+    ], options);
+    return politenessLevelResultSchema.parse({
+        ...decision,
+        politeness: politenessLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { politenessLevelInputSchema, politenessLevelResultSchema, politenessLevelVerdictSchema, } from './schema.js';

package/dist/recipes/politeness-level/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const politenessLevelVerdictSchema: z.ZodEnum<{
+    neutral: "neutral";
+    hostile: "hostile";
+    curt: "curt";
+    courteous: "courteous";
+    deferential: "deferential";
+}>;
+export declare const politenessLevelInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const politenessLevelResultSchema: 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>;
+    politeness: z.ZodEnum<{
+        neutral: "neutral";
+        hostile: "hostile";
+        curt: "curt";
+        courteous: "courteous";
+        deferential: "deferential";
+    }>;
+}, z.core.$strip>;
+export type PolitenessLevelVerdict = z.infer<typeof politenessLevelVerdictSchema>;
+export type PolitenessLevelInput = z.infer<typeof politenessLevelInputSchema>;
+export type PolitenessLevelResult = z.infer<typeof politenessLevelResultSchema>;

package/dist/recipes/politeness-level/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const politenessLevelVerdictSchema = z.enum([
+    'hostile',
+    'curt',
+    'neutral',
+    'courteous',
+    'deferential',
+]);
+export const politenessLevelInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const politenessLevelResultSchema = scoreResultSchema.extend({
+    politeness: politenessLevelVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "postmortem": "Incident 2026-09-18: checkout failures. 10:12 UTC: alert on checkout 5xx rate fired. 10:15: on-call acknowledged and confirmed failures in the order-confirmation step. 10:31: deploy of order-service 3.8.0 identified as the trigger and rolled back. 10:36: error rate returned to baseline. Impact: for 24 minutes, roughly 18% of checkout attempts failed at confirmation, affecting all regions. Root cause: 3.8.0 changed the idempotency key format, and the confirmation step rejected keys written by 3.7.x instances still running during the rolling deploy. Action items: (1) add a compatibility test for mixed-version idempotency keys; (2) add a canary stage to the order-service pipeline; (3) document the key format in the service contract.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesTimeline": { "type": "noul", "noul": 0.95 },
+      "statesRootCause": { "type": "noul", "noul": 0.92 },
+      "statesImpact": { "type": "noul", "noul": 0.9 },
+      "statesContributingFactors": { "type": "noul", "noul": 0.12 },
+      "statesActionItems": { "type": "noul", "noul": 0.94 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PostmortemFacetsInput, PostmortemFacetsResult } from './schema.js';
+export declare function postmortemFacets(input: PostmortemFacetsInput, options?: RecipeOptions): Promise<PostmortemFacetsResult>;
+export { postmortemFacetsInputSchema, postmortemFacetsResultSchema, postmortemFacetsLabelSchema, } from './schema.js';
+export type { PostmortemFacetsInput, PostmortemFacetsResult, PostmortemFacetsLabel, } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { postmortemFacetsInputSchema, postmortemFacetsResultSchema } from './schema.js';
+export async function postmortemFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = postmortemFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesTimeline: {
+            instruction: 'Does postmortem give a sequence of events with times or clear ordering, from detection through resolution?',
+            criteria: {
+                true: 'The postmortem lays out ordered events with timestamps or an explicit sequence covering at least detection and resolution.',
+                false: 'The postmortem gives no ordered sequence of events, or mentions only a single point in time.',
+            },
+        },
+        statesRootCause: {
+            instruction: 'Does postmortem state a specific underlying cause of the incident, beyond restating the symptom?',
+            criteria: {
+                true: 'The postmortem names a specific cause that explains why the failure happened, such as a code change, configuration, or capacity limit.',
+                false: 'The postmortem restates the symptom, says the cause is unknown, or omits a cause entirely.',
+            },
+        },
+        statesImpact: {
+            instruction: 'Does postmortem describe the effect on customers or users, such as who was affected, what failed for them, and for how long?',
+            criteria: {
+                true: 'The postmortem describes user-facing impact with at least one of affected population, affected functionality, or duration.',
+                false: 'The postmortem describes only internal effects or does not describe impact at all.',
+            },
+        },
+        statesContributingFactors: {
+            instruction: 'Does postmortem name additional conditions that made the incident worse or more likely, distinct from the root cause, such as missing alerts, gaps in testing, or slow escalation?',
+            criteria: {
+                true: 'The postmortem lists at least one contributing condition separate from the primary cause.',
+                false: 'The postmortem gives only the primary cause with no separate contributing conditions.',
+            },
+        },
+        statesActionItems: {
+            instruction: 'Does postmortem list concrete follow-up actions intended to prevent recurrence or reduce impact?',
+            criteria: {
+                true: 'The postmortem lists at least one specific follow-up task, with or without an owner or date.',
+                false: 'The postmortem lists no follow-up tasks, or only says that lessons were learned.',
+            },
+        },
+    }, options);
+    return postmortemFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { postmortemFacetsInputSchema, postmortemFacetsResultSchema, postmortemFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const postmortemFacetsLabelSchema: z.ZodEnum<{
+    statesTimeline: "statesTimeline";
+    statesRootCause: "statesRootCause";
+    statesImpact: "statesImpact";
+    statesContributingFactors: "statesContributingFactors";
+    statesActionItems: "statesActionItems";
+}>;
+export declare const postmortemFacetsInputSchema: z.ZodObject<{
+    postmortem: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const postmortemFacetsResultSchema: 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<{
+        statesTimeline: "statesTimeline";
+        statesRootCause: "statesRootCause";
+        statesImpact: "statesImpact";
+        statesContributingFactors: "statesContributingFactors";
+        statesActionItems: "statesActionItems";
+    }>>;
+    labels: z.ZodObject<{
+        statesTimeline: 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>;
+        statesRootCause: 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>;
+        statesImpact: 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>;
+        statesContributingFactors: 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>;
+        statesActionItems: 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 PostmortemFacetsLabel = z.infer<typeof postmortemFacetsLabelSchema>;
+export type PostmortemFacetsInput = z.infer<typeof postmortemFacetsInputSchema>;
+export type PostmortemFacetsResult = z.infer<typeof postmortemFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const postmortemFacetsLabelSchema = z.enum([
+    'statesTimeline',
+    'statesRootCause',
+    'statesImpact',
+    'statesContributingFactors',
+    'statesActionItems',
+]);
+export const postmortemFacetsInputSchema = z.object({
+    postmortem: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const postmortemFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(postmortemFacetsLabelSchema),
+    labels: z.object({
+        statesTimeline: labelCheckSchema,
+        statesRootCause: labelCheckSchema,
+        statesImpact: labelCheckSchema,
+        statesContributingFactors: labelCheckSchema,
+        statesActionItems: labelCheckSchema,
+    }),
+});

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

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

package/dist/recipes/priority-compare/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "criteria": "Customer-facing outages come first. Then anything blocking another team. Internal refactors are scheduled last and only when nothing else is waiting.",
+    "firstTask": "Rename the internal config helpers for consistency across the billing service.",
+    "secondTask": "Fix the checkout page returning a 500 for customers paying with a saved card.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "second",
+        "confidence": 0.93,
+        "probabilities": {
+          "first": 0.02,
+          "second": 0.93,
+          "tie": 0.02,
+          "neither": 0.01,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/priority-compare/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PriorityCompareInput, PriorityCompareResult } from './schema.js';
+export declare function priorityCompare(input: PriorityCompareInput, options?: RecipeOptions): Promise<PriorityCompareResult>;
+export { priorityCompareInputSchema, priorityCompareResultSchema, priorityCompareVerdictSchema, } from './schema.js';
+export type { PriorityCompareInput, PriorityCompareResult, PriorityCompareVerdict, } from './schema.js';

package/dist/recipes/priority-compare/index.js

@@ -0,0 +1,16 @@
+import { evaluateComparison } from '../../src/comparisons.js';
+import { priorityCompareInputSchema, priorityCompareResultSchema } from './schema.js';
+export async function priorityCompare(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = priorityCompareInputSchema.parse(input);
+    const decision = await evaluateComparison(state, 'Which of firstTask and secondTask should be done first under criteria? Apply only the stated criteria, such as deadlines, impact, dependencies, or effort, and not a general sense of importance. A task the criteria exclude or defer entirely should not be done at all.', {
+        first: 'Under the criteria, the first task should be done before the second.',
+        second: 'Under the criteria, the second task should be done before the first.',
+        tie: 'Under the criteria, the order of the two tasks does not matter.',
+        neither: 'Under the criteria, neither task should be done at all.',
+    }, options);
+    return priorityCompareResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { priorityCompareInputSchema, priorityCompareResultSchema, priorityCompareVerdictSchema, } from './schema.js';

package/dist/recipes/priority-compare/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const priorityCompareVerdictSchema: z.ZodEnum<{
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+    unclear: "unclear";
+}>;
+export declare const priorityCompareInputSchema: z.ZodObject<{
+    criteria: z.ZodString;
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const priorityCompareResultSchema: 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<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PriorityCompareVerdict = z.infer<typeof priorityCompareVerdictSchema>;
+export type PriorityCompareInput = z.infer<typeof priorityCompareInputSchema>;
+export type PriorityCompareResult = z.infer<typeof priorityCompareResultSchema>;

package/dist/recipes/priority-compare/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { comparisonResultSchema, comparisonVerdictSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const priorityCompareVerdictSchema = comparisonVerdictSchema;
+export const priorityCompareInputSchema = z.object({
+    criteria: nonEmptyText,
+    firstTask: nonEmptyText,
+    secondTask: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const priorityCompareResultSchema = comparisonResultSchema;

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "notice": "When you create an account we collect your name, email address, and billing details. We use this information to provide the service, process payments, and send account notices. We share billing details with our payment processor and do not sell your data. Questions about your data can be sent to privacy@example.com.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesDataCollected": { "type": "noul", "noul": 0.97 },
+      "statesPurpose": { "type": "noul", "noul": 0.95 },
+      "statesRetention": { "type": "noul", "noul": 0.04 },
+      "statesSharing": { "type": "noul", "noul": 0.93 },
+      "statesContact": { "type": "noul", "noul": 0.96 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PrivacyNoticeFacetsInput, PrivacyNoticeFacetsResult } from './schema.js';
+export declare function privacyNoticeFacets(input: PrivacyNoticeFacetsInput, options?: RecipeOptions): Promise<PrivacyNoticeFacetsResult>;
+export { privacyNoticeFacetsInputSchema, privacyNoticeFacetsResultSchema, privacyNoticeFacetsLabelSchema, } from './schema.js';
+export type { PrivacyNoticeFacetsInput, PrivacyNoticeFacetsResult, PrivacyNoticeFacetsLabel, } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { privacyNoticeFacetsInputSchema, privacyNoticeFacetsResultSchema } from './schema.js';
+export async function privacyNoticeFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = privacyNoticeFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesDataCollected: {
+            instruction: 'Does notice state what personal data is collected from or about the reader?',
+            criteria: {
+                true: 'The notice names the categories or items of personal data that are collected.',
+                false: 'The notice does not say what personal data is collected.',
+            },
+        },
+        statesPurpose: {
+            instruction: 'Does notice state why the collected data is used?',
+            criteria: {
+                true: 'The notice states at least one purpose for which the data is used.',
+                false: 'The notice does not say why the data is used.',
+            },
+        },
+        statesRetention: {
+            instruction: 'Does notice state how long the collected data is kept?',
+            criteria: {
+                true: 'The notice states a retention period or the criteria that determine it.',
+                false: 'The notice does not say how long the data is kept.',
+            },
+        },
+        statesSharing: {
+            instruction: 'Does notice state who the collected data is shared with, or that it is not shared?',
+            criteria: {
+                true: 'The notice names the recipients or categories of recipients, or states that data is not shared.',
+                false: 'The notice does not address who receives the data.',
+            },
+        },
+        statesContact: {
+            instruction: 'Does notice state how to contact the organization or controller responsible for the data?',
+            criteria: {
+                true: 'The notice gives a contact method such as an email address, postal address, form, or phone number.',
+                false: 'The notice gives no way to contact the responsible party.',
+            },
+        },
+    }, options);
+    return privacyNoticeFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { privacyNoticeFacetsInputSchema, privacyNoticeFacetsResultSchema, privacyNoticeFacetsLabelSchema, } from './schema.js';

package/dist/recipes/privacy-notice-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const privacyNoticeFacetsLabelSchema: z.ZodEnum<{
+    statesContact: "statesContact";
+    statesDataCollected: "statesDataCollected";
+    statesPurpose: "statesPurpose";
+    statesRetention: "statesRetention";
+    statesSharing: "statesSharing";
+}>;
+export declare const privacyNoticeFacetsInputSchema: z.ZodObject<{
+    notice: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const privacyNoticeFacetsResultSchema: 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<{
+        statesContact: "statesContact";
+        statesDataCollected: "statesDataCollected";
+        statesPurpose: "statesPurpose";
+        statesRetention: "statesRetention";
+        statesSharing: "statesSharing";
+    }>>;
+    labels: z.ZodObject<{
+        statesDataCollected: 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>;
+        statesPurpose: 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>;
+        statesRetention: 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>;
+        statesSharing: 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>;
+        statesContact: 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 PrivacyNoticeFacetsLabel = z.infer<typeof privacyNoticeFacetsLabelSchema>;
+export type PrivacyNoticeFacetsInput = z.infer<typeof privacyNoticeFacetsInputSchema>;
+export type PrivacyNoticeFacetsResult = z.infer<typeof privacyNoticeFacetsResultSchema>;

package/dist/recipes/privacy-notice-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const privacyNoticeFacetsLabelSchema = z.enum([
+    'statesDataCollected',
+    'statesPurpose',
+    'statesRetention',
+    'statesSharing',
+    'statesContact',
+]);
+export const privacyNoticeFacetsInputSchema = z.object({
+    notice: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const privacyNoticeFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(privacyNoticeFacetsLabelSchema),
+    labels: z.object({
+        statesDataCollected: labelCheckSchema,
+        statesPurpose: labelCheckSchema,
+        statesRetention: labelCheckSchema,
+        statesSharing: labelCheckSchema,
+        statesContact: labelCheckSchema,
+    }),
+});

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

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "request": "Looking for a stainless steel water bottle, at least 32 oz, that fits a standard car cup holder. Must be dishwasher safe. A straw lid would be nice but is not required.",
+    "listing": "Summit 40 oz Insulated Bottle. 18/8 stainless steel, double-wall vacuum insulation. Tapered base fits most car cup holders. Dishwasher safe (top rack). Includes screw-top lid; straw lid sold separately.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.91 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ProductMatchInput, ProductMatchResult } from './schema.js';
+export declare function productMatch(input: ProductMatchInput, options?: RecipeOptions): Promise<ProductMatchResult>;
+export { productMatchInputSchema, productMatchResultSchema, productMatchVerdictSchema, } from './schema.js';
+export type { ProductMatchInput, ProductMatchResult, ProductMatchVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { productMatchInputSchema, productMatchResultSchema } from './schema.js';
+export async function productMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = productMatchInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does listing describe a product that satisfies what request asks for? Every attribute request states as required, such as size, material, compatibility, color, or quantity, must be met by the listing. Preferences that request marks as optional or nice-to-have do not disqualify a listing. When the listing is silent on a required attribute, treat it as not satisfied. Judge only the supplied text.', {
+        true: 'The listing describes a product that meets every stated must-have attribute of the request.',
+        false: 'The listing describes a different product or fails at least one stated must-have attribute.',
+    }, options);
+    return productMatchResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'matches' : 'mismatched',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { productMatchInputSchema, productMatchResultSchema, productMatchVerdictSchema, } from './schema.js';