jev-recipes 0.6.0 → 0.6.1

package/README.md

@@ -11,7 +11,7 @@
 
 <!-- BEGIN GENERATED: summary -->
 
-235 focused recipes for JavaScript and TypeScript. Route messages, check evidence, and label model responses with a function call.
+236 focused recipes for JavaScript and TypeScript. Route messages, check evidence, and label model responses with a function call.
 
 <!-- END GENERATED: summary -->
 

package/dist/catalog/generated/details/finger-actions.json

@@ -0,0 +1,95 @@
+{
+  "inputSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "music": { "type": "string" },
+      "beat": { "type": "string" },
+      "fingers": {
+        "minItems": 1,
+        "maxItems": 20,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "text": { "type": "string" },
+            "options": {
+              "minItems": 1,
+              "maxItems": 50,
+              "type": "array",
+              "items": {
+                "type": "object",
+                "properties": { "id": { "type": "string" }, "text": { "type": "string" } },
+                "required": ["id", "text"]
+              }
+            }
+          },
+          "required": ["id", "text", "options"]
+        }
+      },
+      "style": { "type": "string" },
+      "minConfidence": { "type": "number", "minimum": 0, "maximum": 1 }
+    },
+    "required": ["music", "beat", "fingers"]
+  },
+  "resultSchema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "model": { "type": "string" },
+      "usage": {
+        "type": "object",
+        "properties": {
+          "input_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 },
+          "output_tokens": { "type": "integer", "minimum": 0, "maximum": 9007199254740991 }
+        },
+        "required": ["input_tokens", "output_tokens"],
+        "additionalProperties": false
+      },
+      "status": { "type": "string", "enum": ["ready", "review"] },
+      "assignments": {
+        "minItems": 1,
+        "maxItems": 20,
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string" },
+            "status": { "type": "string", "enum": ["ready", "review"] },
+            "verdict": { "type": "string", "enum": ["chosen", "rest", "ambiguous"] },
+            "action": { "type": ["string", "null"] },
+            "suggestedAction": { "type": ["string", "null"] },
+            "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+            "probabilities": {
+              "type": "object",
+              "properties": {
+                "options": {
+                  "type": "object",
+                  "propertyNames": { "type": "string" },
+                  "additionalProperties": { "type": "number", "minimum": 0, "maximum": 1 }
+                },
+                "rest": { "type": "number", "minimum": 0, "maximum": 1 },
+                "ambiguous": { "type": "number", "minimum": 0, "maximum": 1 }
+              },
+              "required": ["options", "rest", "ambiguous"],
+              "additionalProperties": false
+            }
+          },
+          "required": [
+            "id",
+            "status",
+            "verdict",
+            "action",
+            "suggestedAction",
+            "confidence",
+            "probabilities"
+          ],
+          "additionalProperties": false
+        }
+      }
+    },
+    "required": ["model", "usage", "status", "assignments"],
+    "additionalProperties": false
+  }
+}

package/dist/catalog/generated/loaders.js

