jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/listing-fact-consistency/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "description": "Welcome to this beautifully maintained four-bedroom colonial on a half-acre lot. The 2,400 sq ft layout offers a renovated kitchen, hardwood floors throughout, a finished basement, and a two-car attached garage. Built in 1994 and lovingly updated, this home is move-in ready.",
+    "facts": "Property type: Single-family, colonial\nBedrooms: 3\nBathrooms: 2.5\nLiving area: 2,380 sq ft\nLot size: 0.5 acres\nYear built: 1994\nGarage: 2-car attached\nBasement: Unfinished\nFlooring: Hardwood, carpet",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.95 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/listing-fact-consistency/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ListingFactConsistencyInput, ListingFactConsistencyResult } from './schema.js';
+export declare function listingFactConsistency(input: ListingFactConsistencyInput, options?: RecipeOptions): Promise<ListingFactConsistencyResult>;
+export { listingFactConsistencyInputSchema, listingFactConsistencyResultSchema, listingFactConsistencyVerdictSchema, } from './schema.js';
+export type { ListingFactConsistencyInput, ListingFactConsistencyResult, ListingFactConsistencyVerdict, } from './schema.js';

package/dist/recipes/listing-fact-consistency/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { listingFactConsistencyInputSchema, listingFactConsistencyResultSchema } from './schema.js';
+export async function listingFactConsistency(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = listingFactConsistencyInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Compare the description with the facts sheet and decide whether description states anything that contradicts a value or feature given in facts, such as a different bedroom count, a different size, a different year built, or a feature that facts says is absent. Judge contradiction only: description may omit facts, add detail not in facts, or use marketing language without contradicting anything. Ignore tone, typos, and whether either input is plausible on its own.', {
+        true: 'The description states at least one value or feature that conflicts with what facts gives for the same attribute, beyond ordinary rounding or synonyms.',
+        false: 'Every value or feature the description states either matches facts or concerns an attribute facts does not cover.',
+    }, options);
+    return listingFactConsistencyResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'contradicts' : 'consistent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { listingFactConsistencyInputSchema, listingFactConsistencyResultSchema, listingFactConsistencyVerdictSchema, } from './schema.js';

package/dist/recipes/listing-fact-consistency/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const listingFactConsistencyVerdictSchema: z.ZodEnum<{
+    consistent: "consistent";
+    contradicts: "contradicts";
+}>;
+export declare const listingFactConsistencyInputSchema: z.ZodObject<{
+    description: z.ZodString;
+    facts: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const listingFactConsistencyResultSchema: 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<{
+        consistent: "consistent";
+        contradicts: "contradicts";
+    }>;
+}, z.core.$strip>;
+export type ListingFactConsistencyVerdict = z.infer<typeof listingFactConsistencyVerdictSchema>;
+export type ListingFactConsistencyInput = z.infer<typeof listingFactConsistencyInputSchema>;
+export type ListingFactConsistencyResult = z.infer<typeof listingFactConsistencyResultSchema>;

