jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/instruction-readability/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const instructionReadabilityVerdictSchema: z.ZodEnum<{
+    mixed: "mixed";
+    heavy: "heavy";
+    clear: "clear";
+    dense: "dense";
+    plain: "plain";
+}>;
+export declare const instructionReadabilityInputSchema: z.ZodObject<{
+    instructions: z.ZodString;
+    audience: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const instructionReadabilityResultSchema: 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>;
+    readability: z.ZodEnum<{
+        mixed: "mixed";
+        heavy: "heavy";
+        clear: "clear";
+        dense: "dense";
+        plain: "plain";
+    }>;
+}, z.core.$strip>;
+export type InstructionReadabilityVerdict = z.infer<typeof instructionReadabilityVerdictSchema>;
+export type InstructionReadabilityInput = z.infer<typeof instructionReadabilityInputSchema>;
+export type InstructionReadabilityResult = z.infer<typeof instructionReadabilityResultSchema>;

package/dist/recipes/instruction-readability/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const instructionReadabilityVerdictSchema = z.enum([
+    'dense',
+    'heavy',
+    'mixed',
+    'plain',
+    'clear',
+]);
+export const instructionReadabilityInputSchema = z.object({
+    instructions: nonEmptyText,
+    audience: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const instructionReadabilityResultSchema = scoreResultSchema.extend({
+    readability: instructionReadabilityVerdictSchema,
+});

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

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "report": "My Telecaster has developed a metallic buzz on the low E and A strings whenever I fret anything between the 5th and 9th frets. Open strings are fine and it still tunes up normally. It only started after I swapped to a heavier string set last week.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "buzz_or_rattle",
+        "confidence": 0.9,
+        "probabilities": {
+          "tuning": 0.02,
+          "buzz_or_rattle": 0.9,
+          "no_sound": 0.01,
+          "intonation": 0.02,
+          "mechanical": 0.03,
+          "cosmetic": 0,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { InstrumentIssueKindInput, InstrumentIssueKindResult } from './schema.js';
+export declare function instrumentIssueKind(input: InstrumentIssueKindInput, options?: RecipeOptions): Promise<InstrumentIssueKindResult>;
+export { instrumentIssueKindInputSchema, instrumentIssueKindResultSchema, instrumentIssueKindVerdictSchema, } from './schema.js';
+export type { InstrumentIssueKindInput, InstrumentIssueKindResult, InstrumentIssueKindVerdict, } from './schema.js';

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

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { instrumentIssueKindInputSchema, instrumentIssueKindResultSchema } from './schema.js';
+export async function instrumentIssueKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = instrumentIssueKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "Read report, a player's description of a problem with a musical instrument, and decide which kind of problem it describes based only on the symptom as worded. Pick the single kind the report presses most. Distinguish tuning (the instrument will not hold or reach pitch at all) from intonation (it is in tune in one place but out of tune in another register or up the neck). Use unclear when report does not describe a symptom clearly enough to classify. Do not guess the cause, the repair, or the cost.", {
+        tuning: 'The report says the instrument will not stay in tune, drifts, slips, or cannot be brought to pitch at all.',
+        buzz_or_rattle: 'The report describes an unwanted buzz, rattle, hum, or clank when the instrument is played or handled.',
+        no_sound: 'The report says the instrument, its electronics, or its output produces no sound, cuts out, or is silent on some notes or channels.',
+        intonation: 'The report says the instrument is in tune when open or in one register but out of tune when played up the neck, in another register, or on certain notes.',
+        mechanical: 'The report describes a part that is stuck, loose, broken, sluggish, or misaligned, such as keys, valves, pedals, tuners, action, or a bridge.',
+        cosmetic: 'The report describes only finish, appearance, or surface damage such as scratches, dents, fading, or cracked lacquer that does not affect playing.',
+        unclear: 'The report does not describe a symptom clearly enough to tell what kind of problem it is.',
+    }, options);
+    return instrumentIssueKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { instrumentIssueKindInputSchema, instrumentIssueKindResultSchema, instrumentIssueKindVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const instrumentIssueKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    tuning: "tuning";
+    buzz_or_rattle: "buzz_or_rattle";
+    no_sound: "no_sound";
+    intonation: "intonation";
+    mechanical: "mechanical";
+    cosmetic: "cosmetic";
+}>;
+export declare const instrumentIssueKindInputSchema: z.ZodObject<{
+    report: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const instrumentIssueKindResultSchema: 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";
+        tuning: "tuning";
+        buzz_or_rattle: "buzz_or_rattle";
+        no_sound: "no_sound";
+        intonation: "intonation";
+        mechanical: "mechanical";
+        cosmetic: "cosmetic";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        tuning: "tuning";
+        buzz_or_rattle: "buzz_or_rattle";
+        no_sound: "no_sound";
+        intonation: "intonation";
+        mechanical: "mechanical";
+        cosmetic: "cosmetic";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type InstrumentIssueKindVerdict = z.infer<typeof instrumentIssueKindVerdictSchema>;
+export type InstrumentIssueKindInput = z.infer<typeof instrumentIssueKindInputSchema>;
+export type InstrumentIssueKindResult = z.infer<typeof instrumentIssueKindResultSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const instrumentIssueKindVerdictSchema = z.enum([
+    'tuning',
+    'buzz_or_rattle',
+    'no_sound',
+    'intonation',
+    'mechanical',
+    'cosmetic',
+    'unclear',
+]);
+export const instrumentIssueKindInputSchema = z.object({
+    report: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const instrumentIssueKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: instrumentIssueKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(instrumentIssueKindVerdictSchema, probability),
+});

package/dist/recipes/instrument-report-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "message": "Hi, I have a Martin D-18 (2019) and the B string has started buzzing on the 2nd and 3rd frets. Open it is fine. This began about ten days ago, right after I changed to a set of light-gauge phosphor bronze strings and lowered the saddle a little myself. I have not changed anything else. Can someone take a look?",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesInstrument": { "type": "noul", "noul": 0.97 },
+      "statesSymptom": { "type": "noul", "noul": 0.96 },
+      "statesOnset": { "type": "noul", "noul": 0.93 },
+      "statesRecentChanges": { "type": "noul", "noul": 0.95 },
+      "statesEnvironment": { "type": "noul", "noul": 0.05 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/instrument-report-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { InstrumentReportFacetsInput, InstrumentReportFacetsResult } from './schema.js';
+export declare function instrumentReportFacets(input: InstrumentReportFacetsInput, options?: RecipeOptions): Promise<InstrumentReportFacetsResult>;
+export { instrumentReportFacetsInputSchema, instrumentReportFacetsResultSchema, instrumentReportFacetsLabelSchema, } from './schema.js';
+export type { InstrumentReportFacetsInput, InstrumentReportFacetsResult, InstrumentReportFacetsLabel, } from './schema.js';

package/dist/recipes/instrument-report-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { instrumentReportFacetsInputSchema, instrumentReportFacetsResultSchema } from './schema.js';
+export async function instrumentReportFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = instrumentReportFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesInstrument: {
+            instruction: 'Does message identify the specific instrument or device, such as a make and model, a serial number, or an equally specific description beyond the generic type?',
+            criteria: {
+                true: 'The message names the make, model, or serial of the instrument or device, or describes it specifically enough to identify the exact product.',
+                false: 'The message names only a generic type such as my guitar, the keyboard, or my trumpet, or does not say what instrument is involved.',
+            },
+        },
+        statesSymptom: {
+            instruction: 'Does message describe what is wrong, such as a buzz, a stuck key, tuning drift, no output, or a crack, rather than saying only that something is broken or not working?',
+            criteria: {
+                true: 'The message describes the specific symptom the player observes, including where or when it happens if that is part of the description.',
+                false: 'The message says only that the instrument is broken, not working, or needs a look, without describing the symptom.',
+            },
+        },
+        statesOnset: {
+            instruction: 'Does message say when the problem started or how long it has been happening?',
+            criteria: {
+                true: 'The message gives a time, date, or duration for when the problem began or how long it has persisted.',
+                false: 'The message does not say when the problem began or how long it has been going on.',
+            },
+        },
+        statesRecentChanges: {
+            instruction: 'Does message mention something that changed shortly before the problem, such as new strings, a setup, a move, a drop, a firmware or software update, new cables, or a different amplifier?',
+            criteria: {
+                true: 'The message names a recent event or change to the instrument, its setup, or its accessories that preceded the problem, or states explicitly that nothing has changed.',
+                false: 'The message says nothing about recent changes, events, or handling before the problem appeared.',
+            },
+        },
+        statesEnvironment: {
+            instruction: 'Does message describe the conditions the instrument is kept or used in, such as humidity, temperature, seasonal change, storage in a case or on a stand, or transport?',
+            criteria: {
+                true: 'The message gives environmental or storage conditions such as humidity or temperature readings, a dry or damp room, heating season, a hot car, or how the instrument is stored.',
+                false: 'The message says nothing about humidity, temperature, storage, or the surroundings the instrument is kept in.',
+            },
+        },
+    }, options);
+    return instrumentReportFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { instrumentReportFacetsInputSchema, instrumentReportFacetsResultSchema, instrumentReportFacetsLabelSchema, } from './schema.js';

package/dist/recipes/instrument-report-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const instrumentReportFacetsLabelSchema: z.ZodEnum<{
+    statesInstrument: "statesInstrument";
+    statesSymptom: "statesSymptom";
+    statesOnset: "statesOnset";
+    statesRecentChanges: "statesRecentChanges";
+    statesEnvironment: "statesEnvironment";
+}>;
+export declare const instrumentReportFacetsInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const instrumentReportFacetsResultSchema: 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<{
+        statesInstrument: "statesInstrument";
+        statesSymptom: "statesSymptom";
+        statesOnset: "statesOnset";
+        statesRecentChanges: "statesRecentChanges";
+        statesEnvironment: "statesEnvironment";
+    }>>;
+    labels: z.ZodObject<{
+        statesInstrument: 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>;
+        statesSymptom: 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>;
+        statesOnset: 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>;
+        statesRecentChanges: 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>;
+        statesEnvironment: 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 InstrumentReportFacetsLabel = z.infer<typeof instrumentReportFacetsLabelSchema>;
+export type InstrumentReportFacetsInput = z.infer<typeof instrumentReportFacetsInputSchema>;
+export type InstrumentReportFacetsResult = z.infer<typeof instrumentReportFacetsResultSchema>;

package/dist/recipes/instrument-report-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const instrumentReportFacetsLabelSchema = z.enum([
+    'statesInstrument',
+    'statesSymptom',
+    'statesOnset',
+    'statesRecentChanges',
+    'statesEnvironment',
+]);
+export const instrumentReportFacetsInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const instrumentReportFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(instrumentReportFacetsLabelSchema),
+    labels: z.object({
+        statesInstrument: labelCheckSchema,
+        statesSymptom: labelCheckSchema,
+        statesOnset: labelCheckSchema,
+        statesRecentChanges: labelCheckSchema,
+        statesEnvironment: labelCheckSchema,
+    }),
+});

package/dist/recipes/intake-question-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "question": "To schedule your flu shot, please tell us your date of birth, your insurance provider and member ID, and whether you have ever been treated for depression or anxiety.",
+    "purpose": "Schedule a routine flu shot appointment and verify insurance coverage for the visit.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.06 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/intake-question-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { IntakeQuestionFitInput, IntakeQuestionFitResult } from './schema.js';
+export declare function intakeQuestionFit(input: IntakeQuestionFitInput, options?: RecipeOptions): Promise<IntakeQuestionFitResult>;
+export { intakeQuestionFitInputSchema, intakeQuestionFitResultSchema, intakeQuestionFitVerdictSchema, } from './schema.js';
+export type { IntakeQuestionFitInput, IntakeQuestionFitResult, IntakeQuestionFitVerdict, } from './schema.js';

package/dist/recipes/intake-question-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { intakeQuestionFitInputSchema, intakeQuestionFitResultSchema } from './schema.js';
+export async function intakeQuestionFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = intakeQuestionFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does question ask only for information that purpose needs? Consider each thing the question asks for and whether it plausibly serves the stated purpose. The question overreaches when it asks for personal detail, history, or identifiers that purpose does not call for, even if that detail might be useful for something else. Do not judge tone, wording quality, or whether collecting the information is legally permitted.', {
+        true: 'Everything the question asks for serves the stated purpose.',
+        false: 'The question asks for at least one detail that the stated purpose does not need.',
+    }, options);
+    return intakeQuestionFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'overreaches',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { intakeQuestionFitInputSchema, intakeQuestionFitResultSchema, intakeQuestionFitVerdictSchema, } from './schema.js';

