jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/causal-language-strength/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const causalLanguageStrengthVerdictSchema: z.ZodEnum<{
+    none: "none";
+    association: "association";
+    suggestive: "suggestive";
+    hedged: "hedged";
+    asserted: "asserted";
+}>;
+export declare const causalLanguageStrengthInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const causalLanguageStrengthResultSchema: 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>;
+    causality: z.ZodEnum<{
+        none: "none";
+        association: "association";
+        suggestive: "suggestive";
+        hedged: "hedged";
+        asserted: "asserted";
+    }>;
+}, z.core.$strip>;
+export type CausalLanguageStrengthVerdict = z.infer<typeof causalLanguageStrengthVerdictSchema>;
+export type CausalLanguageStrengthInput = z.infer<typeof causalLanguageStrengthInputSchema>;
+export type CausalLanguageStrengthResult = z.infer<typeof causalLanguageStrengthResultSchema>;

package/dist/recipes/causal-language-strength/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const causalLanguageStrengthVerdictSchema = z.enum([
+    'none',
+    'association',
+    'suggestive',
+    'hedged',
+    'asserted',
+]);
+export const causalLanguageStrengthInputSchema = z.object({
+    statement: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const causalLanguageStrengthResultSchema = scoreResultSchema.extend({
+    causality: causalLanguageStrengthVerdictSchema,
+});

package/dist/recipes/change-risk/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "change": "Replace the session-token validation in the auth middleware with the new JWT verifier, and drop the fallback to the legacy cookie session for all API routes.",
+    "context": "The middleware runs on every authenticated request. About 5% of active users still hold legacy cookie sessions.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.9,
+        "confidence": 0.8,
+        "probabilities": { "0": 0, "1": 0.02, "2": 0.12, "3": 0.8, "4": 0.06 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/change-risk/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ChangeRiskInput, ChangeRiskResult } from './schema.js';
+export declare function changeRisk(input: ChangeRiskInput, options?: RecipeOptions): Promise<ChangeRiskResult>;
+export { changeRiskInputSchema, changeRiskResultSchema, changeRiskVerdictSchema, } from './schema.js';
+export type { ChangeRiskInput, ChangeRiskResult, ChangeRiskVerdict } from './schema.js';

package/dist/recipes/change-risk/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { changeRiskInputSchema, changeRiskResultSchema, changeRiskVerdictSchema, } from './schema.js';
+export async function changeRisk(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = changeRiskInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How risky is change to ship, given any context? Judge the blast radius, the sensitivity of the code paths and data it touches, and how hard the change would be to reverse. Ignore the size of the description.', [
+        'The change touches only documentation, comments, formatting, or dead code with no runtime effect.',
+        'The change is isolated to well-tested logic with a narrow blast radius and an easy rollback.',
+        'The change alters shared code paths, public interfaces, or data shapes that other components depend on.',
+        'The change touches authentication, payments, migrations, concurrency, or a wide blast radius across the system.',
+        'The change carries irreversible data loss or security impact if it is wrong.',
+    ], options);
+    return changeRiskResultSchema.parse({
+        ...decision,
+        risk: changeRiskVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { changeRiskInputSchema, changeRiskResultSchema, changeRiskVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const changeRiskVerdictSchema: z.ZodEnum<{
+    negligible: "negligible";
+    low: "low";
+    moderate: "moderate";
+    high: "high";
+    critical: "critical";
+}>;
+export declare const changeRiskInputSchema: z.ZodObject<{
+    change: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const changeRiskResultSchema: 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<{
+        negligible: "negligible";
+        low: "low";
+        moderate: "moderate";
+        high: "high";
+        critical: "critical";
+    }>;
+}, z.core.$strip>;
+export type ChangeRiskVerdict = z.infer<typeof changeRiskVerdictSchema>;
+export type ChangeRiskInput = z.infer<typeof changeRiskInputSchema>;
+export type ChangeRiskResult = z.infer<typeof changeRiskResultSchema>;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const changeRiskVerdictSchema = z.enum([
+    'negligible',
+    'low',
+    'moderate',
+    'high',
+    'critical',
+]);
+export const changeRiskInputSchema = z.object({
+    change: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const changeRiskResultSchema = scoreResultSchema.extend({
+    risk: changeRiskVerdictSchema,
+});

package/dist/recipes/change-window-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "change": "Deploy payments-service 4.12.1 to production on Friday 2026-09-25 at 16:30 UTC. It patches a rounding bug in refund amounts. Standard rolling deploy, no schema change. Not an emergency; the bug affects about 0.1% of refunds.",
+    "policy": "Production change windows are Monday to Thursday, 09:00 to 17:00 UTC. No production deploys on Fridays, weekends, or during the quarter-end freeze covering the last five business days of each quarter. Emergency fixes may proceed outside windows only with written approval from the incident commander.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.07 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/change-window-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ChangeWindowFitInput, ChangeWindowFitResult } from './schema.js';
+export declare function changeWindowFit(input: ChangeWindowFitInput, options?: RecipeOptions): Promise<ChangeWindowFitResult>;
+export { changeWindowFitInputSchema, changeWindowFitResultSchema, changeWindowFitVerdictSchema, } from './schema.js';
+export type { ChangeWindowFitInput, ChangeWindowFitResult, ChangeWindowFitVerdict, } from './schema.js';

package/dist/recipes/change-window-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { changeWindowFitInputSchema, changeWindowFitResultSchema } from './schema.js';
+export async function changeWindowFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = changeWindowFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does change fall within the change-window or freeze policy stated in policy? Judge only the timing, environment, and change type that change states against the windows, freezes, and exceptions that policy states. Treat a day or date named in change as given; do not compute whether a date is a weekday or falls in a freeze period unless the text states it. Ignore how risky or well-tested the change sounds.', {
+        true: 'The stated timing, environment, and type of change fit within a window that policy permits, or match an exception that policy grants.',
+        false: 'The stated timing, environment, or type of change falls in a period policy forbids or outside every window it permits, and no stated exception applies.',
+    }, options);
+    return changeWindowFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'allowed' : 'blocked',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { changeWindowFitInputSchema, changeWindowFitResultSchema, changeWindowFitVerdictSchema, } from './schema.js';

package/dist/recipes/change-window-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const changeWindowFitVerdictSchema: z.ZodEnum<{
+    allowed: "allowed";
+    blocked: "blocked";
+}>;
+export declare const changeWindowFitInputSchema: z.ZodObject<{
+    change: z.ZodString;
+    policy: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const changeWindowFitResultSchema: 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<{
+        allowed: "allowed";
+        blocked: "blocked";
+    }>;
+}, z.core.$strip>;
+export type ChangeWindowFitVerdict = z.infer<typeof changeWindowFitVerdictSchema>;
+export type ChangeWindowFitInput = z.infer<typeof changeWindowFitInputSchema>;
+export type ChangeWindowFitResult = z.infer<typeof changeWindowFitResultSchema>;

package/dist/recipes/change-window-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const changeWindowFitVerdictSchema = z.enum(['allowed', 'blocked']);
+export const changeWindowFitInputSchema = z.object({
+    change: nonEmptyText,
+    policy: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const changeWindowFitResultSchema = gateResultSchema.extend({
+    verdict: changeWindowFitVerdictSchema,
+});

package/dist/recipes/checkers-move/schema.js

@@ -43,9 +43,8 @@ export const checkersMoveInputSchema = z
     legalMoves: z
         .array(move)
         .min(1)
-        .max(50)
         .refine((moves) => new Set(moves.map((value) => value.id)).size === moves.length, 'Move IDs must be unique.')
-        .describe('One to fifty complete legal moves from your game, with unique IDs.'),
+        .describe('One or more complete legal moves from your game, with unique IDs.'),
     minConfidence: probability.optional(),
 })
     .superRefine((input, context) => {

package/dist/recipes/choose-action/schema.js

@@ -1,11 +1,15 @@
 import { z } from 'zod';
-import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+import { nonEmptyText, probability, selectionResultSchema, textItemSchema, } from '../../src/schema.js';
 export const chooseActionInputSchema = z.object({
     player: nonEmptyText.describe('The player whose next action should be chosen.'),
     objective: nonEmptyText.describe('The goal or scoring preference used to compare eligible actions.'),
     rules: nonEmptyText.describe('Applicable game rules, including turn, phase, resource, and action constraints.'),
     environment: nonEmptyText.describe('The current game snapshot available to the player, after the supplied history.'),
-    actions: textItemsSchema.describe('One to fifty candidate actions with unique IDs and concrete action descriptions.'),
+    actions: z
+        .array(textItemSchema)
+        .min(1)
+        .refine((actions) => new Set(actions.map((action) => action.id)).size === actions.length, 'Action IDs must be unique.')
+        .describe('One or more candidate actions with unique IDs and concrete action descriptions.'),
     history: z
         .array(z.object({
         player: nonEmptyText.describe('The player who took the recorded action.'),

package/dist/recipes/citation-needed/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const citationNeededVerdictSchema: z.ZodEnum<{
-    needed: "needed";
     unclear: "unclear";
+    needed: "needed";
     unnecessary: "unnecessary";
 }>;
 export declare const citationNeededInputSchema: z.ZodObject<{
@@ -20,14 +20,14 @@ export declare const citationNeededResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        needed: "needed";
         unclear: "unclear";
+        needed: "needed";
         unnecessary: "unnecessary";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        needed: "needed";
         unclear: "unclear";
+        needed: "needed";
         unnecessary: "unnecessary";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "claim": "On the night of Sunday 8 March, sometime after we went to bed around 11 pm, a pipe in the upstairs bathroom at our home at 27 Alder Court burst. By the time we woke at 6 am, water had come through the ceiling of the living room directly below. The living room ceiling plaster has collapsed in two places, the hardwood floor is warped across roughly half the room, and the sofa and a wool rug are soaked. We shut off the main and called a plumber, who replaced the split section of pipe that morning.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesWhen": { "type": "noul", "noul": 0.96 },
+      "statesWhere": { "type": "noul", "noul": 0.95 },
+      "statesCause": { "type": "noul", "noul": 0.94 },
+      "statesDamages": { "type": "noul", "noul": 0.96 },
+      "statesEvidence": { "type": "noul", "noul": 0.08 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClaimFacetsInput, ClaimFacetsResult } from './schema.js';
+export declare function claimFacets(input: ClaimFacetsInput, options?: RecipeOptions): Promise<ClaimFacetsResult>;
+export { claimFacetsInputSchema, claimFacetsResultSchema, claimFacetsLabelSchema, } from './schema.js';
+export type { ClaimFacetsInput, ClaimFacetsResult, ClaimFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { claimFacetsInputSchema, claimFacetsResultSchema } from './schema.js';
+export async function claimFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = claimFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesWhen: {
+            instruction: 'Does claim state when the incident happened, as a date, a day, a time, or a clearly anchored period such as "overnight on Tuesday"?',
+            criteria: {
+                true: 'The narrative names a date, day, time, or anchored period for the incident.',
+                false: 'The narrative gives no indication of when the incident occurred.',
+            },
+        },
+        statesWhere: {
+            instruction: 'Does claim state where the incident happened, such as an address, a room or part of a property, a road or intersection, or a named place?',
+            criteria: {
+                true: 'The narrative names the location where the incident occurred.',
+                false: 'The narrative does not say where the incident took place.',
+            },
+        },
+        statesCause: {
+            instruction: 'Does claim state what caused the loss, such as a storm, a burst pipe, a break-in, a collision, or a fire, rather than only describing the resulting damage?',
+            criteria: {
+                true: 'The narrative identifies the event or mechanism that caused the loss.',
+                false: 'The narrative describes damage or loss without saying what caused it.',
+            },
+        },
+        statesDamages: {
+            instruction: 'Does claim state what was damaged, destroyed, lost, or injured, whether as specific items, parts of a property, or a described extent of harm?',
+            criteria: {
+                true: 'The narrative names the property, items, or harm affected by the incident.',
+                false: 'The narrative does not say what was damaged or lost.',
+            },
+        },
+        statesEvidence: {
+            instruction: 'Does claim mention witnesses, photographs, video, receipts, a police or incident report, or other evidence supporting the account?',
+            criteria: {
+                true: 'The narrative refers to at least one witness or piece of supporting evidence.',
+                false: 'The narrative mentions no witnesses or supporting evidence.',
+            },
+        },
+    }, options);
+    return claimFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { claimFacetsInputSchema, claimFacetsResultSchema, claimFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const claimFacetsLabelSchema: z.ZodEnum<{
+    statesWhen: "statesWhen";
+    statesWhere: "statesWhere";
+    statesCause: "statesCause";
+    statesDamages: "statesDamages";
+    statesEvidence: "statesEvidence";
+}>;
+export declare const claimFacetsInputSchema: z.ZodObject<{
+    claim: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const claimFacetsResultSchema: 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<{
+        statesWhen: "statesWhen";
+        statesWhere: "statesWhere";
+        statesCause: "statesCause";
+        statesDamages: "statesDamages";
+        statesEvidence: "statesEvidence";
+    }>>;
+    labels: z.ZodObject<{
+        statesWhen: 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>;
+        statesWhere: 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>;
+        statesCause: 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>;
+        statesDamages: 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>;
+        statesEvidence: 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 ClaimFacetsLabel = z.infer<typeof claimFacetsLabelSchema>;
+export type ClaimFacetsInput = z.infer<typeof claimFacetsInputSchema>;
+export type ClaimFacetsResult = z.infer<typeof claimFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const claimFacetsLabelSchema = z.enum([
+    'statesWhen',
+    'statesWhere',
+    'statesCause',
+    'statesDamages',
+    'statesEvidence',
+]);
+export const claimFacetsInputSchema = z.object({
+    claim: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const claimFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(claimFacetsLabelSchema),
+    labels: z.object({
+        statesWhen: labelCheckSchema,
+        statesWhere: labelCheckSchema,
+        statesCause: labelCheckSchema,
+        statesDamages: labelCheckSchema,
+        statesEvidence: labelCheckSchema,
+    }),
+});

package/dist/recipes/clarify/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const requirementVerdictSchema: z.ZodEnum<{
     ambiguous: "ambiguous";
-    missing: "missing";
     present: "present";
+    missing: "missing";
 }>;
 export declare const clarifyRequirementSchema: z.ZodObject<{
     id: z.ZodString;
@@ -38,14 +38,14 @@ export declare const clarifyResultSchema: z.ZodObject<{
         }>;
         verdict: z.ZodEnum<{
             ambiguous: "ambiguous";
-            missing: "missing";
             present: "present";
+            missing: "missing";
         }>;
         confidence: z.ZodNumber;
         probabilities: z.ZodRecord<z.ZodEnum<{
             ambiguous: "ambiguous";
-            missing: "missing";
             present: "present";
+            missing: "missing";
         }>, z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/dist/recipes/clause-conflict/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "firstClause": "The Customer shall pay each undisputed invoice within thirty (30) days of the invoice date.",
+    "secondClause": "All invoices are payable in full within fourteen (14) days of the invoice date, and no invoice may be disputed after payment is due.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.89 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/clause-conflict/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClauseConflictInput, ClauseConflictResult } from './schema.js';
+export declare function clauseConflict(input: ClauseConflictInput, options?: RecipeOptions): Promise<ClauseConflictResult>;
+export { clauseConflictInputSchema, clauseConflictResultSchema, clauseConflictVerdictSchema, } from './schema.js';
+export type { ClauseConflictInput, ClauseConflictResult, ClauseConflictVerdict } from './schema.js';

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

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { clauseConflictInputSchema, clauseConflictResultSchema } from './schema.js';
+export async function clauseConflict(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = clauseConflictInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Do firstClause and secondClause impose requirements that cannot both be satisfied? Compare what each clause requires, permits, or forbids, including its conditions and exceptions. Count a conflict only when a party following one clause would necessarily breach the other under the same circumstances. Different wording, overlapping subject matter, or one clause being stricter than the other is not a conflict when both can still be honored. Do not decide which clause prevails.', {
+        true: 'A party cannot comply with both clauses at the same time.',
+        false: 'Both clauses can be complied with at the same time.',
+    }, options);
+    return clauseConflictResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'conflict' : 'compatible',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { clauseConflictInputSchema, clauseConflictResultSchema, clauseConflictVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const clauseConflictVerdictSchema: z.ZodEnum<{
+    conflict: "conflict";
+    compatible: "compatible";
+}>;
+export declare const clauseConflictInputSchema: z.ZodObject<{
+    firstClause: z.ZodString;
+    secondClause: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const clauseConflictResultSchema: 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<{
+        conflict: "conflict";
+        compatible: "compatible";
+    }>;
+}, z.core.$strip>;
+export type ClauseConflictVerdict = z.infer<typeof clauseConflictVerdictSchema>;
+export type ClauseConflictInput = z.infer<typeof clauseConflictInputSchema>;
+export type ClauseConflictResult = z.infer<typeof clauseConflictResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const clauseConflictVerdictSchema = z.enum(['conflict', 'compatible']);
+export const clauseConflictInputSchema = z.object({
+    firstClause: nonEmptyText,
+    secondClause: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const clauseConflictResultSchema = gateResultSchema.extend({
+    verdict: clauseConflictVerdictSchema,
+});

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

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "clause": "The Supplier shall deliver the Goods to the Delivery Address no later than thirty (30) days after receipt of a Purchase Order.",
+    "context": "Clause 4.2 of a goods supply agreement between a manufacturer and a retailer.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "obligation",
+        "confidence": 0.92,
+        "probabilities": {
+          "obligation": 0.92,
+          "right": 0.02,
+          "prohibition": 0.01,
+          "condition": 0.03,
+          "definition": 0.01,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ClauseKindInput, ClauseKindResult } from './schema.js';
+export declare function clauseKind(input: ClauseKindInput, options?: RecipeOptions): Promise<ClauseKindResult>;
+export { clauseKindInputSchema, clauseKindResultSchema, clauseKindVerdictSchema, } from './schema.js';
+export type { ClauseKindInput, ClauseKindResult, ClauseKindVerdict } from './schema.js';