jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/settlement-offer-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { settlementOfferFacetsInputSchema, settlementOfferFacetsResultSchema } from './schema.js';
+export async function settlementOfferFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = settlementOfferFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesAmount: {
+            instruction: 'Does offer state a specific settlement amount or payment figure being offered?',
+            criteria: {
+                true: 'The letter names a monetary amount offered in settlement.',
+                false: 'The letter gives no settlement figure.',
+            },
+        },
+        statesBasis: {
+            instruction: 'Does offer explain how the amount was arrived at, such as an itemized valuation, a depreciation calculation, policy limits, a deductible, or an estimate it relies on?',
+            criteria: {
+                true: 'The letter gives a reason or calculation behind the offered amount.',
+                false: 'The letter states an amount, or none, without explaining its basis.',
+            },
+        },
+        statesDeadline: {
+            instruction: 'Does offer state a date or period by which the recipient must accept, respond, or otherwise act?',
+            criteria: {
+                true: 'The letter names a deadline or response period.',
+                false: 'The letter sets no deadline for responding.',
+            },
+        },
+        statesReleaseTerms: {
+            instruction: 'Does offer state that accepting the payment releases, waives, or closes claims, or otherwise describe what the recipient gives up by accepting?',
+            criteria: {
+                true: 'The letter describes a release, waiver, or full-and-final condition attached to acceptance.',
+                false: 'The letter attaches no release or waiver language to the offer.',
+            },
+        },
+        statesDisputePath: {
+            instruction: 'Does offer tell the recipient how to dispute, appeal, or seek review of the offer, such as an internal appeal process, an ombudsman, a regulator, or an appraisal clause?',
+            criteria: {
+                true: 'The letter names a way to dispute, appeal, or seek review of the offer.',
+                false: 'The letter gives no route for disputing or appealing.',
+            },
+        },
+    }, options);
+    return settlementOfferFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { settlementOfferFacetsInputSchema, settlementOfferFacetsResultSchema, settlementOfferFacetsLabelSchema, } from './schema.js';

package/dist/recipes/settlement-offer-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const settlementOfferFacetsLabelSchema: z.ZodEnum<{
+    statesDeadline: "statesDeadline";
+    statesAmount: "statesAmount";
+    statesBasis: "statesBasis";
+    statesReleaseTerms: "statesReleaseTerms";
+    statesDisputePath: "statesDisputePath";
+}>;
+export declare const settlementOfferFacetsInputSchema: z.ZodObject<{
+    offer: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const settlementOfferFacetsResultSchema: 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<{
+        statesDeadline: "statesDeadline";
+        statesAmount: "statesAmount";
+        statesBasis: "statesBasis";
+        statesReleaseTerms: "statesReleaseTerms";
+        statesDisputePath: "statesDisputePath";
+    }>>;
+    labels: z.ZodObject<{
+        statesAmount: 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>;
+        statesBasis: 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>;
+        statesDeadline: 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>;
+        statesReleaseTerms: 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>;
+        statesDisputePath: 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 SettlementOfferFacetsLabel = z.infer<typeof settlementOfferFacetsLabelSchema>;
+export type SettlementOfferFacetsInput = z.infer<typeof settlementOfferFacetsInputSchema>;
+export type SettlementOfferFacetsResult = z.infer<typeof settlementOfferFacetsResultSchema>;

package/dist/recipes/settlement-offer-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const settlementOfferFacetsLabelSchema = z.enum([
+    'statesAmount',
+    'statesBasis',
+    'statesDeadline',
+    'statesReleaseTerms',
+    'statesDisputePath',
+]);
+export const settlementOfferFacetsInputSchema = z.object({
+    offer: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const settlementOfferFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(settlementOfferFacetsLabelSchema),
+    labels: z.object({
+        statesAmount: labelCheckSchema,
+        statesBasis: labelCheckSchema,
+        statesDeadline: labelCheckSchema,
+        statesReleaseTerms: labelCheckSchema,
+        statesDisputePath: labelCheckSchema,
+    }),
+});

package/dist/recipes/shipment-issue-kind/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "message": "Tracking says my order was delivered yesterday at 2:14 PM but there is nothing on my porch, in the mailbox, or with my neighbors. I have checked everywhere. Order #A81-2290.",
+    "context": "Customer message submitted through the order help form for a small parcel shipment.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "lost",
+        "confidence": 0.9,
+        "probabilities": {
+          "delayed": 0.04,
+          "damaged": 0.01,
+          "lost": 0.9,
+          "wrong_item": 0.01,
+          "address": 0.02,
+          "none": 0.01,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/shipment-issue-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ShipmentIssueKindInput, ShipmentIssueKindResult } from './schema.js';
+export declare function shipmentIssueKind(input: ShipmentIssueKindInput, options?: RecipeOptions): Promise<ShipmentIssueKindResult>;
+export { shipmentIssueKindInputSchema, shipmentIssueKindResultSchema, shipmentIssueKindVerdictSchema, } from './schema.js';
+export type { ShipmentIssueKindInput, ShipmentIssueKindResult, ShipmentIssueKindVerdict, } from './schema.js';

package/dist/recipes/shipment-issue-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { shipmentIssueKindInputSchema, shipmentIssueKindResultSchema } from './schema.js';
+export async function shipmentIssueKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = shipmentIssueKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What shipping problem does message report, given any context? Judge the problem the sender describes with the delivery of their order, not their tone or what remedy they ask for. When several problems are mentioned, choose the one the sender is mainly reporting.', {
+        delayed: 'The shipment is late or has not arrived by the expected date but is still expected to arrive.',
+        damaged: 'The shipment arrived with the item or packaging broken, crushed, leaking, or otherwise harmed.',
+        lost: 'The shipment cannot be located, tracking has stopped, or it was marked delivered but never received.',
+        wrong_item: 'The shipment arrived but contained a different item, quantity, size, or variant than ordered.',
+        address: 'The shipment cannot be delivered because the address is wrong, incomplete, or undeliverable.',
+        none: 'The message does not report a shipping problem.',
+        unclear: 'The message reports a problem whose kind is not established by the supplied text.',
+    }, options);
+    return shipmentIssueKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { shipmentIssueKindInputSchema, shipmentIssueKindResultSchema, shipmentIssueKindVerdictSchema, } from './schema.js';

