jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/clause-kind/index.js

@@ -0,0 +1,18 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { clauseKindInputSchema, clauseKindResultSchema } from './schema.js';
+export async function clauseKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = clauseKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What does clause primarily do, given any context? Judge the operative effect of the clause on the parties, not its heading, length, or formality. A clause that mixes effects is graded by its main one.', {
+        obligation: 'The clause requires a party to do something.',
+        right: 'The clause permits or entitles a party to do something.',
+        prohibition: 'The clause forbids a party from doing something.',
+        condition: 'The clause makes something apply only if a stated circumstance occurs, without itself imposing the requirement.',
+        definition: 'The clause defines a term for use elsewhere in the document.',
+        unclear: 'The primary effect of the clause is not established by the supplied text.',
+    }, options);
+    return clauseKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { clauseKindInputSchema, clauseKindResultSchema, clauseKindVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const clauseKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    obligation: "obligation";
+    right: "right";
+    prohibition: "prohibition";
+    condition: "condition";
+    definition: "definition";
+}>;
+export declare const clauseKindInputSchema: z.ZodObject<{
+    clause: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const clauseKindResultSchema: 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";
+        obligation: "obligation";
+        right: "right";
+        prohibition: "prohibition";
+        condition: "condition";
+        definition: "definition";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        obligation: "obligation";
+        right: "right";
+        prohibition: "prohibition";
+        condition: "condition";
+        definition: "definition";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ClauseKindInput = z.infer<typeof clauseKindInputSchema>;
+export type ClauseKindResult = z.infer<typeof clauseKindResultSchema>;
+export type ClauseKindVerdict = z.infer<typeof clauseKindVerdictSchema>;

package/dist/recipes/clause-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const clauseKindVerdictSchema = z.enum([
+    'obligation',
+    'right',
+    'prohibition',
+    'condition',
+    'definition',
+    'unclear',
+]);
+export const clauseKindInputSchema = z.object({
+    clause: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const clauseKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: clauseKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(clauseKindVerdictSchema, probability),
+});

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

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "headline": "This One Kitchen Habit Is Secretly Destroying Your Health - Doctors Are Stunned",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.92,
+        "confidence": 0.62,
+        "probabilities": { "0": 0.01, "1": 0.04, "2": 0.15, "3": 0.62, "4": 0.18 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClickbaitLevelInput, ClickbaitLevelResult } from './schema.js';
+export declare function clickbaitLevel(input: ClickbaitLevelInput, options?: RecipeOptions): Promise<ClickbaitLevelResult>;
+export { clickbaitLevelInputSchema, clickbaitLevelResultSchema, clickbaitLevelVerdictSchema, } from './schema.js';
+export type { ClickbaitLevelInput, ClickbaitLevelResult, ClickbaitLevelVerdict } from './schema.js';

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

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { clickbaitLevelInputSchema, clickbaitLevelResultSchema, clickbaitLevelVerdictSchema, } from './schema.js';
+export async function clickbaitLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = clickbaitLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How heavily does headline rely on bait rather than information? Look for withheld key facts ("you won\'t believe what happened"), unsupported superlatives or absolutes, manufactured urgency, second-person emotional hooks, and numbered-list teasers that hide the substance. A headline that plainly states the subject and finding is low; one that gives almost no information and exists only to provoke a click is high. Ignore topic, length, and whether the claim is true.', [
+        'The headline states the subject and main point plainly with no withheld facts, superlatives, or emotional hooks.',
+        'The headline is mostly informative but adds one light hook such as a soft superlative or a gentle question.',
+        'The headline withholds a key fact or leans on exaggeration so the reader must click to learn the actual point.',
+        'The headline is dominated by curiosity gaps, absolutes, or emotional appeals and gives only a vague hint of the content.',
+        'The headline conveys almost no information about the content and consists only of bait such as shock, outrage, or a promised secret.',
+    ], options);
+    return clickbaitLevelResultSchema.parse({
+        ...decision,
+        bait: clickbaitLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { clickbaitLevelInputSchema, clickbaitLevelResultSchema, clickbaitLevelVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const clickbaitLevelVerdictSchema: z.ZodEnum<{
+    none: "none";
+    moderate: "moderate";
+    mild: "mild";
+    heavy: "heavy";
+    extreme: "extreme";
+}>;
+export declare const clickbaitLevelInputSchema: z.ZodObject<{
+    headline: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const clickbaitLevelResultSchema: 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>;
+    bait: z.ZodEnum<{
+        none: "none";
+        moderate: "moderate";
+        mild: "mild";
+        heavy: "heavy";
+        extreme: "extreme";
+    }>;
+}, z.core.$strip>;
+export type ClickbaitLevelVerdict = z.infer<typeof clickbaitLevelVerdictSchema>;
+export type ClickbaitLevelInput = z.infer<typeof clickbaitLevelInputSchema>;
+export type ClickbaitLevelResult = z.infer<typeof clickbaitLevelResultSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const clickbaitLevelVerdictSchema = z.enum(['none', 'mild', 'moderate', 'heavy', 'extreme']);
+export const clickbaitLevelInputSchema = z.object({
+    headline: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const clickbaitLevelResultSchema = scoreResultSchema.extend({
+    bait: clickbaitLevelVerdictSchema,
+});

package/dist/recipes/commit-message-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "message": "Fix off-by-one in pagination cursor and add regression test",
+    "change": "In paginate() in src/api/list.ts, changed the end index from offset + limit to offset + limit - 1 so the last page no longer repeats the first row of the next page. Added the test 'returns the last page without a duplicate row' to tests/list.test.ts.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.93 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/commit-message-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CommitMessageFitInput, CommitMessageFitResult } from './schema.js';
+export declare function commitMessageFit(input: CommitMessageFitInput, options?: RecipeOptions): Promise<CommitMessageFitResult>;
+export { commitMessageFitInputSchema, commitMessageFitResultSchema, commitMessageFitVerdictSchema, } from './schema.js';
+export type { CommitMessageFitInput, CommitMessageFitResult, CommitMessageFitVerdict, } from './schema.js';

package/dist/recipes/commit-message-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { commitMessageFitInputSchema, commitMessageFitResultSchema } from './schema.js';
+export async function commitMessageFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = commitMessageFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does message accurately describe change? A message fits when every material part of change is reflected and nothing is claimed that change does not contain. Wording, tense, and brevity do not matter. Omitting a trivial detail does not count; omitting a distinct behavior change or claiming work that is absent does.', {
+        true: 'The message covers every material part of the change and claims nothing the change does not do.',
+        false: 'The message omits a material part of the change or claims work that the change does not contain.',
+    }, options);
+    return commitMessageFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'mismatched',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { commitMessageFitInputSchema, commitMessageFitResultSchema, commitMessageFitVerdictSchema, } from './schema.js';

package/dist/recipes/commit-message-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const commitMessageFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    mismatched: "mismatched";
+}>;
+export declare const commitMessageFitInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    change: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const commitMessageFitResultSchema: 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";
+        mismatched: "mismatched";
+    }>;
+}, z.core.$strip>;
+export type CommitMessageFitVerdict = z.infer<typeof commitMessageFitVerdictSchema>;
+export type CommitMessageFitInput = z.infer<typeof commitMessageFitInputSchema>;
+export type CommitMessageFitResult = z.infer<typeof commitMessageFitResultSchema>;