package/dist/recipes/listing-fact-consistency/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const listingFactConsistencyVerdictSchema = z.enum(['contradicts', 'consistent']);
+export const listingFactConsistencyInputSchema = z.object({
+    description: nonEmptyText,
+    facts: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const listingFactConsistencyResultSchema = gateResultSchema.extend({
+    verdict: listingFactConsistencyVerdictSchema,
+});

package/dist/recipes/log-line-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "line": "2026-09-23T14:02:11Z WARN db.pool: connection pool at 87% capacity, above the 80% threshold; new requests may queue",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "warning",
+        "confidence": 0.82,
+        "probabilities": {
+          "error": 0.03,
+          "warning": 0.82,
+          "lifecycle": 0.01,
+          "request": 0.01,
+          "metric": 0.1,
+          "debug": 0.02,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/log-line-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { LogLineKindInput, LogLineKindResult } from './schema.js';
+export declare function logLineKind(input: LogLineKindInput, options?: RecipeOptions): Promise<LogLineKindResult>;
+export { logLineKindInputSchema, logLineKindResultSchema, logLineKindVerdictSchema, } from './schema.js';
+export type { LogLineKindInput, LogLineKindResult, LogLineKindVerdict } from './schema.js';

package/dist/recipes/log-line-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { logLineKindInputSchema, logLineKindResultSchema } from './schema.js';
+export async function logLineKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = logLineKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What does line report? Judge the event the text of line describes, using any level token as one signal among others. Ignore timestamps, logger names, and identifiers except where they clarify the event.', {
+        error: 'The line reports an operation that failed, an exception, or a state the system could not handle.',
+        warning: 'The line reports a condition that succeeded or continues but is abnormal, near a limit, or likely to cause trouble.',
+        lifecycle: 'The line reports a process or component starting, stopping, reloading, or loading configuration.',
+        request: 'The line reports a handled request, message, or job, typically with a method, path, status, or duration.',
+        metric: 'The line reports a periodic measurement or counter with no event attached, such as a heap size or queue depth sample.',
+        debug: 'The line reports internal state or a trace step useful only to a developer, with no operational event.',
+        unclear: 'The line does not describe a recognizable event, or the text is too fragmentary to classify.',
+    }, options);
+    return logLineKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { logLineKindInputSchema, logLineKindResultSchema, logLineKindVerdictSchema, } from './schema.js';

package/dist/recipes/log-line-kind/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const logLineKindVerdictSchema: z.ZodEnum<{
+    error: "error";
+    unclear: "unclear";
+    debug: "debug";
+    request: "request";
+    warning: "warning";
+    lifecycle: "lifecycle";
+    metric: "metric";
+}>;
+export declare const logLineKindInputSchema: z.ZodObject<{
+    line: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const logLineKindResultSchema: 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<{
+        error: "error";
+        unclear: "unclear";
+        debug: "debug";
+        request: "request";
+        warning: "warning";
+        lifecycle: "lifecycle";
+        metric: "metric";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        error: "error";
+        unclear: "unclear";
+        debug: "debug";
+        request: "request";
+        warning: "warning";
+        lifecycle: "lifecycle";
+        metric: "metric";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type LogLineKindVerdict = z.infer<typeof logLineKindVerdictSchema>;
+export type LogLineKindInput = z.infer<typeof logLineKindInputSchema>;
+export type LogLineKindResult = z.infer<typeof logLineKindResultSchema>;

package/dist/recipes/log-line-kind/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const logLineKindVerdictSchema = z.enum([
+    'error',
+    'warning',
+    'lifecycle',
+    'request',
+    'metric',
+    'debug',
+    'unclear',
+]);
+export const logLineKindInputSchema = z.object({
+    line: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const logLineKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: logLineKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(logLineKindVerdictSchema, probability),
+});

package/dist/recipes/loss-cause-kind/demo.json

@@ -0,0 +1,28 @@
+{
+  "input": {
+    "narrative": "We returned from a long weekend on Monday evening and found the back door forced open, with the frame splintered around the deadbolt. Two laptops, my wife's jewelry box, a camera bag, and the cash we kept in the desk drawer were gone. Drawers were pulled out in every bedroom. We called the police that night and have a report number; the neighbor's doorbell camera shows two people in the yard at around 3 am on Sunday.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "theft",
+        "confidence": 0.91,
+        "probabilities": {
+          "weather": 0.01,
+          "fire": 0,
+          "water": 0.01,
+          "theft": 0.91,
+          "collision": 0,
+          "wear_and_tear": 0,
+          "vandalism": 0.04,
+          "other": 0.01,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/loss-cause-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { LossCauseKindInput, LossCauseKindResult } from './schema.js';
+export declare function lossCauseKind(input: LossCauseKindInput, options?: RecipeOptions): Promise<LossCauseKindResult>;
+export { lossCauseKindInputSchema, lossCauseKindResultSchema, lossCauseKindVerdictSchema, } from './schema.js';
+export type { LossCauseKindInput, LossCauseKindResult, LossCauseKindVerdict } from './schema.js';

package/dist/recipes/loss-cause-kind/index.js

@@ -0,0 +1,21 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { lossCauseKindInputSchema, lossCauseKindResultSchema } from './schema.js';
+export async function lossCauseKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = lossCauseKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Decide which cause of loss narrative describes. Judge from what the claimant says caused the damage or loss, not from the type of damage alone. When the narrative describes a chain of events, choose the initiating cause it presents as responsible. Choose unclear when the narrative does not say what caused the loss or gives several causes with no dominant one.', {
+        weather: 'The narrative attributes the loss to a weather event such as wind, hail, lightning, a storm, flooding from rainfall, snow load, or freezing temperatures.',
+        fire: 'The narrative attributes the loss to fire, smoke, or an explosion.',
+        water: 'The narrative attributes the loss to water from plumbing, appliances, roofs, or sewer backup rather than from a weather event.',
+        theft: 'The narrative attributes the loss to property being stolen, including burglary, robbery, or a break-in where items were taken.',
+        collision: 'The narrative attributes the loss to a vehicle, vessel, or object striking or being struck by another vehicle or object.',
+        wear_and_tear: 'The narrative attributes the loss to gradual deterioration, aging, corrosion, or lack of maintenance rather than a sudden event.',
+        vandalism: 'The narrative attributes the loss to deliberate damage or defacement by someone, without property being taken.',
+        other: 'The narrative clearly states a cause that fits none of the listed categories, such as a falling tree with no weather involved, an animal, or a dropped object.',
+        unclear: 'The narrative does not say what caused the loss, or it names several causes with no dominant one.',
+    }, options);
+    return lossCauseKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { lossCauseKindInputSchema, lossCauseKindResultSchema, lossCauseKindVerdictSchema, } from './schema.js';

package/dist/recipes/loss-cause-kind/schema.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const lossCauseKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    other: "other";
+    weather: "weather";
+    fire: "fire";
+    water: "water";
+    theft: "theft";
+    collision: "collision";
+    wear_and_tear: "wear_and_tear";
+    vandalism: "vandalism";
+}>;
+export declare const lossCauseKindInputSchema: z.ZodObject<{
+    narrative: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const lossCauseKindResultSchema: 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";
+        other: "other";
+        weather: "weather";
+        fire: "fire";
+        water: "water";
+        theft: "theft";
+        collision: "collision";
+        wear_and_tear: "wear_and_tear";
+        vandalism: "vandalism";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        other: "other";
+        weather: "weather";
+        fire: "fire";
+        water: "water";
+        theft: "theft";
+        collision: "collision";
+        wear_and_tear: "wear_and_tear";
+        vandalism: "vandalism";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type LossCauseKindVerdict = z.infer<typeof lossCauseKindVerdictSchema>;
+export type LossCauseKindInput = z.infer<typeof lossCauseKindInputSchema>;
+export type LossCauseKindResult = z.infer<typeof lossCauseKindResultSchema>;

package/dist/recipes/loss-cause-kind/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const lossCauseKindVerdictSchema = z.enum([
+    'weather',
+    'fire',
+    'water',
+    'theft',
+    'collision',
+    'wear_and_tear',
+    'vandalism',
+    'other',
+    'unclear',
+]);
+export const lossCauseKindInputSchema = z.object({
+    narrative: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const lossCauseKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: lossCauseKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(lossCauseKindVerdictSchema, probability),
+});

package/dist/recipes/lyric-mood-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "lyrics": "Hands up, we don't stop till the sun comes up\nBass in the trunk and the whole crew showed up\nNo sleep tonight, turn the lights down low\nOne more round and then we go, go, go",
+    "music": "Slow, sparse piano ballad in D minor at 62 bpm with long sustained chords and a single cello line, written to underscore a grieving scene in a short film.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.04 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/lyric-mood-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { LyricMoodFitInput, LyricMoodFitResult } from './schema.js';
+export declare function lyricMoodFit(input: LyricMoodFitInput, options?: RecipeOptions): Promise<LyricMoodFitResult>;
+export { lyricMoodFitInputSchema, lyricMoodFitResultSchema, lyricMoodFitVerdictSchema, } from './schema.js';
+export type { LyricMoodFitInput, LyricMoodFitResult, LyricMoodFitVerdict } from './schema.js';

package/dist/recipes/lyric-mood-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { lyricMoodFitInputSchema, lyricMoodFitResultSchema } from './schema.js';
+export async function lyricMoodFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = lyricMoodFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Do lyrics fit the mood and pacing of the music described in music? Compare the emotional tone, energy, imagery, and density of the words in lyrics against the mood, tempo, genre, and intended use that music describes. Deliberate contrast counts as a fit only when music says the contrast is intended. Do not judge rhyme, meter, syllable counts, or how good the lyrics are.', {
+        true: 'The emotional tone, energy, and pacing of lyrics agree with the mood, tempo, and purpose described in music, or contrast with them in a way music says is intended.',
+        false: 'The emotional tone, energy, or pacing of lyrics conflicts with the mood, tempo, or purpose described in music, and music does not call for that contrast.',
+    }, options);
+    return lyricMoodFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'clashes',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { lyricMoodFitInputSchema, lyricMoodFitResultSchema, lyricMoodFitVerdictSchema, } from './schema.js';

package/dist/recipes/lyric-mood-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const lyricMoodFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    clashes: "clashes";
+}>;
+export declare const lyricMoodFitInputSchema: z.ZodObject<{
+    lyrics: z.ZodString;
+    music: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const lyricMoodFitResultSchema: 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";
+        clashes: "clashes";
+    }>;
+}, z.core.$strip>;
+export type LyricMoodFitVerdict = z.infer<typeof lyricMoodFitVerdictSchema>;
+export type LyricMoodFitInput = z.infer<typeof lyricMoodFitInputSchema>;
+export type LyricMoodFitResult = z.infer<typeof lyricMoodFitResultSchema>;

