jev-recipes 0.5.2 → 0.6.0

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { messageFacetsInputSchema, messageFacetsResultSchema } from './schema.js';
+export async function messageFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = messageFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        asksQuestion: {
+            instruction: 'Does message ask a question that expects an answer, given any context?',
+            criteria: {
+                true: 'The message asks at least one question expecting an answer.',
+                false: 'The message asks no question, or only rhetorical ones.',
+            },
+        },
+        reportsProblem: {
+            instruction: 'Does message report something that is broken, wrong, or not working as expected?',
+            criteria: {
+                true: 'The message reports a problem the sender is experiencing.',
+                false: 'The message reports no problem.',
+            },
+        },
+        requestsAction: {
+            instruction: 'Does message ask the recipient to do something specific?',
+            criteria: {
+                true: 'The message requests a concrete action from the recipient.',
+                false: 'The message requests no action.',
+            },
+        },
+        statesDeadline: {
+            instruction: 'Does message state a deadline, date, or time by which something must happen?',
+            criteria: {
+                true: 'The message states an explicit deadline or time constraint.',
+                false: 'The message states no deadline.',
+            },
+        },
+        referencesPriorContact: {
+            instruction: 'Does message refer to an earlier conversation, ticket, call, or email about the same matter?',
+            criteria: {
+                true: 'The message refers to prior contact about this matter.',
+                false: 'The message does not refer to prior contact.',
+            },
+        },
+    }, options);
+    return messageFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { messageFacetsInputSchema, messageFacetsResultSchema, messageFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export declare const messageFacetsLabelSchema: z.ZodEnum<{
+    asksQuestion: "asksQuestion";
+    reportsProblem: "reportsProblem";
+    requestsAction: "requestsAction";
+    statesDeadline: "statesDeadline";
+    referencesPriorContact: "referencesPriorContact";
+}>;
+export declare const messageFacetsInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const messageFacetsResultSchema: 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<{
+        asksQuestion: "asksQuestion";
+        reportsProblem: "reportsProblem";
+        requestsAction: "requestsAction";
+        statesDeadline: "statesDeadline";
+        referencesPriorContact: "referencesPriorContact";
+    }>>;
+    labels: z.ZodObject<{
+        asksQuestion: 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>;
+        reportsProblem: 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>;
+        requestsAction: 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>;
+        statesDeadline: 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>;
+        referencesPriorContact: 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 MessageFacetsLabel = z.infer<typeof messageFacetsLabelSchema>;
+export type MessageFacetsInput = z.infer<typeof messageFacetsInputSchema>;
+export type MessageFacetsResult = z.infer<typeof messageFacetsResultSchema>;

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const messageFacetsLabelSchema = z.enum([
+    'asksQuestion',
+    'reportsProblem',
+    'requestsAction',
+    'statesDeadline',
+    'referencesPriorContact',
+]);
+export const messageFacetsInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const messageFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(messageFacetsLabelSchema),
+    labels: z.object({
+        asksQuestion: labelCheckSchema,
+        reportsProblem: labelCheckSchema,
+        requestsAction: labelCheckSchema,
+        statesDeadline: labelCheckSchema,
+        referencesPriorContact: labelCheckSchema,
+    }),
+});

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

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "methods": "We recruited 312 undergraduates (mean age 19.4, 58% women) from the university psychology participant pool between March and May 2023. Each participant completed the task in a single 40-minute lab session. Responses were analyzed with mixed-effects logistic regression in R using lme4, with participant as a random intercept and condition as a fixed effect. The hypotheses, design, and analysis plan were preregistered on OSF before data collection began.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesSampleSize": { "type": "noul", "noul": 0.97 },
+      "statesDataSource": { "type": "noul", "noul": 0.92 },
+      "statesAnalysisMethod": { "type": "noul", "noul": 0.96 },
+      "statesLimitations": { "type": "noul", "noul": 0.05 },
+      "statesPreregistration": { "type": "noul", "noul": 0.95 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MethodsFacetsInput, MethodsFacetsResult } from './schema.js';
+export declare function methodsFacets(input: MethodsFacetsInput, options?: RecipeOptions): Promise<MethodsFacetsResult>;
+export { methodsFacetsInputSchema, methodsFacetsResultSchema, methodsFacetsLabelSchema, } from './schema.js';
+export type { MethodsFacetsInput, MethodsFacetsResult, MethodsFacetsLabel } from './schema.js';

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

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { methodsFacetsInputSchema, methodsFacetsResultSchema } from './schema.js';
+export async function methodsFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = methodsFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesSampleSize: {
+            instruction: 'Does methods state how many participants, observations, or units were studied?',
+            criteria: {
+                true: 'The text gives a count of participants, observations, cases, or units, such as N = 312 or 40 interviews.',
+                false: 'The text gives no count of participants, observations, or units.',
+            },
+        },
+        statesDataSource: {
+            instruction: 'Does methods state where the data or participants came from, such as a population, pool, database, registry, or collection site?',
+            criteria: {
+                true: 'The text names the population, recruitment pool, dataset, registry, or site from which the data or participants were drawn.',
+                false: 'The text does not say where the data or participants came from.',
+            },
+        },
+        statesAnalysisMethod: {
+            instruction: 'Does methods name the statistical or analytical procedure used, such as a regression model, test, or coding approach?',
+            criteria: {
+                true: 'The text names at least one specific analysis procedure, model, test, or qualitative coding method.',
+                false: 'The text does not name any analysis procedure beyond generic words such as analyzed or examined.',
+            },
+        },
+        statesLimitations: {
+            instruction: 'Does methods state a weakness, constraint, or threat to validity of the study?',
+            criteria: {
+                true: 'The text names at least one limitation, such as a small sample, self-report bias, missing data, or an inability to infer causation.',
+                false: 'The text states no weakness or threat to validity.',
+            },
+        },
+        statesPreregistration: {
+            instruction: 'Does methods state that the design, hypotheses, or analysis plan were preregistered or followed a protocol fixed before data collection?',
+            criteria: {
+                true: 'The text says the study or analysis plan was preregistered, registered, or followed a prespecified protocol, with or without a registry link.',
+                false: 'The text makes no mention of preregistration, registration, or a prespecified protocol.',
+            },
+        },
+    }, options);
+    return methodsFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { methodsFacetsInputSchema, methodsFacetsResultSchema, methodsFacetsLabelSchema, } from './schema.js';

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

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const methodsFacetsLabelSchema: z.ZodEnum<{
+    statesLimitations: "statesLimitations";
+    statesSampleSize: "statesSampleSize";
+    statesDataSource: "statesDataSource";
+    statesAnalysisMethod: "statesAnalysisMethod";
+    statesPreregistration: "statesPreregistration";
+}>;
+export declare const methodsFacetsInputSchema: z.ZodObject<{
+    methods: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const methodsFacetsResultSchema: 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<{
+        statesLimitations: "statesLimitations";
+        statesSampleSize: "statesSampleSize";
+        statesDataSource: "statesDataSource";
+        statesAnalysisMethod: "statesAnalysisMethod";
+        statesPreregistration: "statesPreregistration";
+    }>>;
+    labels: z.ZodObject<{
+        statesSampleSize: 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>;
+        statesDataSource: 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>;
+        statesAnalysisMethod: 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>;
+        statesLimitations: 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>;
+        statesPreregistration: 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 MethodsFacetsLabel = z.infer<typeof methodsFacetsLabelSchema>;
+export type MethodsFacetsInput = z.infer<typeof methodsFacetsInputSchema>;
+export type MethodsFacetsResult = z.infer<typeof methodsFacetsResultSchema>;

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const methodsFacetsLabelSchema = z.enum([
+    'statesSampleSize',
+    'statesDataSource',
+    'statesAnalysisMethod',
+    'statesLimitations',
+    'statesPreregistration',
+]);
+export const methodsFacetsInputSchema = z.object({
+    methods: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const methodsFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(methodsFacetsLabelSchema),
+    labels: z.object({
+        statesSampleSize: labelCheckSchema,
+        statesDataSource: labelCheckSchema,
+        statesAnalysisMethod: labelCheckSchema,
+        statesLimitations: labelCheckSchema,
+        statesPreregistration: labelCheckSchema,
+    }),
+});

package/dist/recipes/modulation-moment/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "recentMaterial": "Bar 3 of a four-bar phrase. The melody is climbing F4 G4 A4 toward the phrase peak on an upbeat, the harmony has just moved from ii to V, and there has been no cadence or rest since the phrase began.",
+    "key": "C major",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.06 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/modulation-moment/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ModulationMomentInput, ModulationMomentResult } from './schema.js';
+export declare function modulationMoment(input: ModulationMomentInput, options?: RecipeOptions): Promise<ModulationMomentResult>;
+export { modulationMomentInputSchema, modulationMomentResultSchema, modulationMomentVerdictSchema, } from './schema.js';
+export type { ModulationMomentInput, ModulationMomentResult, ModulationMomentVerdict, } from './schema.js';

package/dist/recipes/modulation-moment/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { modulationMomentInputSchema, modulationMomentResultSchema } from './schema.js';
+export async function modulationMoment(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = modulationMomentInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Is now a musically suitable moment to change key away from key, judged only on what recentMaterial describes? Answer suitable when the material has just closed a phrase, landed on a cadence or a held stable chord, or paused on a rest, so a new key can begin without cutting a line off. Answer unsuitable when the material is mid-phrase, building toward a peak, sitting on an unresolved chord, or otherwise still in motion. Judge phrase position, cadence, and stability as described; ignore whether a modulation would be interesting, which key to move to, and how to get there. Do not compute scale degrees or identify the key from the notes.', {
+        true: 'recentMaterial describes a phrase that has just closed or settled on a cadence, a held stable chord, or a rest, so a new key can begin without cutting a line off.',
+        false: 'recentMaterial describes a phrase in motion: mid-line, building toward a peak, sitting on an unresolved chord, or otherwise not yet settled.',
+    }, options);
+    return modulationMomentResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'suitable' : 'unsuitable',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { modulationMomentInputSchema, modulationMomentResultSchema, modulationMomentVerdictSchema, } from './schema.js';

