jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/game-action/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { GameActionInput, GameActionResult } from './schema.js';
+export declare function gameAction(input: GameActionInput, options?: RecipeOptions): Promise<GameActionResult>;
+export { gameActionInputSchema, gameActionResultSchema } from './schema.js';
+export type { GameActionInput, GameActionResult } from './schema.js';

package/dist/recipes/game-action/index.js

@@ -0,0 +1,30 @@
+import { choice } from '@typesafe-ai/sdk';
+import { evaluateWithJev } from '../../src/client.js';
+import { parseChoiceAnswer } from '../../src/answers.js';
+import { parseDecisionState } from '../../src/decisions.js';
+import { gameActionInputSchema, gameActionResultSchema } from './schema.js';
+const instructions = [
+    'Which available action should this player take next, given the supplied game state, player state, rules, and objective?',
+    ...Object.entries(gameActionInputSchema.shape).map(([name, schema]) => `${name}: ${schema.description}`),
+].join('\n');
+export async function gameAction(input, options = {}) {
+    const { legalActions, ...state } = gameActionInputSchema.parse(input);
+    if (legalActions.length === 0)
+        return null;
+    const actions = Object.fromEntries(legalActions.map((action, index) => [`action_${index}`, action]));
+    const criteria = Object.fromEntries(Object.entries(actions).map(([label, action]) => [label, JSON.stringify(action)]));
+    const response = await evaluateWithJev({
+        state: parseDecisionState(state),
+        questions: { decision: choice(instructions, criteria) },
+    }, options);
+    const answer = parseChoiceAnswer(response.answers.decision, Object.keys(actions));
+    return gameActionResultSchema.parse({
+        selection: answer.choice,
+        action: actions[answer.choice],
+        confidence: answer.confidence,
+        probabilities: answer.probabilities,
+        model: response.model,
+        usage: response.usage,
+    });
+}
+export { gameActionInputSchema, gameActionResultSchema } from './schema.js';