package/dist/recipes/lyric-mood-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const lyricMoodFitVerdictSchema = z.enum(['fits', 'clashes']);
+export const lyricMoodFitInputSchema = z.object({
+    lyrics: nonEmptyText,
+    music: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const lyricMoodFitResultSchema = gateResultSchema.extend({
+    verdict: lyricMoodFitVerdictSchema,
+});

package/dist/recipes/maintenance-hazard-wording/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "request": "Unit 4B. Since this morning there's a strong gas smell in the kitchen, strongest near the stove even with all the burners off. I opened the windows. Can someone come take a look when they get a chance? Thanks.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.96 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/maintenance-hazard-wording/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MaintenanceHazardWordingInput, MaintenanceHazardWordingResult } from './schema.js';
+export declare function maintenanceHazardWording(input: MaintenanceHazardWordingInput, options?: RecipeOptions): Promise<MaintenanceHazardWordingResult>;
+export { maintenanceHazardWordingInputSchema, maintenanceHazardWordingResultSchema, maintenanceHazardWordingVerdictSchema, } from './schema.js';
+export type { MaintenanceHazardWordingInput, MaintenanceHazardWordingResult, MaintenanceHazardWordingVerdict, } from './schema.js';

package/dist/recipes/maintenance-hazard-wording/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { maintenanceHazardWordingInputSchema, maintenanceHazardWordingResultSchema, } from './schema.js';
+export async function maintenanceHazardWording(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = maintenanceHazardWordingInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Read the maintenance request and decide whether it describes a safety hazard: a gas or burning smell, active water intrusion or flooding, exposed or sparking wiring, structural damage such as a sagging ceiling or cracked support, loss of heat during cold weather, a blocked or non-functioning exit, or a comparable threat to occupants. Judge what request describes, not how urgently it is worded: a calm report of a gas smell is a hazard and an angry report of a dripping faucet is routine. Ignore tone, length, and whether the tenant proposes a fix.', {
+        true: 'The request describes a condition that threatens occupant safety, such as a gas smell, active leaking or flooding, exposed or sparking wiring, structural damage, no heat in cold conditions, or a blocked exit.',
+        false: 'The request describes a repair, cosmetic, comfort, or appliance problem that does not threaten occupant safety, such as a dripping faucet, a broken cabinet hinge, or a slow drain.',
+    }, options);
+    return maintenanceHazardWordingResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'hazard' : 'routine',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { maintenanceHazardWordingInputSchema, maintenanceHazardWordingResultSchema, maintenanceHazardWordingVerdictSchema, } from './schema.js';

package/dist/recipes/maintenance-hazard-wording/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const maintenanceHazardWordingVerdictSchema: z.ZodEnum<{
+    hazard: "hazard";
+    routine: "routine";
+}>;
+export declare const maintenanceHazardWordingInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const maintenanceHazardWordingResultSchema: 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<{
+        hazard: "hazard";
+        routine: "routine";
+    }>;
+}, z.core.$strip>;
+export type MaintenanceHazardWordingVerdict = z.infer<typeof maintenanceHazardWordingVerdictSchema>;
+export type MaintenanceHazardWordingInput = z.infer<typeof maintenanceHazardWordingInputSchema>;
+export type MaintenanceHazardWordingResult = z.infer<typeof maintenanceHazardWordingResultSchema>;