package/dist/recipes/modulation-moment/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const modulationMomentVerdictSchema: z.ZodEnum<{
+    unsuitable: "unsuitable";
+    suitable: "suitable";
+}>;
+export declare const modulationMomentInputSchema: z.ZodObject<{
+    recentMaterial: z.ZodString;
+    key: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const modulationMomentResultSchema: 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<{
+        unsuitable: "unsuitable";
+        suitable: "suitable";
+    }>;
+}, z.core.$strip>;
+export type ModulationMomentVerdict = z.infer<typeof modulationMomentVerdictSchema>;
+export type ModulationMomentInput = z.infer<typeof modulationMomentInputSchema>;
+export type ModulationMomentResult = z.infer<typeof modulationMomentResultSchema>;

package/dist/recipes/modulation-moment/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const modulationMomentVerdictSchema = z.enum(['suitable', 'unsuitable']);
+export const modulationMomentInputSchema = z.object({
+    recentMaterial: nonEmptyText,
+    key: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const modulationMomentResultSchema = gateResultSchema.extend({
+    verdict: modulationMomentVerdictSchema,
+});

package/dist/recipes/mood-match/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "requestedMood": "calm, something to relax to",
+    "passage": "Fast tempo around 160 bpm, driving repeated sixteenth notes in the left hand, diminished and augmented chords with frequent chromatic shifts, sudden accents on off-beats, fortissimo throughout, melody leaping in the high register.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.04 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/mood-match/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MoodMatchInput, MoodMatchResult } from './schema.js';
+export declare function moodMatch(input: MoodMatchInput, options?: RecipeOptions): Promise<MoodMatchResult>;
+export { moodMatchInputSchema, moodMatchResultSchema, moodMatchVerdictSchema } from './schema.js';
+export type { MoodMatchInput, MoodMatchResult, MoodMatchVerdict } from './schema.js';

package/dist/recipes/mood-match/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { moodMatchInputSchema, moodMatchResultSchema } from './schema.js';
+export async function moodMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = moodMatchInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Read requestedMood, the mood a listener asked for, and passage, a text description of a musical passage. Decide whether the musical features described in passage, such as mode, tempo, register, harmony, rhythm, and dynamics, conventionally express requestedMood. Judge the features against the mood as worded, allowing for synonyms and near neighbours, such as soothing for calm. Ignore any listener reaction, title, or intention that passage mentions, and do not judge whether the passage is well played or interesting.', {
+        true: 'The features passage describes conventionally express requestedMood or a close neighbour of it, with no dominant feature pulling toward an opposing mood.',
+        false: 'The features passage describes express a different mood from requestedMood, or the features that support requestedMood are outweighed by ones that oppose it.',
+    }, options);
+    return moodMatchResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'matches' : 'mismatched',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { moodMatchInputSchema, moodMatchResultSchema, moodMatchVerdictSchema } from './schema.js';