package/dist/recipes/game-action/schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const gameActionInputSchema: z.ZodObject<{
+    gameState: z.ZodJSONSchema;
+    playerState: z.ZodJSONSchema;
+    legalActions: z.ZodArray<z.ZodJSONSchema>;
+    rules: z.ZodOptional<z.ZodJSONSchema>;
+    objective: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strip>;
+export declare const gameActionResultSchema: z.ZodNullable<z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    selection: z.ZodString;
+    action: z.ZodJSONSchema;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>>;
+export type GameActionInput = z.infer<typeof gameActionInputSchema>;
+export type GameActionResult = z.infer<typeof gameActionResultSchema>;

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { probability, resultMetadataSchema } from '../../src/schema.js';
+export const gameActionInputSchema = z.object({
+    gameState: z.json().describe('The current game information available for this decision.'),
+    playerState: z.json().describe('Information about the player making this decision.'),
+    legalActions: z.array(z.json()).describe('The available actions the player can choose from.'),
+    rules: z.json().optional().describe('Game rules and explanations of game-specific information.'),
+    objective: z.json().optional().describe('What the player is trying to accomplish.'),
+});
+export const gameActionResultSchema = resultMetadataSchema
+    .extend({
+    selection: z
+        .string()
+        .describe('The internal Choice label associated with the selected action.'),
+    action: z.json().describe('The original selected action, preserving any existing game ID.'),
+    confidence: probability.describe('The confidence returned by Jev.'),
+    probabilities: z
+        .record(z.string(), probability)
+        .describe("Jev's probabilities, keyed by internal Choice label."),
+})
+    .nullable();

package/dist/recipes/game-phase/demo.json

@@ -0,0 +1,25 @@
+{
+  "input": {
+    "state": "Chess. White: king g1, rook d1, pawns a2, f2, g2. Black: king g8, rook e8, pawns a7, h6. Move 52, White to move. No queens or minor pieces remain. Neither side is in check.",
+    "rules": "Standard chess. The game ends by checkmate, stalemate, agreed draw, resignation, or the fifty-move and threefold repetition rules.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "endgame",
+        "confidence": 0.85,
+        "probabilities": {
+          "opening": 0.01,
+          "midgame": 0.09,
+          "endgame": 0.85,
+          "terminal": 0.02,
+          "unclear": 0.03
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/game-phase/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { GamePhaseInput, GamePhaseResult } from './schema.js';
+export declare function gamePhase(input: GamePhaseInput, options?: RecipeOptions): Promise<GamePhaseResult>;
+export { gamePhaseInputSchema, gamePhaseResultSchema, gamePhaseVerdictSchema } from './schema.js';
+export type { GamePhaseInput, GamePhaseResult, GamePhaseVerdict } from './schema.js';

package/dist/recipes/game-phase/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { gamePhaseInputSchema, gamePhaseResultSchema } from './schema.js';
+export async function gamePhase(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = gamePhaseInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Which phase of the game does state describe? Use rules when supplied to understand what counts as setup, development, reduced material, and a finished game; otherwise rely on common conventions for the game named or implied in state. Opening means early setup or development with most resources still in play. Midgame means resources are engaged and contested with no side close to a decisive result. Endgame means resources are depleted or the outcome is close and play is about converting or defending. Terminal means state describes a finished game with a winner, loser, or draw already determined. Use unclear when state gives too little to place it.', {
+        opening: 'The state shows early setup or development, with most pieces, cards, or resources still available and little direct conflict.',
+        midgame: 'The state shows resources engaged and contested, with meaningful material or options remaining on each side and no decisive result near.',
+        endgame: 'The state shows depleted resources or a nearly decided outcome, with play focused on converting an advantage or holding a defense.',
+        terminal: 'The state describes a finished game: a checkmate, elimination, agreed draw, or final score is stated.',
+        unclear: 'The state gives too little information about the game or its progress to place it in a phase.',
+    }, options);
+    return gamePhaseResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { gamePhaseInputSchema, gamePhaseResultSchema, gamePhaseVerdictSchema } from './schema.js';

package/dist/recipes/game-phase/schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const gamePhaseVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    opening: "opening";
+    midgame: "midgame";
+    endgame: "endgame";
+    terminal: "terminal";
+}>;
+export declare const gamePhaseInputSchema: z.ZodObject<{
+    state: z.ZodString;
+    rules: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const gamePhaseResultSchema: 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";
+        opening: "opening";
+        midgame: "midgame";
+        endgame: "endgame";
+        terminal: "terminal";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        opening: "opening";
+        midgame: "midgame";
+        endgame: "endgame";
+        terminal: "terminal";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type GamePhaseVerdict = z.infer<typeof gamePhaseVerdictSchema>;
+export type GamePhaseInput = z.infer<typeof gamePhaseInputSchema>;
+export type GamePhaseResult = z.infer<typeof gamePhaseResultSchema>;

package/dist/recipes/game-phase/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const gamePhaseVerdictSchema = z.enum([
+    'opening',
+    'midgame',
+    'endgame',
+    'terminal',
+    'unclear',
+]);
+export const gamePhaseInputSchema = z.object({
+    state: nonEmptyText,
+    rules: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const gamePhaseResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: gamePhaseVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(gamePhaseVerdictSchema, probability),
+});

package/dist/recipes/goal-drift/demo.json

@@ -0,0 +1,13 @@
+{
+  "input": {
+    "goal": "Fix the failing login test in auth.spec.ts so the suite passes.",
+    "step": "Rewrite the entire session middleware module to use async/await and rename all of its helper functions for consistency.",
+    "context": "The failing test asserts that an expired token returns 401. The middleware currently throws and the request ends in a 500. No other tests are failing.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.91 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/goal-drift/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { GoalDriftInput, GoalDriftResult } from './schema.js';
+export declare function goalDrift(input: GoalDriftInput, options?: RecipeOptions): Promise<GoalDriftResult>;
+export { goalDriftInputSchema, goalDriftResultSchema, goalDriftVerdictSchema } from './schema.js';
+export type { GoalDriftInput, GoalDriftResult, GoalDriftVerdict } from './schema.js';

package/dist/recipes/goal-drift/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { goalDriftInputSchema, goalDriftResultSchema } from './schema.js';
+export async function goalDrift(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = goalDriftInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does step still serve goal, or has the work drifted to something goal did not ask for? Count step as drifted when it pursues a different objective, expands scope beyond what goal requires, or continues past the point where goal was already met. Necessary preparation, investigation, or fixes that are clearly on the path to goal are aligned. Use context, when supplied, for what has happened so far.', {
+        true: 'The step pursues work that goal did not ask for or no longer needs.',
+        false: 'The step is a reasonable move toward goal.',
+    }, options);
+    return goalDriftResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'drifted' : 'aligned',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { goalDriftInputSchema, goalDriftResultSchema, goalDriftVerdictSchema } from './schema.js';

package/dist/recipes/goal-drift/schema.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const goalDriftVerdictSchema: z.ZodEnum<{
+    aligned: "aligned";
+    drifted: "drifted";
+}>;
+export declare const goalDriftInputSchema: z.ZodObject<{
+    goal: z.ZodString;
+    step: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const goalDriftResultSchema: 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<{
+        aligned: "aligned";
+        drifted: "drifted";
+    }>;
+}, z.core.$strip>;
+export type GoalDriftVerdict = z.infer<typeof goalDriftVerdictSchema>;
+export type GoalDriftInput = z.infer<typeof goalDriftInputSchema>;
+export type GoalDriftResult = z.infer<typeof goalDriftResultSchema>;

package/dist/recipes/goal-drift/schema.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const goalDriftVerdictSchema = z.enum(['drifted', 'aligned']);
+export const goalDriftInputSchema = z.object({
+    goal: nonEmptyText,
+    step: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const goalDriftResultSchema = gateResultSchema.extend({
+    verdict: goalDriftVerdictSchema,
+});

package/dist/recipes/grounding-level/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "draft": "Your Starter plan includes 5 GB of storage and unlimited collaborators. Files larger than 2 GB must be uploaded through the desktop app, and deleted files can be restored for 30 days.",
+    "evidence": "Starter plan: 5 GB storage, up to 10 collaborators. Uploads larger than 2 GB require the desktop application. Deleted files can be restored for 30 days.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.91,
+        "confidence": 0.85,
+        "probabilities": { "0": 0.0, "1": 0.02, "2": 0.09, "3": 0.85, "4": 0.04 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/grounding-level/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { GroundingLevelInput, GroundingLevelResult } from './schema.js';
+export declare function groundingLevel(input: GroundingLevelInput, options?: RecipeOptions): Promise<GroundingLevelResult>;
+export { groundingLevelInputSchema, groundingLevelResultSchema, groundingLevelVerdictSchema, } from './schema.js';
+export type { GroundingLevelInput, GroundingLevelResult, GroundingLevelVerdict } from './schema.js';

package/dist/recipes/grounding-level/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { groundingLevelInputSchema, groundingLevelResultSchema, groundingLevelVerdictSchema, } from './schema.js';
+export async function groundingLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = groundingLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How much of the substantive content in draft is backed by evidence? Consider each factual statement, figure, and recommendation in draft and ask whether evidence states or directly entails it. Ignore greetings, transitions, and other filler. Do not credit statements that are true only from outside knowledge.', [
+        'None of the substantive statements in draft are supported by evidence.',
+        'A minority of the substantive statements in draft are supported by evidence.',
+        'About half of the substantive statements in draft are supported by evidence.',
+        'Most substantive statements in draft are supported by evidence, with a few unsupported statements.',
+        'Every substantive statement in draft is supported by evidence.',
+    ], options);
+    return groundingLevelResultSchema.parse({
+        ...decision,
+        grounding: groundingLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { groundingLevelInputSchema, groundingLevelResultSchema, groundingLevelVerdictSchema, } from './schema.js';

package/dist/recipes/grounding-level/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const groundingLevelVerdictSchema: z.ZodEnum<{
+    none: "none";
+    partial: "partial";
+    mostly: "mostly";
+    full: "full";
+    weak: "weak";
+}>;
+export declare const groundingLevelInputSchema: z.ZodObject<{
+    draft: z.ZodString;
+    evidence: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const groundingLevelResultSchema: 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>;
+    grounding: z.ZodEnum<{
+        none: "none";
+        partial: "partial";
+        mostly: "mostly";
+        full: "full";
+        weak: "weak";
+    }>;
+}, z.core.$strip>;
+export type GroundingLevelVerdict = z.infer<typeof groundingLevelVerdictSchema>;
+export type GroundingLevelInput = z.infer<typeof groundingLevelInputSchema>;
+export type GroundingLevelResult = z.infer<typeof groundingLevelResultSchema>;

package/dist/recipes/grounding-level/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const groundingLevelVerdictSchema = z.enum(['none', 'weak', 'partial', 'mostly', 'full']);
+export const groundingLevelInputSchema = z.object({
+    draft: nonEmptyText,
+    evidence: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const groundingLevelResultSchema = scoreResultSchema.extend({
+    grounding: groundingLevelVerdictSchema,
+});

package/dist/recipes/guest-request-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "request": "Hello, we are hoping to book two rooms from Friday 14 November to Sunday 16 November for my parents' 40th wedding anniversary. There will be six of us: my parents, my husband and me, and our two teenagers. My father uses a walker, so one of the rooms needs to be step-free with a roll-in shower and close to the elevator. Could you also let us know whether the restaurant can do a small celebration dinner on the Saturday?",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesDates": { "type": "noul", "noul": 0.96 },
+      "statesPartySize": { "type": "noul", "noul": 0.95 },
+      "statesAccessibilityNeeds": { "type": "noul", "noul": 0.93 },
+      "statesBudget": { "type": "noul", "noul": 0.07 },
+      "statesOccasion": { "type": "noul", "noul": 0.94 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/guest-request-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { GuestRequestFacetsInput, GuestRequestFacetsResult } from './schema.js';
+export declare function guestRequestFacets(input: GuestRequestFacetsInput, options?: RecipeOptions): Promise<GuestRequestFacetsResult>;
+export { guestRequestFacetsInputSchema, guestRequestFacetsResultSchema, guestRequestFacetsLabelSchema, } from './schema.js';
+export type { GuestRequestFacetsInput, GuestRequestFacetsResult, GuestRequestFacetsLabel, } from './schema.js';

package/dist/recipes/guest-request-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { guestRequestFacetsInputSchema, guestRequestFacetsResultSchema } from './schema.js';
+export async function guestRequestFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = guestRequestFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesDates: {
+            instruction: 'Does request state the dates or date range of the stay or visit, such as specific days, a month with a duration, or check-in and check-out days?',
+            criteria: {
+                true: 'The request names when the stay or visit would take place.',
+                false: 'The request gives no dates or period for the stay.',
+            },
+        },
+        statesPartySize: {
+            instruction: 'Does request state how many people are in the party, either as a number or an enumerated list of travelers?',
+            criteria: {
+                true: 'The request says how many guests or which named people are traveling.',
+                false: 'The request does not indicate how many people are coming.',
+            },
+        },
+        statesAccessibilityNeeds: {
+            instruction: 'Does request state an accessibility need, such as step-free access, a wheelchair-accessible room, a ground-floor room for mobility reasons, or accommodations for a sensory or medical condition?',
+            criteria: {
+                true: 'The request names an accessibility or mobility accommodation the party needs.',
+                false: 'The request mentions no accessibility need.',
+            },
+        },
+        statesBudget: {
+            instruction: 'Does request state a budget, price ceiling, or price range for the booking?',
+            criteria: {
+                true: 'The request gives an amount, ceiling, or range the guest is willing to pay.',
+                false: 'The request gives no price figure or range.',
+            },
+        },
+        statesOccasion: {
+            instruction: 'Does request state a special occasion for the trip, such as an anniversary, birthday, honeymoon, graduation, or reunion?',
+            criteria: {
+                true: 'The request names an occasion being celebrated or marked by the trip.',
+                false: 'The request mentions no special occasion.',
+            },
+        },
+    }, options);
+    return guestRequestFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { guestRequestFacetsInputSchema, guestRequestFacetsResultSchema, guestRequestFacetsLabelSchema, } from './schema.js';

package/dist/recipes/guest-request-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const guestRequestFacetsLabelSchema: z.ZodEnum<{
+    statesDates: "statesDates";
+    statesPartySize: "statesPartySize";
+    statesAccessibilityNeeds: "statesAccessibilityNeeds";
+    statesBudget: "statesBudget";
+    statesOccasion: "statesOccasion";
+}>;
+export declare const guestRequestFacetsInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const guestRequestFacetsResultSchema: 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<{
+        statesDates: "statesDates";
+        statesPartySize: "statesPartySize";
+        statesAccessibilityNeeds: "statesAccessibilityNeeds";
+        statesBudget: "statesBudget";
+        statesOccasion: "statesOccasion";
+    }>>;
+    labels: z.ZodObject<{
+        statesDates: 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>;
+        statesPartySize: 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>;
+        statesAccessibilityNeeds: 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>;
+        statesBudget: 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>;
+        statesOccasion: 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 GuestRequestFacetsLabel = z.infer<typeof guestRequestFacetsLabelSchema>;
+export type GuestRequestFacetsInput = z.infer<typeof guestRequestFacetsInputSchema>;
+export type GuestRequestFacetsResult = z.infer<typeof guestRequestFacetsResultSchema>;

package/dist/recipes/guest-request-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const guestRequestFacetsLabelSchema = z.enum([
+    'statesDates',
+    'statesPartySize',
+    'statesAccessibilityNeeds',
+    'statesBudget',
+    'statesOccasion',
+]);
+export const guestRequestFacetsInputSchema = z.object({
+    request: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const guestRequestFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(guestRequestFacetsLabelSchema),
+    labels: z.object({
+        statesDates: labelCheckSchema,
+        statesPartySize: labelCheckSchema,
+        statesAccessibilityNeeds: labelCheckSchema,
+        statesBudget: labelCheckSchema,
+        statesOccasion: labelCheckSchema,
+    }),
+});

package/dist/recipes/handoff-completeness/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "item": "Add rate limiting to the public /search endpoint. Use the existing RateLimiter middleware in src/middleware/rate-limit.ts and the Redis instance already configured for sessions. Done when requests beyond 60 per minute per API key return 429 with a Retry-After header and the integration test in tests/api/search.test.ts covers the limit.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.96,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.0, "1": 0.02, "2": 0.08, "3": 0.82, "4": 0.08 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/handoff-completeness/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { HandoffCompletenessInput, HandoffCompletenessResult } from './schema.js';
+export declare function handoffCompleteness(input: HandoffCompletenessInput, options?: RecipeOptions): Promise<HandoffCompletenessResult>;
+export { handoffCompletenessInputSchema, handoffCompletenessResultSchema, handoffCompletenessVerdictSchema, } from './schema.js';
+export type { HandoffCompletenessInput, HandoffCompletenessResult, HandoffCompletenessVerdict, } from './schema.js';

package/dist/recipes/handoff-completeness/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { handoffCompletenessInputSchema, handoffCompletenessResultSchema, handoffCompletenessVerdictSchema, } from './schema.js';
+export async function handoffCompleteness(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = handoffCompletenessInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How ready is item, a work description being handed to another agent or person, to be picked up without asking questions? Judge whether item states the goal, supplies the inputs and context needed to start, defines what done looks like, and names constraints, ownership, and acceptance criteria. Ignore length and tone; a short item that covers every element is complete.', [
+        'The goal is missing or too unclear to know what work is being asked for.',
+        'The goal is stated, but the inputs, references, or context needed to start are missing.',
+        'The goal and its inputs are present, but there is no definition of when the work is done.',
+        'The goal, inputs, and definition of done are present, but constraints, ownership, or acceptance criteria are missing.',
+        'The goal, inputs, definition of done, constraints, ownership, and acceptance criteria are all present.',
+    ], options);
+    return handoffCompletenessResultSchema.parse({
+        ...decision,
+        completeness: handoffCompletenessVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { handoffCompletenessInputSchema, handoffCompletenessResultSchema, handoffCompletenessVerdictSchema, } from './schema.js';