package/dist/recipes/shipment-issue-kind/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const shipmentIssueKindVerdictSchema: z.ZodEnum<{
+    none: "none";
+    unclear: "unclear";
+    delayed: "delayed";
+    damaged: "damaged";
+    lost: "lost";
+    wrong_item: "wrong_item";
+    address: "address";
+}>;
+export declare const shipmentIssueKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const shipmentIssueKindResultSchema: 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<{
+        none: "none";
+        unclear: "unclear";
+        delayed: "delayed";
+        damaged: "damaged";
+        lost: "lost";
+        wrong_item: "wrong_item";
+        address: "address";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        none: "none";
+        unclear: "unclear";
+        delayed: "delayed";
+        damaged: "damaged";
+        lost: "lost";
+        wrong_item: "wrong_item";
+        address: "address";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ShipmentIssueKindInput = z.infer<typeof shipmentIssueKindInputSchema>;
+export type ShipmentIssueKindResult = z.infer<typeof shipmentIssueKindResultSchema>;
+export type ShipmentIssueKindVerdict = z.infer<typeof shipmentIssueKindVerdictSchema>;

package/dist/recipes/shipment-issue-kind/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const shipmentIssueKindVerdictSchema = z.enum([
+    'delayed',
+    'damaged',
+    'lost',
+    'wrong_item',
+    'address',
+    'none',
+    'unclear',
+]);
+export const shipmentIssueKindInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const shipmentIssueKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: shipmentIssueKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(shipmentIssueKindVerdictSchema, probability),
+});

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

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "proposal": "How about Friday at 3:00 PM for the kickoff call?",
+    "constraints": "I am available weekday afternoons from 1 PM to 5 PM, except Fridays, which I keep meeting-free.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.06 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { SlotFitInput, SlotFitResult } from './schema.js';
+export declare function slotFit(input: SlotFitInput, options?: RecipeOptions): Promise<SlotFitResult>;
+export { slotFitInputSchema, slotFitResultSchema, slotFitVerdictSchema } from './schema.js';
+export type { SlotFitInput, SlotFitResult, SlotFitVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { slotFitInputSchema, slotFitResultSchema } from './schema.js';
+export async function slotFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = slotFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does the time or slot proposed in proposal satisfy every availability constraint written in constraints? Read the constraints as a person would, including day-of-week rules, time-of-day windows, exclusions, and stated exceptions. Count the proposal as fitting only when it falls inside every stated window and outside every stated exclusion. Do not assume a time zone or a date that neither text supplies.', {
+        true: 'The proposed slot satisfies all of the stated availability constraints.',
+        false: 'The proposed slot falls outside at least one stated constraint.',
+    }, options);
+    return slotFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'violates',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { slotFitInputSchema, slotFitResultSchema, slotFitVerdictSchema } from './schema.js';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const slotFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    violates: "violates";
+}>;
+export declare const slotFitInputSchema: z.ZodObject<{
+    proposal: z.ZodString;
+    constraints: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const slotFitResultSchema: 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";
+        violates: "violates";
+    }>;
+}, z.core.$strip>;
+export type SlotFitVerdict = z.infer<typeof slotFitVerdictSchema>;
+export type SlotFitInput = z.infer<typeof slotFitInputSchema>;
+export type SlotFitResult = z.infer<typeof slotFitResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const slotFitVerdictSchema = z.enum(['fits', 'violates']);
+export const slotFitInputSchema = z.object({
+    proposal: nonEmptyText,
+    constraints: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const slotFitResultSchema = gateResultSchema.extend({
+    verdict: slotFitVerdictSchema,
+});

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

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "request": "A warm analog-style pad with a slow attack and some gentle movement, for the intro of a downtempo track.",
+    "patch": "Preset: Dusk Pad. Two sawtooth oscillators detuned 9 cents, one octave down sub sine at -12 dB. 24 dB low-pass filter, cutoff at 35 percent with a slow envelope adding 20 percent over 2 seconds. Amp envelope: attack 1.6 s, decay 0.5 s, sustain 100 percent, release 3.2 s. Slow triangle LFO at 0.15 Hz on filter cutoff, depth 8 percent. Stereo chorus and a long hall reverb at 30 percent mix.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.92 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { SoundMatchInput, SoundMatchResult } from './schema.js';
+export declare function soundMatch(input: SoundMatchInput, options?: RecipeOptions): Promise<SoundMatchResult>;
+export { soundMatchInputSchema, soundMatchResultSchema, soundMatchVerdictSchema, } from './schema.js';
+export type { SoundMatchInput, SoundMatchResult, SoundMatchVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { soundMatchInputSchema, soundMatchResultSchema } from './schema.js';
+export async function soundMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = soundMatchInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does the patch or preset described in patch produce the sound character asked for in request? Compare the qualities request names, such as warmth, brightness, attack, movement, thickness, or genre role, against what patch states in words or implies through its parameters, such as oscillator types, filter settings, envelope times, modulation, and effects. Treat a quality as delivered only when patch supports it; ignore qualities request does not mention. Do not judge whether the patch is well made or which synth it runs on.', {
+        true: 'Every sound quality request asks for is stated or clearly implied by patch, and nothing in patch contradicts a requested quality.',
+        false: 'At least one quality request asks for is absent from patch or contradicted by it, such as a fast attack where a slow one was requested.',
+    }, options);
+    return soundMatchResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'matches' : 'mismatched',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { soundMatchInputSchema, soundMatchResultSchema, soundMatchVerdictSchema, } from './schema.js';

package/dist/recipes/sound-match/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const soundMatchVerdictSchema: z.ZodEnum<{
+    mismatched: "mismatched";
+    matches: "matches";
+}>;
+export declare const soundMatchInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    patch: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const soundMatchResultSchema: 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<{
+        mismatched: "mismatched";
+        matches: "matches";
+    }>;
+}, z.core.$strip>;
+export type SoundMatchVerdict = z.infer<typeof soundMatchVerdictSchema>;
+export type SoundMatchInput = z.infer<typeof soundMatchInputSchema>;
+export type SoundMatchResult = z.infer<typeof soundMatchResultSchema>;