package/dist/recipes/mood-match/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const moodMatchVerdictSchema: z.ZodEnum<{
+    mismatched: "mismatched";
+    matches: "matches";
+}>;
+export declare const moodMatchInputSchema: z.ZodObject<{
+    requestedMood: z.ZodString;
+    passage: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const moodMatchResultSchema: 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<{
+        mismatched: "mismatched";
+        matches: "matches";
+    }>;
+}, z.core.$strip>;
+export type MoodMatchVerdict = z.infer<typeof moodMatchVerdictSchema>;
+export type MoodMatchInput = z.infer<typeof moodMatchInputSchema>;
+export type MoodMatchResult = z.infer<typeof moodMatchResultSchema>;

package/dist/recipes/mood-match/schema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const moodMatchVerdictSchema = z.enum(['matches', 'mismatched']);
+export const moodMatchInputSchema = z.object({
+    requestedMood: nonEmptyText,
+    passage: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const moodMatchResultSchema = gateResultSchema.extend({ verdict: moodMatchVerdictSchema });

package/dist/recipes/mood-request/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "message": "long day, can we get something soft and dreamy? trying to wind down before bed",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "calm",
+        "confidence": 0.9,
+        "probabilities": {
+          "happy": 0.01,
+          "sad": 0.02,
+          "calm": 0.9,
+          "energetic": 0.01,
+          "tense": 0.01,
+          "romantic": 0.03,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/mood-request/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MoodRequestInput, MoodRequestResult } from './schema.js';
+export declare function moodRequest(input: MoodRequestInput, options?: RecipeOptions): Promise<MoodRequestResult>;
+export { moodRequestInputSchema, moodRequestResultSchema, moodRequestVerdictSchema, } from './schema.js';
+export type { MoodRequestInput, MoodRequestResult, MoodRequestVerdict } from './schema.js';

package/dist/recipes/mood-request/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { moodRequestInputSchema, moodRequestResultSchema } from './schema.js';
+export async function moodRequest(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = moodRequestInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Read message from a listener of a musical performance and decide which mood it asks the music to take on. Judge the feeling the listener wants to hear, not the feeling the listener expresses about themselves; a listener who says they are stressed and wants something to unwind to is asking for calm. Pick the single mood the message presses most. If message asks for a tempo, style, or piece without naming a feeling, or asks nothing of the music, choose unclear.', {
+        happy: 'The message asks for something cheerful, bright, upbeat in feeling, or fun.',
+        sad: 'The message asks for something melancholy, mournful, wistful, or heartbreaking.',
+        calm: 'The message asks for something relaxing, soft, peaceful, dreamy, or soothing.',
+        energetic: 'The message asks for something lively, intense, driving, exciting, or hype.',
+        tense: 'The message asks for something suspenseful, dark, eerie, anxious, or dramatic.',
+        romantic: 'The message asks for something loving, tender, intimate, or sensual.',
+        unclear: 'The message names no feeling it wants to hear, or names one that fits none of the listed moods.',
+    }, options);
+    return moodRequestResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { moodRequestInputSchema, moodRequestResultSchema, moodRequestVerdictSchema, } from './schema.js';

package/dist/recipes/mood-request/schema.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const moodRequestVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    happy: "happy";
+    sad: "sad";
+    calm: "calm";
+    energetic: "energetic";
+    tense: "tense";
+    romantic: "romantic";
+}>;
+export declare const moodRequestInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const moodRequestResultSchema: 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";
+        happy: "happy";
+        sad: "sad";
+        calm: "calm";
+        energetic: "energetic";
+        tense: "tense";
+        romantic: "romantic";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        happy: "happy";
+        sad: "sad";
+        calm: "calm";
+        energetic: "energetic";
+        tense: "tense";
+        romantic: "romantic";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MoodRequestVerdict = z.infer<typeof moodRequestVerdictSchema>;
+export type MoodRequestInput = z.infer<typeof moodRequestInputSchema>;
+export type MoodRequestResult = z.infer<typeof moodRequestResultSchema>;

package/dist/recipes/mood-request/schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const moodRequestVerdictSchema = z.enum([
+    'happy',
+    'sad',
+    'calm',
+    'energetic',
+    'tense',
+    'romantic',
+    'unclear',
+]);
+export const moodRequestInputSchema = z.object({
+    message: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const moodRequestResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: moodRequestVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(moodRequestVerdictSchema, probability),
+});