package/dist/recipes/maintenance-hazard-wording/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const maintenanceHazardWordingVerdictSchema = z.enum(['hazard', 'routine']);
+export const maintenanceHazardWordingInputSchema = z.object({
+    request: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const maintenanceHazardWordingResultSchema = gateResultSchema.extend({
+    verdict: maintenanceHazardWordingVerdictSchema,
+});

package/dist/recipes/medication-mention/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "message": "I have been taking 20 mg of lisinopril every morning and started a magnesium supplement last week. Since then I feel dizzy when I stand up. Is that normal, or should I stop one of them?",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.97 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/medication-mention/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MedicationMentionInput, MedicationMentionResult } from './schema.js';
+export declare function medicationMention(input: MedicationMentionInput, options?: RecipeOptions): Promise<MedicationMentionResult>;
+export { medicationMentionInputSchema, medicationMentionResultSchema, medicationMentionVerdictSchema, } from './schema.js';
+export type { MedicationMentionInput, MedicationMentionResult, MedicationMentionVerdict, } from './schema.js';

package/dist/recipes/medication-mention/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { medicationMentionInputSchema, medicationMentionResultSchema } from './schema.js';
+export async function medicationMention(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = medicationMentionInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does message mention a medication, supplement, or dosage? Count brand or generic drug names, over-the-counter products, vitamins and herbal supplements, and any dose, strength, or dosing schedule. Do not count general words such as "treatment" or "prescription" with no product named, and do not count medical devices, procedures, or ordinary foods.', {
+        true: 'The message names at least one medication, supplement, or a specific dose or dosing schedule.',
+        false: 'The message names no medication, supplement, dose, or dosing schedule.',
+    }, options);
+    return medicationMentionResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'mentioned' : 'absent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { medicationMentionInputSchema, medicationMentionResultSchema, medicationMentionVerdictSchema, } from './schema.js';

