jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/outcome-framing/schema.d.ts

@@ -2,9 +2,9 @@ import { z } from 'zod';
 export declare const outcomeFramingVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
     mixed: "mixed";
+    neutral: "neutral";
     gain: "gain";
     loss: "loss";
-    neutral: "neutral";
 }>;
 export declare const outcomeFramingInputSchema: z.ZodObject<{
     text: z.ZodString;
@@ -25,17 +25,17 @@ export declare const outcomeFramingResultSchema: z.ZodObject<{
     verdict: z.ZodEnum<{
         unclear: "unclear";
         mixed: "mixed";
+        neutral: "neutral";
         gain: "gain";
         loss: "loss";
-        neutral: "neutral";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
         mixed: "mixed";
+        neutral: "neutral";
         gain: "gain";
         loss: "loss";
-        neutral: "neutral";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type OutcomeFramingInput = z.infer<typeof outcomeFramingInputSchema>;

package/dist/recipes/passage-compare/demo.json

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "question": "How long do refunds take to appear on a card?",
+    "firstPassage": "Refunds are issued to the original payment method and typically appear within 5 to 10 business days, depending on the card issuer.",
+    "secondPassage": "You can request a refund from the Orders page by selecting the item and choosing Return.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "first",
+        "confidence": 0.9,
+        "probabilities": {
+          "first": 0.9,
+          "second": 0.03,
+          "tie": 0.03,
+          "neither": 0.02,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/passage-compare/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PassageCompareInput, PassageCompareResult } from './schema.js';
+export declare function passageCompare(input: PassageCompareInput, options?: RecipeOptions): Promise<PassageCompareResult>;
+export { passageCompareInputSchema, passageCompareResultSchema, passageCompareVerdictSchema, } from './schema.js';
+export type { PassageCompareInput, PassageCompareResult, PassageCompareVerdict } from './schema.js';

package/dist/recipes/passage-compare/index.js

@@ -0,0 +1,16 @@
+import { evaluateComparison } from '../../src/comparisons.js';
+import { passageCompareInputSchema, passageCompareResultSchema } from './schema.js';
+export async function passageCompare(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = passageCompareInputSchema.parse(input);
+    const decision = await evaluateComparison(state, 'Which passage more directly and completely helps answer question? Judge the information each passage contains, not its length or style.', {
+        first: 'Only the first passage helps answer the question, or it clearly helps more.',
+        second: 'Only the second passage helps answer the question, or it clearly helps more.',
+        tie: 'Both passages help answer the question about equally.',
+        neither: 'Neither passage contains information that helps answer the question.',
+    }, options);
+    return passageCompareResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { passageCompareInputSchema, passageCompareResultSchema, passageCompareVerdictSchema, } from './schema.js';

package/dist/recipes/passage-compare/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const passageCompareVerdictSchema: z.ZodEnum<{
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+    unclear: "unclear";
+}>;
+export declare const passageCompareInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    firstPassage: z.ZodString;
+    secondPassage: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const passageCompareResultSchema: 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<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PassageCompareVerdict = z.infer<typeof passageCompareVerdictSchema>;
+export type PassageCompareInput = z.infer<typeof passageCompareInputSchema>;
+export type PassageCompareResult = z.infer<typeof passageCompareResultSchema>;

package/dist/recipes/passage-compare/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { comparisonResultSchema, comparisonVerdictSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const passageCompareVerdictSchema = comparisonVerdictSchema;
+export const passageCompareInputSchema = z.object({
+    question: nonEmptyText,
+    firstPassage: nonEmptyText,
+    secondPassage: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const passageCompareResultSchema = comparisonResultSchema;

package/dist/recipes/passage-difficulty/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "passage": "Continuous sixteenth-note arpeggios across all four strings at quarter note = 144, in E-flat major, moving from first position up to seventh position and back every two bars, with string crossings on every beat and a two-octave leap into the final bar.",
+    "instrument": "violin",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.95,
+        "confidence": 0.84,
+        "probabilities": { "0": 0, "1": 0.01, "2": 0.09, "3": 0.84, "4": 0.06 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/passage-difficulty/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PassageDifficultyInput, PassageDifficultyResult } from './schema.js';
+export declare function passageDifficulty(input: PassageDifficultyInput, options?: RecipeOptions): Promise<PassageDifficultyResult>;
+export { passageDifficultyInputSchema, passageDifficultyResultSchema, passageDifficultyVerdictSchema, } from './schema.js';
+export type { PassageDifficultyInput, PassageDifficultyResult, PassageDifficultyVerdict, } from './schema.js';

package/dist/recipes/passage-difficulty/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { passageDifficultyInputSchema, passageDifficultyResultSchema, passageDifficultyVerdictSchema, } from './schema.js';
+export async function passageDifficulty(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = passageDifficultyInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How hard is the passage described in passage to play on instrument, or on the instrument the description implies when instrument is not given? Weigh the technical demands the description states: tempo, rhythmic complexity, range and position changes, key and accidentals, hand or finger independence, speed of passagework, extended techniques, and endurance. Judge the demands on the player, not the musical quality of the piece or how well known it is. Do not assume demands the description does not state.', [
+        'The passage uses a few notes in a comfortable range at a slow tempo with simple rhythms and no position changes, suited to a first-year player.',
+        'The passage stays in familiar keys and positions at a moderate tempo with straightforward rhythms and occasional small shifts.',
+        'The passage requires some speed, position or register changes, less common keys, or rhythmic independence that takes a few years of study.',
+        'The passage demands fast passagework, wide leaps, awkward keys, complex rhythms, or sustained technical control expected of an advanced student or working player.',
+        'The passage combines extreme speed, range, or extended techniques with continuous technical demands that only highly accomplished players can manage.',
+    ], options);
+    return passageDifficultyResultSchema.parse({
+        ...decision,
+        difficulty: passageDifficultyVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { passageDifficultyInputSchema, passageDifficultyResultSchema, passageDifficultyVerdictSchema, } from './schema.js';

package/dist/recipes/passage-difficulty/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const passageDifficultyVerdictSchema: z.ZodEnum<{
+    beginner: "beginner";
+    easy: "easy";
+    intermediate: "intermediate";
+    advanced: "advanced";
+    virtuoso: "virtuoso";
+}>;
+export declare const passageDifficultyInputSchema: z.ZodObject<{
+    passage: z.ZodString;
+    instrument: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const passageDifficultyResultSchema: 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>;
+    difficulty: z.ZodEnum<{
+        beginner: "beginner";
+        easy: "easy";
+        intermediate: "intermediate";
+        advanced: "advanced";
+        virtuoso: "virtuoso";
+    }>;
+}, z.core.$strip>;
+export type PassageDifficultyVerdict = z.infer<typeof passageDifficultyVerdictSchema>;
+export type PassageDifficultyInput = z.infer<typeof passageDifficultyInputSchema>;
+export type PassageDifficultyResult = z.infer<typeof passageDifficultyResultSchema>;

package/dist/recipes/passage-difficulty/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const passageDifficultyVerdictSchema = z.enum([
+    'beginner',
+    'easy',
+    'intermediate',
+    'advanced',
+    'virtuoso',
+]);
+export const passageDifficultyInputSchema = z.object({
+    passage: nonEmptyText,
+    instrument: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const passageDifficultyResultSchema = scoreResultSchema.extend({
+    difficulty: passageDifficultyVerdictSchema,
+});

package/dist/recipes/passage-duplicate/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const passageDuplicateVerdictSchema: z.ZodEnum<{
-    duplicate: "duplicate";
     unclear: "unclear";
+    duplicate: "duplicate";
     overlapping: "overlapping";
     distinct: "distinct";
 }>;
@@ -21,15 +21,15 @@ export declare const passageDuplicateResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        duplicate: "duplicate";
         unclear: "unclear";
+        duplicate: "duplicate";
         overlapping: "overlapping";
         distinct: "distinct";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        duplicate: "duplicate";
         unclear: "unclear";
+        duplicate: "duplicate";
         overlapping: "overlapping";
         distinct: "distinct";
     }>, z.ZodNumber>;

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

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "passage": "D minor, slow tempo around 52 bpm, melody in the low-middle register moving mostly by step and descending at the end of each phrase, sustained chords in the left hand, dynamics piano throughout, frequent suspensions that resolve downward.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "sad",
+        "confidence": 0.88,
+        "probabilities": {
+          "happy": 0,
+          "sad": 0.88,
+          "calm": 0.07,
+          "energetic": 0,
+          "tense": 0.02,
+          "romantic": 0.02,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PassageMoodInput, PassageMoodResult } from './schema.js';
+export declare function passageMood(input: PassageMoodInput, options?: RecipeOptions): Promise<PassageMoodResult>;
+export { passageMoodInputSchema, passageMoodResultSchema, passageMoodVerdictSchema, } from './schema.js';
+export type { PassageMoodInput, PassageMoodResult, PassageMoodVerdict } from './schema.js';

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

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { passageMoodInputSchema, passageMoodResultSchema } from './schema.js';
+export async function passageMood(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = passageMoodInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Read passage, a text description of a musical passage, and decide which mood its described features express. Judge only the musical features named, such as mode, harmony, tempo, rhythm, register, articulation, and dynamics, and the conventional affect those features carry: major mode and lively tempo toward happy or energetic, minor mode and slow tempo toward sad, soft sustained textures toward calm, dissonance and unpredictable rhythm toward tense, warm harmony at a gentle pace toward romantic. Ignore any listener reactions, intentions, or titles that passage mentions. Pick the single mood the features support most, and choose unclear when passage names too few features to tell or when they point in opposite directions with none dominant.', {
+        happy: 'The described features are bright and buoyant: major mode, moderate-to-lively tempo, mid-to-high register, consonant harmony, and detached or bouncing articulation.',
+        sad: 'The described features are dark and slow: minor mode, slow tempo, descending melodic lines, low or middle register, soft dynamics, and suspensions or sighing figures.',
+        calm: 'The described features are gentle and still: slow-to-moderate tempo, sustained or arpeggiated texture, soft dynamics, consonant harmony, and little rhythmic drive.',
+        energetic: 'The described features are driving and loud: fast tempo, strong steady pulse, repeated rhythmic figures, wide range, and forte or louder dynamics.',
+        tense: 'The described features are unstable and unsettled: dissonant or diminished harmony, chromatic motion, irregular or syncopated rhythm, sudden accents, tremolo, or unresolved cadences.',
+        romantic: 'The described features are warm and yearning: lush or extended harmony, singing legato melody, rubato or gentle tempo, and swelling dynamics.',
+        unclear: 'The passage names too few musical features to judge, or its features point toward opposing moods with none dominant.',
+    }, options);
+    return passageMoodResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { passageMoodInputSchema, passageMoodResultSchema, passageMoodVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const passageMoodVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    happy: "happy";
+    sad: "sad";
+    calm: "calm";
+    energetic: "energetic";
+    tense: "tense";
+    romantic: "romantic";
+}>;
+export declare const passageMoodInputSchema: z.ZodObject<{
+    passage: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const passageMoodResultSchema: 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 PassageMoodVerdict = z.infer<typeof passageMoodVerdictSchema>;
+export type PassageMoodInput = z.infer<typeof passageMoodInputSchema>;
+export type PassageMoodResult = z.infer<typeof passageMoodResultSchema>;

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

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

package/dist/recipes/passage-standalone/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "passage": "As noted above, this approach reduces the latency further, but it requires the second cache to be warmed before traffic shifts. Otherwise the fallback path described earlier is used.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.08 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/passage-standalone/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PassageStandaloneInput, PassageStandaloneResult } from './schema.js';
+export declare function passageStandalone(input: PassageStandaloneInput, options?: RecipeOptions): Promise<PassageStandaloneResult>;
+export { passageStandaloneInputSchema, passageStandaloneResultSchema, passageStandaloneVerdictSchema, } from './schema.js';
+export type { PassageStandaloneInput, PassageStandaloneResult, PassageStandaloneVerdict, } from './schema.js';

package/dist/recipes/passage-standalone/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { passageStandaloneInputSchema, passageStandaloneResultSchema } from './schema.js';
+export async function passageStandalone(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = passageStandaloneInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Can passage be understood on its own, without the text that surrounded it? Look for references that the passage itself does not resolve: pronouns or phrases like "this approach" or "the second option" with no referent inside the passage, pointers such as "as above" or "the following", and terms or abbreviations that are clearly defined elsewhere. A passage is standalone when a reader with no other context can tell what it is about and what it claims.', {
+        true: 'A reader can understand the passage with no surrounding text.',
+        false: 'The passage depends on surrounding text through unresolved references or undefined terms.',
+    }, options);
+    return passageStandaloneResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'standalone' : 'dependent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { passageStandaloneInputSchema, passageStandaloneResultSchema, passageStandaloneVerdictSchema, } from './schema.js';

package/dist/recipes/passage-standalone/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const passageStandaloneVerdictSchema: z.ZodEnum<{
+    standalone: "standalone";
+    dependent: "dependent";
+}>;
+export declare const passageStandaloneInputSchema: z.ZodObject<{
+    passage: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const passageStandaloneResultSchema: 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<{
+        standalone: "standalone";
+        dependent: "dependent";
+    }>;
+}, z.core.$strip>;
+export type PassageStandaloneVerdict = z.infer<typeof passageStandaloneVerdictSchema>;
+export type PassageStandaloneInput = z.infer<typeof passageStandaloneInputSchema>;
+export type PassageStandaloneResult = z.infer<typeof passageStandaloneResultSchema>;

package/dist/recipes/passage-standalone/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const passageStandaloneVerdictSchema = z.enum(['standalone', 'dependent']);
+export const passageStandaloneInputSchema = z.object({
+    passage: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const passageStandaloneResultSchema = gateResultSchema.extend({
+    verdict: passageStandaloneVerdictSchema,
+});

package/dist/recipes/performance-feedback-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "feedback": "Good work this week. The dotted eighths in bars 9 to 12 are still rushing, so put the metronome on and count the sixteenth underneath. The high F-sharp in bar 14 was flat every time; check it against the open E before you start. I liked the contrast between the quiet opening and the forte at the return of the theme, keep that.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "mentionsRhythm": { "type": "noul", "noul": 0.96 },
+      "mentionsPitch": { "type": "noul", "noul": 0.95 },
+      "mentionsDynamics": { "type": "noul", "noul": 0.91 },
+      "mentionsTechnique": { "type": "noul", "noul": 0.06 },
+      "mentionsExpression": { "type": "noul", "noul": 0.08 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/performance-feedback-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PerformanceFeedbackFacetsInput, PerformanceFeedbackFacetsResult } from './schema.js';
+export declare function performanceFeedbackFacets(input: PerformanceFeedbackFacetsInput, options?: RecipeOptions): Promise<PerformanceFeedbackFacetsResult>;
+export { performanceFeedbackFacetsInputSchema, performanceFeedbackFacetsResultSchema, performanceFeedbackFacetsLabelSchema, } from './schema.js';
+export type { PerformanceFeedbackFacetsInput, PerformanceFeedbackFacetsResult, PerformanceFeedbackFacetsLabel, } from './schema.js';

package/dist/recipes/performance-feedback-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { performanceFeedbackFacetsInputSchema, performanceFeedbackFacetsResultSchema, } from './schema.js';
+export async function performanceFeedbackFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = performanceFeedbackFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        mentionsRhythm: {
+            instruction: 'Does feedback address rhythm, tempo, timing, or pulse, such as rushing, dragging, uneven subdivisions, or holding notes for their full value?',
+            criteria: {
+                true: 'The feedback comments on timing, tempo, pulse, rhythm accuracy, or steadiness.',
+                false: 'The feedback says nothing about timing, tempo, or rhythm.',
+            },
+        },
+        mentionsPitch: {
+            instruction: 'Does feedback address pitch or intonation, such as wrong notes, playing sharp or flat, tuning, or pitch accuracy in a register?',
+            criteria: {
+                true: 'The feedback comments on pitch accuracy, intonation, tuning, or wrong notes.',
+                false: 'The feedback says nothing about pitch, intonation, or note accuracy.',
+            },
+        },
+        mentionsDynamics: {
+            instruction: 'Does feedback address dynamics, such as loudness, softness, contrast, crescendos, diminuendos, accents, or balance between hands or parts?',
+            criteria: {
+                true: 'The feedback comments on volume levels, dynamic contrast, accents, or balance.',
+                false: 'The feedback says nothing about loudness, contrast, or balance.',
+            },
+        },
+        mentionsTechnique: {
+            instruction: 'Does feedback address physical technique, such as posture, hand position, fingering, bowing, breathing, embouchure, pedaling, or articulation mechanics?',
+            criteria: {
+                true: 'The feedback comments on how the player physically produces the sound, such as fingering, bow use, breath support, hand shape, posture, or pedaling.',
+                false: 'The feedback says nothing about the physical means of playing.',
+            },
+        },
+        mentionsExpression: {
+            instruction: 'Does feedback address expression or phrasing, such as musical shape, direction, character, style, rubato, or communicating the mood of the piece?',
+            criteria: {
+                true: 'The feedback comments on phrasing, musical shape, character, style, or emotional communication.',
+                false: 'The feedback says nothing about phrasing, shape, character, or musical meaning.',
+            },
+        },
+    }, options);
+    return performanceFeedbackFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { performanceFeedbackFacetsInputSchema, performanceFeedbackFacetsResultSchema, performanceFeedbackFacetsLabelSchema, } from './schema.js';

package/dist/recipes/performance-feedback-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const performanceFeedbackFacetsLabelSchema: z.ZodEnum<{
+    mentionsRhythm: "mentionsRhythm";
+    mentionsPitch: "mentionsPitch";
+    mentionsDynamics: "mentionsDynamics";
+    mentionsTechnique: "mentionsTechnique";
+    mentionsExpression: "mentionsExpression";
+}>;
+export declare const performanceFeedbackFacetsInputSchema: z.ZodObject<{
+    feedback: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const performanceFeedbackFacetsResultSchema: 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<{
+        mentionsRhythm: "mentionsRhythm";
+        mentionsPitch: "mentionsPitch";
+        mentionsDynamics: "mentionsDynamics";
+        mentionsTechnique: "mentionsTechnique";
+        mentionsExpression: "mentionsExpression";
+    }>>;
+    labels: z.ZodObject<{
+        mentionsRhythm: 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>;
+        mentionsPitch: 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>;
+        mentionsDynamics: 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>;
+        mentionsTechnique: 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>;
+        mentionsExpression: 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 PerformanceFeedbackFacetsLabel = z.infer<typeof performanceFeedbackFacetsLabelSchema>;
+export type PerformanceFeedbackFacetsInput = z.infer<typeof performanceFeedbackFacetsInputSchema>;
+export type PerformanceFeedbackFacetsResult = z.infer<typeof performanceFeedbackFacetsResultSchema>;