package/dist/recipes/sound-match/schema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const soundMatchVerdictSchema = z.enum(['matches', 'mismatched']);
+export const soundMatchInputSchema = z.object({
+    request: nonEmptyText,
+    patch: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const soundMatchResultSchema = gateResultSchema.extend({ verdict: soundMatchVerdictSchema });

package/dist/recipes/spam-signal/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "message": "Congratulations!! You have been selected for a $500 gift card. Claim now at bit.ly/claim-prize-4421 before it expires tonight!!!",
+    "context": "Reply posted in a community forum thread about troubleshooting a printer driver.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.97 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/spam-signal/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { SpamSignalInput, SpamSignalResult } from './schema.js';
+export declare function spamSignal(input: SpamSignalInput, options?: RecipeOptions): Promise<SpamSignalResult>;
+export { spamSignalInputSchema, spamSignalResultSchema, spamSignalVerdictSchema, } from './schema.js';
+export type { SpamSignalInput, SpamSignalResult, SpamSignalVerdict } from './schema.js';

package/dist/recipes/spam-signal/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { spamSignalInputSchema, spamSignalResultSchema } from './schema.js';
+export async function spamSignal(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = spamSignalInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Is message unsolicited promotional, scam, or bulk content rather than a genuine contribution to the conversation or community, given any context? Count unsolicited advertising, affiliate or referral pushes, phishing and fraud lures, and templated mass postings. Do not count on-topic recommendations, replies to a request for suggestions, or self-promotion that the context permits.', {
+        true: 'The message is unsolicited promotional, scam, or bulk content.',
+        false: 'The message is a genuine contribution to the conversation or community.',
+    }, options);
+    return spamSignalResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'spam' : 'genuine',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { spamSignalInputSchema, spamSignalResultSchema, spamSignalVerdictSchema, } from './schema.js';

package/dist/recipes/spam-signal/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const spamSignalVerdictSchema: z.ZodEnum<{
+    spam: "spam";
+    genuine: "genuine";
+}>;
+export declare const spamSignalInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const spamSignalResultSchema: 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<{
+        spam: "spam";
+        genuine: "genuine";
+    }>;
+}, z.core.$strip>;
+export type SpamSignalVerdict = z.infer<typeof spamSignalVerdictSchema>;
+export type SpamSignalInput = z.infer<typeof spamSignalInputSchema>;
+export type SpamSignalResult = z.infer<typeof spamSignalResultSchema>;