@@ -86,6 +86,7 @@ export const recipeLoaders = {
     'feedback-kind': () => import('../../recipes/feedback-kind/index.js').then((recipe) => (input, options) => recipe.feedbackKind(recipe.feedbackKindInputSchema.parse(input), options)),
     'field-select': () => import('../../recipes/field-select/index.js').then((recipe) => (input, options) => recipe.fieldSelect(recipe.fieldSelectInputSchema.parse(input), options)),
     'financial-advice-signal': () => import('../../recipes/financial-advice-signal/index.js').then((recipe) => (input, options) => recipe.financialAdviceSignal(recipe.financialAdviceSignalInputSchema.parse(input), options)),
+    'finger-actions': () => import('../../recipes/finger-actions/index.js').then((recipe) => (input, options) => recipe.fingerActions(recipe.fingerActionsInputSchema.parse(input), options)),
     'followup-link': () => import('../../recipes/followup-link/index.js').then((recipe) => (input, options) => recipe.followupLink(recipe.followupLinkInputSchema.parse(input), options)),
     'forecast-confidence-wording': () => import('../../recipes/forecast-confidence-wording/index.js').then((recipe) => (input, options) => recipe.forecastConfidenceWording(recipe.forecastConfidenceWordingInputSchema.parse(input), options)),
     'format-fit': () => import('../../recipes/format-fit/index.js').then((recipe) => (input, options) => recipe.formatFit(recipe.formatFitInputSchema.parse(input), options)),

package/dist/catalog/generated/metadata.js

@@ -1918,6 +1918,29 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'finger-actions',
+        title: 'Choose an action for every finger',
+        description: 'On beat, which listed option should each finger in fingers take, given music and style, or rest?',
+        category: 'workflow',
+        tags: ['music', 'piano', 'performance', 'fingers', 'assignment', 'live-performance', 'agent'],
+        limitations: [
+            'Each finger is judged as its own question within one request, so two fingers can pick the same key. Resolve collisions and physical reach in code.',
+            'Options are the caller-supplied reachable actions for that finger; the recipe does not invent notes or check key membership.',
+            'Beat timing, note durations, and MIDI output belong in application code.',
+        ],
+        useWhen: 'A playing loop advances one subdivision at a time and wants every finger to pick from its own reachable options in a single call.',
+        related: [
+            {
+                id: 'next-note',
+                reason: 'Use next-note when the loop chooses one melodic note rather than an action per finger.',
+            },
+            {
+                id: 'next-chord',
+                reason: 'Use next-chord to pick the harmony first, then let finger-actions voice it.',
+            },
+        ],
+    },
     {
         id: 'followup-link',
         title: 'Link a follow-up request',

package/dist/catalog/generated/names.d.ts

@@ -1 +1 @@
-export declare const recipeNames: readonly ["action-compare", "action-effects", "action-reversibility", "action-scope", "age-appropriateness", "alert-actionability", "answer-consistency", "answer-coverage", "answer-disclosures", "answer-grade", "answer-invalidation", "answer-relevance", "answerability", "appeal-grounds-kind", "appointment-request-kind", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "breaking-change-signal", "budget-fit", "budget-narrative-fit", "bug-report-completeness", "buying-intent", "cache-match", "cancellation-check", "care-urgency-wording", "category-fit", "causal-attribution", "causal-language-strength", "certainty-match", "change-meaning", "change-risk", "change-window-fit", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-facets", "claim-stance", "clarify", "clause-conflict", "clause-kind", "clickbait-level", "commit-message-fit", "commitment-strength", "comparable-fit", "confirmation-match", "consent-request", "consent-scope-fit", "constraint-strength", "content-facets", "content-freshness-signal", "context-role", "continuation-compare", "correction-target", "corrective-action-fit", "daw-request-kind", "deadline-risk", "defect-report-facets", "delegation-fit", "disclosure-facets", "dispute-kind", "document-role", "draft-compare", "dynamic-change", "eligibility-facets", "emotion-kind", "entity-match", "error-acknowledgment", "escalation-wording", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "evidence-strength", "exercise-select", "expense-category", "explanation-level", "extraction-fidelity", "fact-stability", "failure-kind", "fair-housing-wording", "feedback-actionability", "feedback-kind", "field-select", "financial-advice-signal", "followup-link", "forecast-confidence-wording", "format-fit", "freshness-needed", "frustration-signal", "funder-fit", "game-action", "game-phase", "goal-drift", "grounding-level", "guest-request-facets", "handoff", "handoff-completeness", "headline-fit", "incident-match", "incident-severity-wording", "injection-signal", "instruction-clarity", "instruction-conflict", "instruction-fit", "instruction-priority", "instruction-readability", "instrument-issue-kind", "instrument-report-facets", "intake-question-fit", "intent-change", "invoice-facets", "issue-impact", "issue-recurrence", "itinerary-feasibility", "job-post-facets", "length-fit", "listener-request-kind", "listing-compare", "listing-fact-consistency", "log-line-kind", "loss-cause-kind", "lyric-mood-fit", "maintenance-hazard-wording", "medication-mention", "memory-relation", "memory-scope", "memory-subject", "memory-value", "message-facets", "methods-facets", "modulation-moment", "mood-match", "mood-request", "motivation-source", "move-explanation-fit", "narrative-consistency", "next-chord", "next-duration", "next-note", "notice-facets", "novelty-claim-level", "objection-kind", "objective-fit", "offer-terms-facets", "outcome-framing", "passage-compare", "passage-difficulty", "passage-duplicate", "passage-mood", "passage-standalone", "performance-feedback-facets", "persuasion-technique", "phrase-complete", "pii-presence", "plan-completeness", "policy-compliance", "policy-severity", "politeness-level", "postmortem-facets", "preference-kind", "priority-compare", "privacy-notice-facets", "product-match", "progress-stall", "promise-check", "proposal-facets", "qualification-evidence", "query-equivalence", "query-specificity", "question-assumption", "question-leading", "question-relevance", "reconciliation-match", "reference-resolve", "repeated-attempt", "repetition-level", "reply-template-match", "report-facets", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-plausibility", "result-usefulness", "retrieval-needed", "retry-worthwhile", "review-comment-kind", "review-facets", "review-recommendation-kind", "review-response-fit", "rollback-signal", "root-cause-depth", "route", "rule-compliance", "runbook-fit", "safety-incident-kind", "satisfaction-signal", "search-intent-kind", "sentiment-shift", "settlement-offer-facets", "shipment-issue-kind", "slot-fit", "sound-match", "source-applicability", "spam-signal", "stage-evidence", "step-complete", "step-progress", "style-kind", "summary-coverage", "symptom-facets", "take-turn", "task-complexity", "task-dependency", "task-duplicate", "task-overlap", "tempo-change", "tension-level", "ticket-match", "tone-check", "tool-compare", "tool-fit", "topic-shift", "trip-purpose-kind", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];
+export declare const recipeNames: readonly ["action-compare", "action-effects", "action-reversibility", "action-scope", "age-appropriateness", "alert-actionability", "answer-consistency", "answer-coverage", "answer-disclosures", "answer-grade", "answer-invalidation", "answer-relevance", "answerability", "appeal-grounds-kind", "appointment-request-kind", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "breaking-change-signal", "budget-fit", "budget-narrative-fit", "bug-report-completeness", "buying-intent", "cache-match", "cancellation-check", "care-urgency-wording", "category-fit", "causal-attribution", "causal-language-strength", "certainty-match", "change-meaning", "change-risk", "change-window-fit", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-facets", "claim-stance", "clarify", "clause-conflict", "clause-kind", "clickbait-level", "commit-message-fit", "commitment-strength", "comparable-fit", "confirmation-match", "consent-request", "consent-scope-fit", "constraint-strength", "content-facets", "content-freshness-signal", "context-role", "continuation-compare", "correction-target", "corrective-action-fit", "daw-request-kind", "deadline-risk", "defect-report-facets", "delegation-fit", "disclosure-facets", "dispute-kind", "document-role", "draft-compare", "dynamic-change", "eligibility-facets", "emotion-kind", "entity-match", "error-acknowledgment", "escalation-wording", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "evidence-strength", "exercise-select", "expense-category", "explanation-level", "extraction-fidelity", "fact-stability", "failure-kind", "fair-housing-wording", "feedback-actionability", "feedback-kind", "field-select", "financial-advice-signal", "finger-actions", "followup-link", "forecast-confidence-wording", "format-fit", "freshness-needed", "frustration-signal", "funder-fit", "game-action", "game-phase", "goal-drift", "grounding-level", "guest-request-facets", "handoff", "handoff-completeness", "headline-fit", "incident-match", "incident-severity-wording", "injection-signal", "instruction-clarity", "instruction-conflict", "instruction-fit", "instruction-priority", "instruction-readability", "instrument-issue-kind", "instrument-report-facets", "intake-question-fit", "intent-change", "invoice-facets", "issue-impact", "issue-recurrence", "itinerary-feasibility", "job-post-facets", "length-fit", "listener-request-kind", "listing-compare", "listing-fact-consistency", "log-line-kind", "loss-cause-kind", "lyric-mood-fit", "maintenance-hazard-wording", "medication-mention", "memory-relation", "memory-scope", "memory-subject", "memory-value", "message-facets", "methods-facets", "modulation-moment", "mood-match", "mood-request", "motivation-source", "move-explanation-fit", "narrative-consistency", "next-chord", "next-duration", "next-note", "notice-facets", "novelty-claim-level", "objection-kind", "objective-fit", "offer-terms-facets", "outcome-framing", "passage-compare", "passage-difficulty", "passage-duplicate", "passage-mood", "passage-standalone", "performance-feedback-facets", "persuasion-technique", "phrase-complete", "pii-presence", "plan-completeness", "policy-compliance", "policy-severity", "politeness-level", "postmortem-facets", "preference-kind", "priority-compare", "privacy-notice-facets", "product-match", "progress-stall", "promise-check", "proposal-facets", "qualification-evidence", "query-equivalence", "query-specificity", "question-assumption", "question-leading", "question-relevance", "reconciliation-match", "reference-resolve", "repeated-attempt", "repetition-level", "reply-template-match", "report-facets", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-plausibility", "result-usefulness", "retrieval-needed", "retry-worthwhile", "review-comment-kind", "review-facets", "review-recommendation-kind", "review-response-fit", "rollback-signal", "root-cause-depth", "route", "rule-compliance", "runbook-fit", "safety-incident-kind", "satisfaction-signal", "search-intent-kind", "sentiment-shift", "settlement-offer-facets", "shipment-issue-kind", "slot-fit", "sound-match", "source-applicability", "spam-signal", "stage-evidence", "step-complete", "step-progress", "style-kind", "summary-coverage", "symptom-facets", "take-turn", "task-complexity", "task-dependency", "task-duplicate", "task-overlap", "tempo-change", "tension-level", "ticket-match", "tone-check", "tool-compare", "tool-fit", "topic-shift", "trip-purpose-kind", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -87,6 +87,7 @@ export const recipeNames = [
     'feedback-kind',
     'field-select',
     'financial-advice-signal',
+    'finger-actions',
     'followup-link',
     'forecast-confidence-wording',
     'format-fit',

package/dist/catalog/schema.d.ts

@@ -87,6 +87,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "feedback-kind": "feedback-kind";
     "field-select": "field-select";
     "financial-advice-signal": "financial-advice-signal";
+    "finger-actions": "finger-actions";
     "followup-link": "followup-link";
     "forecast-confidence-wording": "forecast-confidence-wording";
     "format-fit": "format-fit";

package/dist/cli/schema.d.ts

@@ -90,6 +90,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "feedback-kind": "feedback-kind";
     "field-select": "field-select";
     "financial-advice-signal": "financial-advice-signal";
+    "finger-actions": "finger-actions";
     "followup-link": "followup-link";
     "forecast-confidence-wording": "forecast-confidence-wording";
     "format-fit": "format-fit";
@@ -329,6 +330,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "feedback-kind": "feedback-kind";
     "field-select": "field-select";
     "financial-advice-signal": "financial-advice-signal";
+    "finger-actions": "finger-actions";
     "followup-link": "followup-link";
     "forecast-confidence-wording": "forecast-confidence-wording";
     "format-fit": "format-fit";
@@ -565,6 +567,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "feedback-kind": "feedback-kind";
     "field-select": "field-select";
     "financial-advice-signal": "financial-advice-signal";
+    "finger-actions": "finger-actions";
     "followup-link": "followup-link";
     "forecast-confidence-wording": "forecast-confidence-wording";
     "format-fit": "format-fit";

package/dist/recipes/finger-actions/demo.json

@@ -0,0 +1,58 @@
+{
+  "input": {
+    "music": "Key C major, 72 bpm, gentle ballad. Last bar: right hand melody E4 D4 C4 (quarter, quarter, half) over a C major chord held in the left hand. The phrase just ended on the tonic.",
+    "beat": "Bar 5, eighth 1, start of a new phrase",
+    "fingers": [
+      {
+        "id": "rh-thumb",
+        "text": "Right thumb, resting on C4, free to move",
+        "options": [
+          { "id": "c4", "text": "Press C4 to restate the tonic" },
+          { "id": "hold", "text": "Keep C4 sounding from the previous bar" }
+        ]
+      },
+      {
+        "id": "rh-index",
+        "text": "Right index, hovering over D4 and E4",
+        "options": [
+          { "id": "e4", "text": "Press E4 to start the melody a third above" },
+          { "id": "d4", "text": "Press D4 to start stepwise" }
+        ]
+      },
+      {
+        "id": "lh-pinky",
+        "text": "Left pinky, on C3 which is currently sounding",
+        "options": [
+          { "id": "c3", "text": "Re-strike C3 for a fresh bass note" },
+          { "id": "g2", "text": "Move down to G2 for a dominant pedal" }
+        ]
+      }
+    ],
+    "style": "Keep the texture sparse; melody on top, single bass notes below.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "finger_0": {
+        "type": "choice",
+        "choice": "rest",
+        "confidence": 0.84,
+        "probabilities": { "option_0": 0.08, "option_1": 0.06, "rest": 0.84, "ambiguous": 0.02 }
+      },
+      "finger_1": {
+        "type": "choice",
+        "choice": "option_0",
+        "confidence": 0.86,
+        "probabilities": { "option_0": 0.86, "option_1": 0.1, "rest": 0.03, "ambiguous": 0.01 }
+      },
+      "finger_2": {
+        "type": "choice",
+        "choice": "option_0",
+        "confidence": 0.9,
+        "probabilities": { "option_0": 0.9, "option_1": 0.06, "rest": 0.03, "ambiguous": 0.01 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/finger-actions/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { FingerActionsInput, FingerActionsResult } from './schema.js';
+export declare function fingerActions(input: FingerActionsInput, options?: RecipeOptions): Promise<FingerActionsResult>;
+export { fingerActionsInputSchema, fingerActionsResultSchema } from './schema.js';
+export type { FingerActionsInput, FingerActionsResult } from './schema.js';

package/dist/recipes/finger-actions/index.js

@@ -0,0 +1,7 @@
+import { evaluateAssignments } from '../../src/assignments.js';
+import { fingerActionsInputSchema } from './schema.js';
+export async function fingerActions(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = fingerActionsInputSchema.parse(input);
+    return evaluateAssignments(state, state.fingers, (index) => `What should fingers[${index}] (described in fingers[${index}].text) do on beat, given the recent material, key, and tempo in music and any style? Choose one of its listed options so the whole hand plays a coherent, idiomatic voicing with the other fingers' likely actions. Judge only this finger.`, minConfidence, options, 'finger');
+}
+export { fingerActionsInputSchema, fingerActionsResultSchema } from './schema.js';

package/dist/recipes/finger-actions/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const fingerActionsInputSchema: z.ZodObject<{
+    music: z.ZodString;
+    beat: z.ZodString;
+    fingers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    style: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const fingerActionsResultSchema: 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";
+    }>;
+    assignments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            review: "review";
+        }>;
+        verdict: z.ZodEnum<{
+            ambiguous: "ambiguous";
+            chosen: "chosen";
+            rest: "rest";
+        }>;
+        action: z.ZodNullable<z.ZodString>;
+        suggestedAction: z.ZodNullable<z.ZodString>;
+        confidence: z.ZodNumber;
+        probabilities: z.ZodObject<{
+            options: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            rest: z.ZodNumber;
+            ambiguous: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FingerActionsInput = z.infer<typeof fingerActionsInputSchema>;
+export type FingerActionsResult = z.infer<typeof fingerActionsResultSchema>;

package/dist/recipes/finger-actions/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { assignmentsResultSchema, nonEmptyText, optionSlotsSchema, probability, } from '../../src/schema.js';
+export const fingerActionsInputSchema = z.object({
+    music: nonEmptyText,
+    beat: nonEmptyText,
+    fingers: optionSlotsSchema,
+    style: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const fingerActionsResultSchema = assignmentsResultSchema;

package/dist/src/assignments.d.ts

@@ -0,0 +1,2 @@
+import type { AssignmentsResult, OptionSlot, RecipeOptions } from './schema.js';
+export declare function evaluateAssignments(state: Record<string, unknown>, slots: OptionSlot[], instruction: (index: number) => string, minConfidence: number, options?: RecipeOptions, questionPrefix?: string): Promise<AssignmentsResult>;

package/dist/src/assignments.js

@@ -0,0 +1,47 @@
+import { choice } from '@typesafe-ai/sdk';
+import { evaluateWithJev } from './client.js';
+import { parseChoiceAnswer } from './answers.js';
+import { asDecisionInstruction, parseDecisionState } from './decisions.js';
+import { assignmentsResultSchema } from './schema.js';
+export async function evaluateAssignments(state, slots, instruction, minConfidence, options = {}, questionPrefix = 'slot') {
+    const criteria = slots.map((slot) => ({
+        ...Object.fromEntries(slot.options.map((option, index) => [`option_${index}`, option.text])),
+        rest: 'No listed option should be taken now; stay silent or release.',
+        ambiguous: 'Several listed options fit equally well, or the facts cannot separate them.',
+    }));
+    const response = await evaluateWithJev({
+        state: parseDecisionState(state),
+        questions: Object.fromEntries(slots.map((_, index) => [
+            `${questionPrefix}_${index}`,
+            choice(asDecisionInstruction(`${instruction(index)} Choose rest when no listed option fits. Choose ambiguous when several fit equally well.`), criteria[index]),
+        ])),
+    }, options);
+    const assignments = slots.map((slot, index) => {
+        const answer = parseChoiceAnswer(response.answers[`${questionPrefix}_${index}`], Object.keys(criteria[index]));
+        const chosen = slot.options.find((_, position) => `option_${position}` === answer.choice);
+        const suggestedAction = chosen?.id ?? null;
+        const requiresReview = answer.confidence < minConfidence || answer.choice === 'ambiguous';
+        return {
+            id: slot.id,
+            status: requiresReview ? 'review' : 'ready',
+            verdict: chosen !== undefined ? 'chosen' : answer.choice,
+            action: requiresReview ? null : suggestedAction,
+            suggestedAction,
+            confidence: answer.confidence,
+            probabilities: {
+                options: Object.fromEntries(slot.options.map((option, position) => [
+                    option.id,
+                    answer.probabilities[`option_${position}`],
+                ])),
+                rest: answer.probabilities.rest,
+                ambiguous: answer.probabilities.ambiguous,
+            },
+        };
+    });
+    return assignmentsResultSchema.parse({
+        status: assignments.some((assignment) => assignment.status === 'review') ? 'review' : 'ready',
+        assignments,
+        model: response.model,
+        usage: response.usage,
+    });
+}

package/dist/src/index.d.ts

@@ -176,6 +176,8 @@ export { fieldSelect, fieldSelectInputSchema, fieldSelectResultSchema, } from '.
 export type { FieldSelectInput, FieldSelectResult } from '../recipes/field-select/index.js';
 export { financialAdviceSignal, financialAdviceSignalInputSchema, financialAdviceSignalResultSchema, financialAdviceSignalVerdictSchema, } from '../recipes/financial-advice-signal/index.js';
 export type { FinancialAdviceSignalInput, FinancialAdviceSignalResult, FinancialAdviceSignalVerdict, } from '../recipes/financial-advice-signal/index.js';
+export { fingerActions, fingerActionsInputSchema, fingerActionsResultSchema, } from '../recipes/finger-actions/index.js';
+export type { FingerActionsInput, FingerActionsResult } from '../recipes/finger-actions/index.js';
 export { followupLink, followupLinkInputSchema, followupLinkResultSchema, } from '../recipes/followup-link/index.js';
 export type { FollowupLinkInput, FollowupLinkResult } from '../recipes/followup-link/index.js';
 export { forecastConfidenceWording, forecastConfidenceWordingInputSchema, forecastConfidenceWordingResultSchema, forecastConfidenceWordingVerdictSchema, } from '../recipes/forecast-confidence-wording/index.js';

package/dist/src/index.js

@@ -88,6 +88,7 @@ export { feedbackActionability, feedbackActionabilityInputSchema, feedbackAction
 export { feedbackKind, feedbackKindInputSchema, feedbackKindResultSchema, feedbackKindVerdictSchema, } from '../recipes/feedback-kind/index.js';
 export { fieldSelect, fieldSelectInputSchema, fieldSelectResultSchema, } from '../recipes/field-select/index.js';
 export { financialAdviceSignal, financialAdviceSignalInputSchema, financialAdviceSignalResultSchema, financialAdviceSignalVerdictSchema, } from '../recipes/financial-advice-signal/index.js';
+export { fingerActions, fingerActionsInputSchema, fingerActionsResultSchema, } from '../recipes/finger-actions/index.js';
 export { followupLink, followupLinkInputSchema, followupLinkResultSchema, } from '../recipes/followup-link/index.js';
 export { forecastConfidenceWording, forecastConfidenceWordingInputSchema, forecastConfidenceWordingResultSchema, forecastConfidenceWordingVerdictSchema, } from '../recipes/forecast-confidence-wording/index.js';
 export { formatFit, formatFitInputSchema, formatFitResultSchema, formatFitVerdictSchema, } from '../recipes/format-fit/index.js';

package/dist/src/schema.d.ts

@@ -236,3 +236,73 @@ export type LabelQuestions = z.infer<typeof labelQuestionsSchema>;
 export type LabelVerdict = z.infer<typeof labelVerdictSchema>;
 export type LabelCheck = z.infer<typeof labelCheckSchema>;
 export type LabelsResult = z.infer<typeof labelsResultSchema>;
+export declare const optionSlotSchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const optionSlotsSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export declare const assignmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        chosen: "chosen";
+        rest: "rest";
+    }>;
+    action: z.ZodNullable<z.ZodString>;
+    suggestedAction: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        options: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        rest: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const assignmentsResultSchema: 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";
+    }>;
+    assignments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            review: "review";
+        }>;
+        verdict: z.ZodEnum<{
+            ambiguous: "ambiguous";
+            chosen: "chosen";
+            rest: "rest";
+        }>;
+        action: z.ZodNullable<z.ZodString>;
+        suggestedAction: z.ZodNullable<z.ZodString>;
+        confidence: z.ZodNumber;
+        probabilities: z.ZodObject<{
+            options: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            rest: z.ZodNumber;
+            ambiguous: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OptionSlot = z.infer<typeof optionSlotSchema>;
+export type Assignment = z.infer<typeof assignmentSchema>;
+export type AssignmentsResult = z.infer<typeof assignmentsResultSchema>;

package/dist/src/schema.js

@@ -111,3 +111,30 @@ export const labelsResultSchema = resultMetadataSchema.extend({
     status: decisionStatusSchema,
     detected: z.array(nonEmptyText),
 });
+export const optionSlotSchema = z.object({
+    id: nonEmptyText,
+    text: nonEmptyText,
+    options: textItemsSchema,
+});
+export const optionSlotsSchema = z
+    .array(optionSlotSchema)
+    .min(1)
+    .max(20)
+    .refine((slots) => new Set(slots.map((slot) => slot.id)).size === slots.length, 'Slot IDs must be unique.');
+export const assignmentSchema = z.object({
+    id: nonEmptyText,
+    status: decisionStatusSchema,
+    verdict: z.enum(['chosen', 'rest', 'ambiguous']),
+    action: nonEmptyText.nullable(),
+    suggestedAction: nonEmptyText.nullable(),
+    confidence: probability,
+    probabilities: z.object({
+        options: z.record(nonEmptyText, probability),
+        rest: probability,
+        ambiguous: probability,
+    }),
+});
+export const assignmentsResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    assignments: z.array(assignmentSchema).min(1).max(20),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jev-recipes",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Small, composable Jev decisions for retrieval, conversations, and agent workflows.",
   "type": "module",
   "license": "MIT",
@@ -372,6 +372,10 @@
       "types": "./dist/recipes/financial-advice-signal/index.d.ts",
       "import": "./dist/recipes/financial-advice-signal/index.js"
     },
+    "./finger-actions": {
+      "types": "./dist/recipes/finger-actions/index.d.ts",
+      "import": "./dist/recipes/finger-actions/index.js"
+    },
     "./followup-link": {
       "types": "./dist/recipes/followup-link/index.d.ts",
       "import": "./dist/recipes/followup-link/index.js"