package/dist/recipes/intake-question-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const intakeQuestionFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    overreaches: "overreaches";
+}>;
+export declare const intakeQuestionFitInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    purpose: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const intakeQuestionFitResultSchema: 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";
+        overreaches: "overreaches";
+    }>;
+}, z.core.$strip>;
+export type IntakeQuestionFitVerdict = z.infer<typeof intakeQuestionFitVerdictSchema>;
+export type IntakeQuestionFitInput = z.infer<typeof intakeQuestionFitInputSchema>;
+export type IntakeQuestionFitResult = z.infer<typeof intakeQuestionFitResultSchema>;

package/dist/recipes/intake-question-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const intakeQuestionFitVerdictSchema = z.enum(['fits', 'overreaches']);
+export const intakeQuestionFitInputSchema = z.object({
+    question: nonEmptyText,
+    purpose: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const intakeQuestionFitResultSchema = gateResultSchema.extend({
+    verdict: intakeQuestionFitVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "invoice": "Northwind Design Studio\n412 Harbor St, Portland OR\n\nINVOICE #2024-0187\nBill to: Acme Robotics, Attn: Accounts Payable\n\n1. Landing page redesign, 24 hrs @ $120/hr ........ $2,880.00\n2. Icon set (32 icons) ................................ $640.00\n\nSubtotal: $3,520.00\nTax (0%): $0.00\nTotal due: $3,520.00\n\nThank you for your business.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesVendor": { "type": "noul", "noul": 0.97 },
+      "statesInvoiceNumber": { "type": "noul", "noul": 0.95 },
+      "statesDueDate": { "type": "noul", "noul": 0.12 },
+      "statesLineItems": { "type": "noul", "noul": 0.93 },
+      "statesTotals": { "type": "noul", "noul": 0.96 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { InvoiceFacetsInput, InvoiceFacetsResult } from './schema.js';
+export declare function invoiceFacets(input: InvoiceFacetsInput, options?: RecipeOptions): Promise<InvoiceFacetsResult>;
+export { invoiceFacetsInputSchema, invoiceFacetsResultSchema, invoiceFacetsLabelSchema, } from './schema.js';
+export type { InvoiceFacetsInput, InvoiceFacetsResult, InvoiceFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { invoiceFacetsInputSchema, invoiceFacetsResultSchema } from './schema.js';
+export async function invoiceFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = invoiceFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesVendor: {
+            instruction: 'Does invoice state who issued it, such as a business name, sender name, or seller identity?',
+            criteria: {
+                true: 'The text names the business or person issuing the invoice.',
+                false: 'The text does not identify who issued the invoice.',
+            },
+        },
+        statesInvoiceNumber: {
+            instruction: 'Does invoice state an invoice number or reference identifier for the invoice itself?',
+            criteria: {
+                true: 'The text gives an invoice number, reference number, or similar identifier for this invoice.',
+                false: 'The text gives no identifier for the invoice; order or account numbers alone do not count.',
+            },
+        },
+        statesDueDate: {
+            instruction: 'Does invoice state when payment is due, as a date or as payment terms that fix one?',
+            criteria: {
+                true: 'The text states a due date or payment terms such as a number of days from the invoice date.',
+                false: 'The text does not say when payment is due.',
+            },
+        },
+        statesLineItems: {
+            instruction: 'Does invoice list one or more individual items or services being billed?',
+            criteria: {
+                true: 'The text itemizes at least one product, service, or charge separately from the total.',
+                false: 'The text gives only a lump amount or no breakdown of what is billed.',
+            },
+        },
+        statesTotals: {
+            instruction: 'Does invoice state a total amount due, with or without a tax or subtotal breakdown?',
+            criteria: {
+                true: 'The text states a total amount due, a subtotal plus tax, or an equivalent summary of what is owed.',
+                false: 'The text does not state a total or summary amount owed.',
+            },
+        },
+    }, options);
+    return invoiceFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { invoiceFacetsInputSchema, invoiceFacetsResultSchema, invoiceFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const invoiceFacetsLabelSchema: z.ZodEnum<{
+    statesVendor: "statesVendor";
+    statesInvoiceNumber: "statesInvoiceNumber";
+    statesDueDate: "statesDueDate";
+    statesLineItems: "statesLineItems";
+    statesTotals: "statesTotals";
+}>;
+export declare const invoiceFacetsInputSchema: z.ZodObject<{
+    invoice: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const invoiceFacetsResultSchema: 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<{
+        statesVendor: "statesVendor";
+        statesInvoiceNumber: "statesInvoiceNumber";
+        statesDueDate: "statesDueDate";
+        statesLineItems: "statesLineItems";
+        statesTotals: "statesTotals";
+    }>>;
+    labels: z.ZodObject<{
+        statesVendor: 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>;
+        statesInvoiceNumber: 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>;
+        statesDueDate: 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>;
+        statesLineItems: 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>;
+        statesTotals: 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 InvoiceFacetsLabel = z.infer<typeof invoiceFacetsLabelSchema>;
+export type InvoiceFacetsInput = z.infer<typeof invoiceFacetsInputSchema>;
+export type InvoiceFacetsResult = z.infer<typeof invoiceFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const invoiceFacetsLabelSchema = z.enum([
+    'statesVendor',
+    'statesInvoiceNumber',
+    'statesDueDate',
+    'statesLineItems',
+    'statesTotals',
+]);
+export const invoiceFacetsInputSchema = z.object({
+    invoice: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const invoiceFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(invoiceFacetsLabelSchema),
+    labels: z.object({
+        statesVendor: labelCheckSchema,
+        statesInvoiceNumber: labelCheckSchema,
+        statesDueDate: labelCheckSchema,
+        statesLineItems: labelCheckSchema,
+        statesTotals: labelCheckSchema,
+    }),
+});