jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/deadline-risk/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const deadlineRiskVerdictSchema: z.ZodEnum<{
+    none: "none";
+    moderate: "moderate";
+    high: "high";
+    minor: "minor";
+    missed: "missed";
+}>;
+export declare const deadlineRiskInputSchema: z.ZodObject<{
+    deadline: z.ZodString;
+    progress: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const deadlineRiskResultSchema: 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>;
+    risk: z.ZodEnum<{
+        none: "none";
+        moderate: "moderate";
+        high: "high";
+        minor: "minor";
+        missed: "missed";
+    }>;
+}, z.core.$strip>;
+export type DeadlineRiskVerdict = z.infer<typeof deadlineRiskVerdictSchema>;
+export type DeadlineRiskInput = z.infer<typeof deadlineRiskInputSchema>;
+export type DeadlineRiskResult = z.infer<typeof deadlineRiskResultSchema>;

package/dist/recipes/deadline-risk/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const deadlineRiskVerdictSchema = z.enum(['none', 'minor', 'moderate', 'high', 'missed']);
+export const deadlineRiskInputSchema = z.object({
+    deadline: nonEmptyText,
+    progress: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const deadlineRiskResultSchema = scoreResultSchema.extend({
+    risk: deadlineRiskVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "report": "NCR-2041. Part 88-3312-B mounting bracket, supplier lot L26091 from Kestrel Metalworks. Flange thickness measured 2.68 to 2.74 mm on all 6 sampled pieces against the drawing callout of 3.0 mm +/- 0.1 mm. Found at incoming inspection, receiving dock 2, during the standard AQL sample on 2026-09-22. Lot quantity received: 1,200 pieces; the whole lot is suspect since every sample failed. Requesting disposition from engineering.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesPartId": { "type": "noul", "noul": 0.96 },
+      "statesDefect": { "type": "noul", "noul": 0.95 },
+      "statesDetectionPoint": { "type": "noul", "noul": 0.92 },
+      "statesQuantity": { "type": "noul", "noul": 0.93 },
+      "statesContainment": { "type": "noul", "noul": 0.07 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DefectReportFacetsInput, DefectReportFacetsResult } from './schema.js';
+export declare function defectReportFacets(input: DefectReportFacetsInput, options?: RecipeOptions): Promise<DefectReportFacetsResult>;
+export { defectReportFacetsInputSchema, defectReportFacetsResultSchema, defectReportFacetsLabelSchema, } from './schema.js';
+export type { DefectReportFacetsInput, DefectReportFacetsResult, DefectReportFacetsLabel, } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { defectReportFacetsInputSchema, defectReportFacetsResultSchema } from './schema.js';
+export async function defectReportFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = defectReportFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesPartId: {
+            instruction: 'Does report identify the affected part, material, or lot with a part number, lot number, serial number, or equally specific identifier?',
+            criteria: {
+                true: 'The report gives a part number, lot or batch number, serial number, or drawing number that identifies what is affected.',
+                false: 'The report names the item only generically, such as a bracket or the incoming shipment, with no identifier.',
+            },
+        },
+        statesDefect: {
+            instruction: 'Does report describe what is wrong with the part, such as a dimension out of tolerance, a surface flaw, a missing feature, or a functional failure?',
+            criteria: {
+                true: 'The report describes the specific nonconformance observed, such as a measurement against its specification or a named physical or functional flaw.',
+                false: 'The report says only that parts are defective, rejected, or bad without describing the flaw.',
+            },
+        },
+        statesDetectionPoint: {
+            instruction: 'Does report say where or at what stage the defect was found, such as incoming inspection, a named operation or station, final test, or at the customer?',
+            criteria: {
+                true: 'The report names the inspection point, process step, station, or location where the defect was detected.',
+                false: 'The report does not say where or at what stage the defect was found.',
+            },
+        },
+        statesQuantity: {
+            instruction: 'Does report give how many units are affected, inspected, or suspect, as a count, a sample result, or a lot size?',
+            criteria: {
+                true: 'The report gives a number of affected, rejected, sampled, or suspect units, or the size of the lot in question.',
+                false: 'The report gives no count and uses only words like some, several, or the lot.',
+            },
+        },
+        statesContainment: {
+            instruction: 'Does report state an action already taken or ordered to stop the defective material from moving on, such as a hold, quarantine, tag, segregation, line stop, or sort?',
+            criteria: {
+                true: 'The report states that affected material was placed on hold, quarantined, tagged, segregated, sorted, or that production or shipment was stopped.',
+                false: 'The report states no action that contains the affected material, or mentions containment only as a question or future intention.',
+            },
+        },
+    }, options);
+    return defectReportFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { defectReportFacetsInputSchema, defectReportFacetsResultSchema, defectReportFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const defectReportFacetsLabelSchema: z.ZodEnum<{
+    statesPartId: "statesPartId";
+    statesDefect: "statesDefect";
+    statesDetectionPoint: "statesDetectionPoint";
+    statesQuantity: "statesQuantity";
+    statesContainment: "statesContainment";
+}>;
+export declare const defectReportFacetsInputSchema: z.ZodObject<{
+    report: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const defectReportFacetsResultSchema: 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<{
+        statesPartId: "statesPartId";
+        statesDefect: "statesDefect";
+        statesDetectionPoint: "statesDetectionPoint";
+        statesQuantity: "statesQuantity";
+        statesContainment: "statesContainment";
+    }>>;
+    labels: z.ZodObject<{
+        statesPartId: 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>;
+        statesDefect: 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>;
+        statesDetectionPoint: 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>;
+        statesQuantity: 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>;
+        statesContainment: 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 DefectReportFacetsLabel = z.infer<typeof defectReportFacetsLabelSchema>;
+export type DefectReportFacetsInput = z.infer<typeof defectReportFacetsInputSchema>;
+export type DefectReportFacetsResult = z.infer<typeof defectReportFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const defectReportFacetsLabelSchema = z.enum([
+    'statesPartId',
+    'statesDefect',
+    'statesDetectionPoint',
+    'statesQuantity',
+    'statesContainment',
+]);
+export const defectReportFacetsInputSchema = z.object({
+    report: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const defectReportFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(defectReportFacetsLabelSchema),
+    labels: z.object({
+        statesPartId: labelCheckSchema,
+        statesDefect: labelCheckSchema,
+        statesDetectionPoint: labelCheckSchema,
+        statesQuantity: labelCheckSchema,
+        statesContainment: labelCheckSchema,
+    }),
+});

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

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "subtask": "Find the three most recent production incidents involving the checkout service, pull their postmortem documents from the wiki, and summarize the root causes in a short table.",
+    "capabilities": "Read-only access to the code repository and its git history. Can run the test suite and static analysis. No network access, no wiki or ticketing access, no production logs.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.06 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DelegationFitInput, DelegationFitResult } from './schema.js';
+export declare function delegationFit(input: DelegationFitInput, options?: RecipeOptions): Promise<DelegationFitResult>;
+export { delegationFitInputSchema, delegationFitResultSchema, delegationFitVerdictSchema, } from './schema.js';
+export type { DelegationFitInput, DelegationFitResult, DelegationFitVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { delegationFitInputSchema, delegationFitResultSchema } from './schema.js';
+export async function delegationFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = delegationFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does subtask fall within capabilities, the description of what the delegate can do, may access, and is allowed to decide? Count subtask as fitting only when every part of it can be completed using the tools, access, skills, and permissions capabilities describes. A subtask that needs even one tool, data source, or permission capabilities does not mention is outside. Do not assume capabilities beyond what is written.', {
+        true: 'Every part of the subtask can be completed with the described capabilities.',
+        false: 'Some part of the subtask needs a tool, access, skill, or permission the capabilities do not include.',
+    }, options);
+    return delegationFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'fits' : 'outside',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { delegationFitInputSchema, delegationFitResultSchema, delegationFitVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const delegationFitVerdictSchema: z.ZodEnum<{
+    fits: "fits";
+    outside: "outside";
+}>;
+export declare const delegationFitInputSchema: z.ZodObject<{
+    subtask: z.ZodString;
+    capabilities: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const delegationFitResultSchema: 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";
+        outside: "outside";
+    }>;
+}, z.core.$strip>;
+export type DelegationFitVerdict = z.infer<typeof delegationFitVerdictSchema>;
+export type DelegationFitInput = z.infer<typeof delegationFitInputSchema>;
+export type DelegationFitResult = z.infer<typeof delegationFitResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const delegationFitVerdictSchema = z.enum(['fits', 'outside']);
+export const delegationFitInputSchema = z.object({
+    subtask: nonEmptyText,
+    capabilities: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const delegationFitResultSchema = gateResultSchema.extend({
+    verdict: delegationFitVerdictSchema,
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "disclosure": "Seller's Property Disclosure - 27 Birchwood Lane\n\nRoof: Seller is aware of a leak at the chimney flashing that appears during heavy rain; a stain is visible on the upstairs hallway ceiling. Not yet repaired.\nPlumbing: Water heater replaced in March 2024 (receipt available). Kitchen drain line snaked in 2023.\nBasement: Occasional dampness on the north wall after spring thaw; no standing water observed.\nEnvironmental: Radon test in 2022 measured 3.1 pCi/L; no mitigation system installed. House built in 1968; seller has no knowledge of lead-based paint testing.\nHeating: Furnace original to 1998 addition, serviced annually.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesKnownDefects": { "type": "noul", "noul": 0.97 },
+      "statesPriorRepairs": { "type": "noul", "noul": 0.95 },
+      "statesEnvironmentalHazards": { "type": "noul", "noul": 0.94 },
+      "statesBoundaryIssues": { "type": "noul", "noul": 0.05 },
+      "statesAssociationRules": { "type": "noul", "noul": 0.04 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DisclosureFacetsInput, DisclosureFacetsResult } from './schema.js';
+export declare function disclosureFacets(input: DisclosureFacetsInput, options?: RecipeOptions): Promise<DisclosureFacetsResult>;
+export { disclosureFacetsInputSchema, disclosureFacetsResultSchema, disclosureFacetsLabelSchema, } from './schema.js';
+export type { DisclosureFacetsInput, DisclosureFacetsResult, DisclosureFacetsLabel, } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { disclosureFacetsInputSchema, disclosureFacetsResultSchema } from './schema.js';
+export async function disclosureFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = disclosureFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesKnownDefects: {
+            instruction: 'Does disclosure address known defects or problems with the property, such as leaks, cracks, pests, or failing systems?',
+            criteria: {
+                true: 'The text reports at least one defect or problem, or states that the seller knows of none.',
+                false: 'The text says nothing about defects or problems with the property.',
+            },
+        },
+        statesPriorRepairs: {
+            instruction: 'Does disclosure address repairs, replacements, or remediation previously done on the property?',
+            criteria: {
+                true: 'The text describes past repairs, replacements, or remediation work, or states that none was done.',
+                false: 'The text says nothing about past repair or remediation work.',
+            },
+        },
+        statesEnvironmentalHazards: {
+            instruction: 'Does disclosure address environmental hazards such as radon, lead paint, asbestos, mold, flooding, or contaminated soil or water?',
+            criteria: {
+                true: 'The text reports, tests for, or denies knowledge of an environmental hazard on or affecting the property.',
+                false: 'The text says nothing about environmental hazards.',
+            },
+        },
+        statesBoundaryIssues: {
+            instruction: 'Does disclosure address property boundaries, encroachments, easements, or rights of way?',
+            criteria: {
+                true: 'The text mentions a survey, encroachment, easement, shared driveway, boundary dispute, or states that the seller knows of none.',
+                false: 'The text says nothing about boundaries, encroachments, or easements.',
+            },
+        },
+        statesAssociationRules: {
+            instruction: 'Does disclosure address a homeowners or condominium association, its dues, or its rules and restrictions?',
+            criteria: {
+                true: 'The text mentions an association, its fees, its covenants or restrictions, or states that the property is not subject to one.',
+                false: 'The text says nothing about an association or its rules.',
+            },
+        },
+    }, options);
+    return disclosureFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { disclosureFacetsInputSchema, disclosureFacetsResultSchema, disclosureFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const disclosureFacetsLabelSchema: z.ZodEnum<{
+    statesKnownDefects: "statesKnownDefects";
+    statesPriorRepairs: "statesPriorRepairs";
+    statesEnvironmentalHazards: "statesEnvironmentalHazards";
+    statesBoundaryIssues: "statesBoundaryIssues";
+    statesAssociationRules: "statesAssociationRules";
+}>;
+export declare const disclosureFacetsInputSchema: z.ZodObject<{
+    disclosure: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const disclosureFacetsResultSchema: 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<{
+        statesKnownDefects: "statesKnownDefects";
+        statesPriorRepairs: "statesPriorRepairs";
+        statesEnvironmentalHazards: "statesEnvironmentalHazards";
+        statesBoundaryIssues: "statesBoundaryIssues";
+        statesAssociationRules: "statesAssociationRules";
+    }>>;
+    labels: z.ZodObject<{
+        statesKnownDefects: 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>;
+        statesPriorRepairs: 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>;
+        statesEnvironmentalHazards: 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>;
+        statesBoundaryIssues: 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>;
+        statesAssociationRules: 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 DisclosureFacetsLabel = z.infer<typeof disclosureFacetsLabelSchema>;
+export type DisclosureFacetsInput = z.infer<typeof disclosureFacetsInputSchema>;
+export type DisclosureFacetsResult = z.infer<typeof disclosureFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const disclosureFacetsLabelSchema = z.enum([
+    'statesKnownDefects',
+    'statesPriorRepairs',
+    'statesEnvironmentalHazards',
+    'statesBoundaryIssues',
+    'statesAssociationRules',
+]);
+export const disclosureFacetsInputSchema = z.object({
+    disclosure: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const disclosureFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(disclosureFacetsLabelSchema),
+    labels: z.object({
+        statesKnownDefects: labelCheckSchema,
+        statesPriorRepairs: labelCheckSchema,
+        statesEnvironmentalHazards: labelCheckSchema,
+        statesBoundaryIssues: labelCheckSchema,
+        statesAssociationRules: labelCheckSchema,
+    }),
+});

package/dist/recipes/dispute-kind/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "message": "I cancelled my Pro plan on August 28th and got the confirmation email, but my card was charged $49 again on September 1st. Please reverse it and confirm the account is actually closed this time.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "cancellation_not_honored",
+        "confidence": 0.88,
+        "probabilities": {
+          "duplicate_charge": 0.03,
+          "wrong_amount": 0.02,
+          "unrecognized_charge": 0.02,
+          "refund_not_received": 0.02,
+          "cancellation_not_honored": 0.88,
+          "other": 0.01,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/dispute-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DisputeKindInput, DisputeKindResult } from './schema.js';
+export declare function disputeKind(input: DisputeKindInput, options?: RecipeOptions): Promise<DisputeKindResult>;
+export { disputeKindInputSchema, disputeKindResultSchema, disputeKindVerdictSchema, } from './schema.js';
+export type { DisputeKindInput, DisputeKindResult, DisputeKindVerdict } from './schema.js';

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

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { disputeKindInputSchema, disputeKindResultSchema } from './schema.js';
+export async function disputeKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = disputeKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "Read the customer's message and decide what kind of billing dispute it raises, based only on what the customer claims happened. Pick the single type the message presses most. Use other when the message is clearly a billing complaint that fits none of the named types, and unclear when the message does not describe a billing problem clearly enough to classify. Do not judge whether the claim is correct.", {
+        duplicate_charge: 'The customer says they were charged more than once for the same purchase or period.',
+        wrong_amount: 'The customer says a charge happened but the amount differs from what was expected, quoted, or advertised.',
+        unrecognized_charge: 'The customer says they do not recognize a charge or did not authorize a purchase at all.',
+        refund_not_received: 'The customer says a refund was promised or issued but has not arrived.',
+        cancellation_not_honored: 'The customer says they cancelled a subscription or order but were still charged afterwards.',
+        other: 'The message clearly disputes a bill or charge but fits none of the named types, such as a tax, currency, or fee question.',
+        unclear: 'The message does not describe a billing problem clearly enough to tell what is being disputed.',
+    }, options);
+    return disputeKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { disputeKindInputSchema, disputeKindResultSchema, disputeKindVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const disputeKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    other: "other";
+    duplicate_charge: "duplicate_charge";
+    wrong_amount: "wrong_amount";
+    unrecognized_charge: "unrecognized_charge";
+    refund_not_received: "refund_not_received";
+    cancellation_not_honored: "cancellation_not_honored";
+}>;
+export declare const disputeKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const disputeKindResultSchema: 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";
+        duplicate_charge: "duplicate_charge";
+        wrong_amount: "wrong_amount";
+        unrecognized_charge: "unrecognized_charge";
+        refund_not_received: "refund_not_received";
+        cancellation_not_honored: "cancellation_not_honored";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        other: "other";
+        duplicate_charge: "duplicate_charge";
+        wrong_amount: "wrong_amount";
+        unrecognized_charge: "unrecognized_charge";
+        refund_not_received: "refund_not_received";
+        cancellation_not_honored: "cancellation_not_honored";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type DisputeKindVerdict = z.infer<typeof disputeKindVerdictSchema>;
+export type DisputeKindInput = z.infer<typeof disputeKindInputSchema>;
+export type DisputeKindResult = z.infer<typeof disputeKindResultSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const disputeKindVerdictSchema = z.enum([
+    'duplicate_charge',
+    'wrong_amount',
+    'unrecognized_charge',
+    'refund_not_received',
+    'cancellation_not_honored',
+    'other',
+    'unclear',
+]);
+export const disputeKindInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const disputeKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: disputeKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(disputeKindVerdictSchema, probability),
+});