package/dist/recipes/medication-mention/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const medicationMentionVerdictSchema: z.ZodEnum<{
+    absent: "absent";
+    mentioned: "mentioned";
+}>;
+export declare const medicationMentionInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const medicationMentionResultSchema: 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";
+        mentioned: "mentioned";
+    }>;
+}, z.core.$strip>;
+export type MedicationMentionVerdict = z.infer<typeof medicationMentionVerdictSchema>;
+export type MedicationMentionInput = z.infer<typeof medicationMentionInputSchema>;
+export type MedicationMentionResult = z.infer<typeof medicationMentionResultSchema>;

package/dist/recipes/medication-mention/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const medicationMentionVerdictSchema = z.enum(['mentioned', 'absent']);
+export const medicationMentionInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const medicationMentionResultSchema = gateResultSchema.extend({
+    verdict: medicationMentionVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "message": "Following up on ticket 4821: the export still fails with a timeout. Can you escalate this? We need it working before our board meeting on Friday.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "asksQuestion": { "type": "noul", "noul": 0.86 },
+      "reportsProblem": { "type": "noul", "noul": 0.97 },
+      "requestsAction": { "type": "noul", "noul": 0.95 },
+      "statesDeadline": { "type": "noul", "noul": 0.93 },
+      "referencesPriorContact": { "type": "noul", "noul": 0.96 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MessageFacetsInput, MessageFacetsResult } from './schema.js';
+export declare function messageFacets(input: MessageFacetsInput, options?: RecipeOptions): Promise<MessageFacetsResult>;
+export { messageFacetsInputSchema, messageFacetsResultSchema, messageFacetsLabelSchema, } from './schema.js';
+export type { MessageFacetsInput, MessageFacetsResult, MessageFacetsLabel } from './schema.js';