package/dist/recipes/spam-signal/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const spamSignalVerdictSchema = z.enum(['spam', 'genuine']);
+export const spamSignalInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const spamSignalResultSchema = gateResultSchema.extend({
+    verdict: spamSignalVerdictSchema,
+});

package/dist/recipes/stage-evidence/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "stage": "Proposal sent: a written proposal with pricing has been delivered to the decision maker and they have acknowledged receiving it.",
+    "evidence": "Call on Tuesday with Priya (VP Operations) to review requirements. She asked for a formal proposal covering the 40-seat rollout. Rep noted: will draft proposal this week and send Friday. No further activity logged.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.07 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/stage-evidence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { StageEvidenceInput, StageEvidenceResult } from './schema.js';
+export declare function stageEvidence(input: StageEvidenceInput, options?: RecipeOptions): Promise<StageEvidenceResult>;
+export { stageEvidenceInputSchema, stageEvidenceResultSchema, stageEvidenceVerdictSchema, } from './schema.js';
+export type { StageEvidenceInput, StageEvidenceResult, StageEvidenceVerdict } from './schema.js';

package/dist/recipes/stage-evidence/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { stageEvidenceInputSchema, stageEvidenceResultSchema } from './schema.js';
+export async function stageEvidence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = stageEvidenceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does evidence support that the deal has reached stage as described? Count the stage as supported only when the evidence shows the events or conditions the stage description requires have actually happened. Planned, hoped-for, or rep-asserted progress without a matching buyer action does not count. Judge only the supplied evidence.', {
+        true: 'The evidence shows the conditions stage describes have been met.',
+        false: 'The evidence does not show the conditions stage describes have been met.',
+    }, options);
+    return stageEvidenceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'supported' : 'unsupported',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { stageEvidenceInputSchema, stageEvidenceResultSchema, stageEvidenceVerdictSchema, } from './schema.js';

package/dist/recipes/stage-evidence/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const stageEvidenceVerdictSchema: z.ZodEnum<{
+    supported: "supported";
+    unsupported: "unsupported";
+}>;
+export declare const stageEvidenceInputSchema: z.ZodObject<{
+    stage: z.ZodString;
+    evidence: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const stageEvidenceResultSchema: 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<{
+        supported: "supported";
+        unsupported: "unsupported";
+    }>;
+}, z.core.$strip>;
+export type StageEvidenceVerdict = z.infer<typeof stageEvidenceVerdictSchema>;
+export type StageEvidenceInput = z.infer<typeof stageEvidenceInputSchema>;
+export type StageEvidenceResult = z.infer<typeof stageEvidenceResultSchema>;

package/dist/recipes/stage-evidence/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const stageEvidenceVerdictSchema = z.enum(['supported', 'unsupported']);
+export const stageEvidenceInputSchema = z.object({
+    stage: nonEmptyText,
+    evidence: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const stageEvidenceResultSchema = gateResultSchema.extend({
+    verdict: stageEvidenceVerdictSchema,
+});

package/dist/recipes/step-progress/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const stepProgressVerdictSchema: z.ZodEnum<{
-    progress: "progress";
     unclear: "unclear";
+    progress: "progress";
     no_progress: "no_progress";
     setback: "setback";
 }>;
@@ -22,15 +22,15 @@ export declare const stepProgressResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        progress: "progress";
         unclear: "unclear";
+        progress: "progress";
         no_progress: "no_progress";
         setback: "setback";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        progress: "progress";
         unclear: "unclear";
+        progress: "progress";
         no_progress: "no_progress";
         setback: "setback";
     }>, z.ZodNumber>;