package/dist/recipes/commit-message-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const commitMessageFitVerdictSchema = z.enum(['fits', 'mismatched']);
+export const commitMessageFitInputSchema = z.object({
+    message: nonEmptyText,
+    change: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const commitMessageFitResultSchema = gateResultSchema.extend({
+    verdict: commitMessageFitVerdictSchema,
+});

package/dist/recipes/commitment-strength/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "statement": "I will have the revised contract in your inbox by 5pm Thursday, and I will call you as soon as it is sent.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.85,
+        "confidence": 0.87,
+        "probabilities": { "0": 0.0, "1": 0.0, "2": 0.02, "3": 0.11, "4": 0.87 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/commitment-strength/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CommitmentStrengthInput, CommitmentStrengthResult } from './schema.js';
+export declare function commitmentStrength(input: CommitmentStrengthInput, options?: RecipeOptions): Promise<CommitmentStrengthResult>;
+export { commitmentStrengthInputSchema, commitmentStrengthResultSchema, commitmentStrengthVerdictSchema, } from './schema.js';
+export type { CommitmentStrengthInput, CommitmentStrengthResult, CommitmentStrengthVerdict, } from './schema.js';

package/dist/recipes/commitment-strength/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { commitmentStrengthInputSchema, commitmentStrengthResultSchema, commitmentStrengthVerdictSchema, } from './schema.js';
+export async function commitmentStrength(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = commitmentStrengthInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How firmly does statement commit its speaker to an action or outcome, given any context? Judge the expressed wording only, not whether the speaker will follow through.', [
+        'The wording makes no commitment or explicitly refuses.',
+        'The wording raises a vague possibility with no stated intention to act.',
+        'The wording states an intention hedged by conditions, caveats, or uncertainty.',
+        'The wording states a firm intention to act without specific terms.',
+        'The wording makes a binding promise with specific terms such as what, when, or how.',
+    ], options);
+    return commitmentStrengthResultSchema.parse({
+        ...decision,
+        commitment: commitmentStrengthVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { commitmentStrengthInputSchema, commitmentStrengthResultSchema, commitmentStrengthVerdictSchema, } from './schema.js';

package/dist/recipes/commitment-strength/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const commitmentStrengthVerdictSchema: z.ZodEnum<{
+    none: "none";
+    vague: "vague";
+    conditional: "conditional";
+    firm: "firm";
+    binding: "binding";
+}>;
+export declare const commitmentStrengthInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const commitmentStrengthResultSchema: 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>;
+    commitment: z.ZodEnum<{
+        none: "none";
+        vague: "vague";
+        conditional: "conditional";
+        firm: "firm";
+        binding: "binding";
+    }>;
+}, z.core.$strip>;
+export type CommitmentStrengthVerdict = z.infer<typeof commitmentStrengthVerdictSchema>;
+export type CommitmentStrengthInput = z.infer<typeof commitmentStrengthInputSchema>;
+export type CommitmentStrengthResult = z.infer<typeof commitmentStrengthResultSchema>;

package/dist/recipes/commitment-strength/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const commitmentStrengthVerdictSchema = z.enum([
+    'none',
+    'vague',
+    'conditional',
+    'firm',
+    'binding',
+]);
+export const commitmentStrengthInputSchema = z.object({
+    statement: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const commitmentStrengthResultSchema = scoreResultSchema.extend({
+    commitment: commitmentStrengthVerdictSchema,
+});

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

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "subject": "Single-family ranch, 3 bedrooms, 2 baths, 1,650 sq ft, built 1978, updated kitchen and roof (2019), attached 2-car garage, 0.3-acre lot on a quiet suburban cul-de-sac in Maple Grove.",
+    "comparable": "Condominium, 2 bedrooms, 2 baths, 1,100 sq ft, built 2015, 14th floor of a downtown high-rise with concierge, one deeded parking space, HOA dues $610/month.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.04 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ComparableFitInput, ComparableFitResult } from './schema.js';
+export declare function comparableFit(input: ComparableFitInput, options?: RecipeOptions): Promise<ComparableFitResult>;
+export { comparableFitInputSchema, comparableFitResultSchema, comparableFitVerdictSchema, } from './schema.js';
+export type { ComparableFitInput, ComparableFitResult, ComparableFitVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { comparableFitInputSchema, comparableFitResultSchema } from './schema.js';
+export async function comparableFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = comparableFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Compare the descriptions of subject and comparable and decide whether comparable is similar enough to support a valuation comparison. Weigh property type, size, bedroom and bathroom count, age, condition, and how the location is described. A comparable fits when it is the same general type of property in broadly similar size, age, and condition in a similar kind of location; it does not fit when it differs in type, or differs so much in size, age, condition, or setting that an appraiser would not adjust from it. Judge only what the two descriptions state; ignore prices, sale dates, and any attribute neither description mentions.', {
+        true: 'The comparable is the same general property type as the subject and its described size, room count, age, condition, and location are close enough that a valuation could reasonably adjust from it.',
+        false: 'The comparable differs from the subject in property type or differs substantially in size, age, condition, or setting, so that a valuation could not reasonably adjust from it.',
+    }, options);
+    return comparableFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'comparable' : 'dissimilar',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { comparableFitInputSchema, comparableFitResultSchema, comparableFitVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const comparableFitVerdictSchema: z.ZodEnum<{
+    comparable: "comparable";
+    dissimilar: "dissimilar";
+}>;
+export declare const comparableFitInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    comparable: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const comparableFitResultSchema: 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<{
+        comparable: "comparable";
+        dissimilar: "dissimilar";
+    }>;
+}, z.core.$strip>;
+export type ComparableFitVerdict = z.infer<typeof comparableFitVerdictSchema>;
+export type ComparableFitInput = z.infer<typeof comparableFitInputSchema>;
+export type ComparableFitResult = z.infer<typeof comparableFitResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const comparableFitVerdictSchema = z.enum(['comparable', 'dissimilar']);
+export const comparableFitInputSchema = z.object({
+    subject: nonEmptyText,
+    comparable: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const comparableFitResultSchema = gateResultSchema.extend({
+    verdict: comparableFitVerdictSchema,
+});

package/dist/recipes/consent-request/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "text": "Before we enable call recording on your account, we need your permission. Do you agree to have your support calls recorded for quality review? Reply YES to agree or NO to keep recording off.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.95 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/consent-request/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ConsentRequestInput, ConsentRequestResult } from './schema.js';
+export declare function consentRequest(input: ConsentRequestInput, options?: RecipeOptions): Promise<ConsentRequestResult>;
+export { consentRequestInputSchema, consentRequestResultSchema, consentRequestVerdictSchema, } from './schema.js';
+export type { ConsentRequestInput, ConsentRequestResult, ConsentRequestVerdict } from './schema.js';

package/dist/recipes/consent-request/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { consentRequestInputSchema, consentRequestResultSchema } from './schema.js';
+export async function consentRequest(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = consentRequestInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does text explicitly ask the reader for agreement or permission before something proceeds? Count a direct question or instruction that invites the reader to accept, agree, opt in, or grant permission, where the action waits on that answer. Do not count text that merely informs the reader that something will happen, states that continuing implies agreement, or describes consent that has already been given.', {
+        true: 'The text asks the reader to agree or grant permission before proceeding.',
+        false: 'The text informs, assumes, or records consent without asking for it.',
+    }, options);
+    return consentRequestResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'requested' : 'absent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { consentRequestInputSchema, consentRequestResultSchema, consentRequestVerdictSchema, } from './schema.js';

package/dist/recipes/consent-request/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const consentRequestVerdictSchema: z.ZodEnum<{
+    absent: "absent";
+    requested: "requested";
+}>;
+export declare const consentRequestInputSchema: z.ZodObject<{
+    text: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const consentRequestResultSchema: 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<{
+        absent: "absent";
+        requested: "requested";
+    }>;
+}, z.core.$strip>;
+export type ConsentRequestVerdict = z.infer<typeof consentRequestVerdictSchema>;
+export type ConsentRequestInput = z.infer<typeof consentRequestInputSchema>;
+export type ConsentRequestResult = z.infer<typeof consentRequestResultSchema>;

package/dist/recipes/consent-request/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const consentRequestVerdictSchema = z.enum(['requested', 'absent']);
+export const consentRequestInputSchema = z.object({
+    text: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const consentRequestResultSchema = gateResultSchema.extend({
+    verdict: consentRequestVerdictSchema,
+});

package/dist/recipes/consent-scope-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "consent": "I authorize Riverside Family Clinic to share my visit summaries and lab results with my cardiologist, Dr. Anita Patel, for the purpose of coordinating my heart care. This authorization expires one year from the date signed.",
+    "use": "Send the patient's lab results to a pharmaceutical company's research registry for a hypertension study.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.03 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/consent-scope-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ConsentScopeFitInput, ConsentScopeFitResult } from './schema.js';
+export declare function consentScopeFit(input: ConsentScopeFitInput, options?: RecipeOptions): Promise<ConsentScopeFitResult>;
+export { consentScopeFitInputSchema, consentScopeFitResultSchema, consentScopeFitVerdictSchema, } from './schema.js';
+export type { ConsentScopeFitInput, ConsentScopeFitResult, ConsentScopeFitVerdict, } from './schema.js';

package/dist/recipes/consent-scope-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { consentScopeFitInputSchema, consentScopeFitResultSchema } from './schema.js';
+export async function consentScopeFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = consentScopeFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does the wording of consent cover the described use? Compare what the consent text says the patient agrees to, including who may act, what information or action is involved, and for what purpose, against use. Judge by the plain meaning of the words; the use is uncovered when it involves a party, purpose, information type, or action that the consent does not mention or excludes. Do not judge whether the consent is legally valid, properly obtained, or still in force.', {
+        true: 'The described use falls within the parties, information, actions, and purposes that the consent wording permits.',
+        false: 'The described use involves a party, purpose, information type, or action that the consent wording does not permit or does not mention.',
+    }, options);
+    return consentScopeFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'covered' : 'uncovered',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { consentScopeFitInputSchema, consentScopeFitResultSchema, consentScopeFitVerdictSchema, } from './schema.js';

package/dist/recipes/consent-scope-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const consentScopeFitVerdictSchema: z.ZodEnum<{
+    covered: "covered";
+    uncovered: "uncovered";
+}>;
+export declare const consentScopeFitInputSchema: z.ZodObject<{
+    consent: z.ZodString;
+    use: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const consentScopeFitResultSchema: 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<{
+        covered: "covered";
+        uncovered: "uncovered";
+    }>;
+}, z.core.$strip>;
+export type ConsentScopeFitVerdict = z.infer<typeof consentScopeFitVerdictSchema>;
+export type ConsentScopeFitInput = z.infer<typeof consentScopeFitInputSchema>;
+export type ConsentScopeFitResult = z.infer<typeof consentScopeFitResultSchema>;

package/dist/recipes/consent-scope-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const consentScopeFitVerdictSchema = z.enum(['covered', 'uncovered']);
+export const consentScopeFitInputSchema = z.object({
+    consent: nonEmptyText,
+    use: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const consentScopeFitResultSchema = gateResultSchema.extend({
+    verdict: consentScopeFitVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "article": "Why every small team should ship a status page\n\nAfter running infrastructure for three startups over eight years, I am convinced that a public status page is the highest-leverage reliability investment a small team can make. When we added one at my last company, support tickets during incidents dropped from an average of 41 to 9, because customers could see we already knew. It also forced us to define what \"degraded\" meant, which improved our own alerting. Start today: pick a hosted provider, list your five most visible services, and link the page from your app footer before the next incident finds you.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesThesis": { "type": "noul", "noul": 0.93 },
+      "providesEvidence": { "type": "noul", "noul": 0.9 },
+      "addressesCounterarguments": { "type": "noul", "noul": 0.12 },
+      "includesCallToAction": { "type": "noul", "noul": 0.88 },
+      "signalsExpertise": { "type": "noul", "noul": 0.91 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}