jev-recipes 0.5.2 → 0.6.0

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const tempoChangeVerdictSchema = z.enum(['slower', 'same', 'faster', 'unclear']);
+export const tempoChangeInputSchema = z.object({
+    context: nonEmptyText,
+    recentMaterial: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const tempoChangeResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: tempoChangeVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(tempoChangeVerdictSchema, probability),
+});

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

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "progression": "Am - F - Dm7 - G7 - G7(b9) with the melody suspended on C over the bass, held for two full bars and swelling (current chord)",
+    "key": "C major",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.76,
+        "confidence": 0.83,
+        "probabilities": { "0": 0.01, "1": 0.01, "2": 0.02, "3": 0.13, "4": 0.83 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TensionLevelInput, TensionLevelResult } from './schema.js';
+export declare function tensionLevel(input: TensionLevelInput, options?: RecipeOptions): Promise<TensionLevelResult>;
+export { tensionLevelInputSchema, tensionLevelResultSchema, tensionLevelVerdictSchema, } from './schema.js';
+export type { TensionLevelInput, TensionLevelResult, TensionLevelVerdict } from './schema.js';

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

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { tensionLevelInputSchema, tensionLevelResultSchema, tensionLevelVerdictSchema, } from './schema.js';
+export async function tensionLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = tensionLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How much harmonic tension does the current point in progression carry, given key when it is supplied? Judge only the last chord or event in progression and the expectation the chords before it have set up: whether it is a stable home chord, a mild departure, a pre-dominant leaning away, a dominant or other unresolved sonority pulling toward resolution, or a dominant stacked with dissonance, suspension, or a long hold that demands resolution now. Use annotations in the text about held notes, suspensions, or pedal tones as given. Do not compute scale degrees or check voice leading; judge the pull as described.', [
+        'The current point sits on the tonic or another home chord with no pending dissonance described, so nothing calls for a further move.',
+        'The current chord is stable or only mildly colored, such as a subdominant or an added-sixth chord, and the progression could rest or move on without strain.',
+        'The current point leans away from home, such as a pre-dominant or a secondary chord, so a listener expects more but is not yet pressed.',
+        'The current chord is a dominant or another unresolved sonority that clearly pulls toward a resolution.',
+        'The current point stacks dominant function with added dissonance, a suspension, or a described long hold, so the progression demands resolution immediately.',
+    ], options);
+    return tensionLevelResultSchema.parse({
+        ...decision,
+        tension: tensionLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { tensionLevelInputSchema, tensionLevelResultSchema, tensionLevelVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const tensionLevelVerdictSchema: z.ZodEnum<{
+    low: "low";
+    moderate: "moderate";
+    high: "high";
+    resolved: "resolved";
+    peak: "peak";
+}>;
+export declare const tensionLevelInputSchema: z.ZodObject<{
+    progression: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const tensionLevelResultSchema: 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>;
+    tension: z.ZodEnum<{
+        low: "low";
+        moderate: "moderate";
+        high: "high";
+        resolved: "resolved";
+        peak: "peak";
+    }>;
+}, z.core.$strip>;
+export type TensionLevelVerdict = z.infer<typeof tensionLevelVerdictSchema>;
+export type TensionLevelInput = z.infer<typeof tensionLevelInputSchema>;
+export type TensionLevelResult = z.infer<typeof tensionLevelResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const tensionLevelVerdictSchema = z.enum(['resolved', 'low', 'moderate', 'high', 'peak']);
+export const tensionLevelInputSchema = z.object({
+    progression: nonEmptyText,
+    key: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const tensionLevelResultSchema = scoreResultSchema.extend({
+    tension: tensionLevelVerdictSchema,
+});

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

@@ -0,0 +1,26 @@
+{
+  "input": {
+    "task": "Extract every line-item table from a batch of 40 scanned supplier invoices, delivered as image-only PDFs, into CSV rows with the page number each row came from.",
+    "firstTool": "pdf_text_extract: returns the embedded text layer of a PDF as a single plain-text string per page. Does not perform OCR and returns empty output for scanned or image-only pages.",
+    "secondTool": "document_ocr_tables: runs OCR on scanned or image-based PDFs and returns detected tables as structured rows, each with cell text, a table index, and the source page number.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "second",
+        "confidence": 0.93,
+        "probabilities": {
+          "first": 0.02,
+          "second": 0.93,
+          "tie": 0.02,
+          "neither": 0.02,
+          "unclear": 0.01
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ToolCompareInput, ToolCompareResult } from './schema.js';
+export declare function toolCompare(input: ToolCompareInput, options?: RecipeOptions): Promise<ToolCompareResult>;
+export { toolCompareInputSchema, toolCompareResultSchema, toolCompareVerdictSchema, } from './schema.js';
+export type { ToolCompareInput, ToolCompareResult, ToolCompareVerdict } from './schema.js';

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

@@ -0,0 +1,16 @@
+import { evaluateComparison } from '../../src/comparisons.js';
+import { toolCompareInputSchema, toolCompareResultSchema } from './schema.js';
+export async function toolCompare(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = toolCompareInputSchema.parse(input);
+    const decision = await evaluateComparison(state, 'Which tool better fits task, judged only by the capabilities each description states? Prefer the tool whose described inputs, outputs, and behavior cover what task requires with the least missing or irrelevant capability. Ignore tool names, description length, and any capability the description does not state.', {
+        first: "Only the first tool's described capabilities cover what the task requires, or they cover it clearly better than the second tool's.",
+        second: "Only the second tool's described capabilities cover what the task requires, or they cover it clearly better than the first tool's.",
+        tie: "Both tools' described capabilities cover the task about equally well.",
+        neither: "Neither tool's described capabilities cover what the task requires.",
+    }, options);
+    return toolCompareResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { toolCompareInputSchema, toolCompareResultSchema, toolCompareVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const toolCompareVerdictSchema: z.ZodEnum<{
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+    unclear: "unclear";
+}>;
+export declare const toolCompareInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    firstTool: z.ZodString;
+    secondTool: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const toolCompareResultSchema: 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 ToolCompareVerdict = z.infer<typeof toolCompareVerdictSchema>;
+export type ToolCompareInput = z.infer<typeof toolCompareInputSchema>;
+export type ToolCompareResult = z.infer<typeof toolCompareResultSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { comparisonResultSchema, comparisonVerdictSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const toolCompareVerdictSchema = comparisonVerdictSchema;
+export const toolCompareInputSchema = z.object({
+    task: nonEmptyText,
+    firstTool: nonEmptyText,
+    secondTool: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const toolCompareResultSchema = comparisonResultSchema;

package/dist/recipes/trip-purpose-kind/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "message": "We are moving to Lisbon for good at the end of October. My partner's job transfers her there permanently and the kids start school in January. I need one-way flights for the four of us and somewhere to stay for the first three weeks until our long-term lease begins on 20 November.",
+    "context": "Traveler previously asked this assistant about shipping household goods overseas.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "relocation",
+        "confidence": 0.9,
+        "probabilities": {
+          "business": 0.02,
+          "leisure": 0.01,
+          "family_visit": 0.02,
+          "medical": 0.01,
+          "relocation": 0.9,
+          "event": 0.01,
+          "unclear": 0.03
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/trip-purpose-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TripPurposeKindInput, TripPurposeKindResult } from './schema.js';
+export declare function tripPurposeKind(input: TripPurposeKindInput, options?: RecipeOptions): Promise<TripPurposeKindResult>;
+export { tripPurposeKindInputSchema, tripPurposeKindResultSchema, tripPurposeKindVerdictSchema, } from './schema.js';
+export type { TripPurposeKindInput, TripPurposeKindResult, TripPurposeKindVerdict, } from './schema.js';

package/dist/recipes/trip-purpose-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { tripPurposeKindInputSchema, tripPurposeKindResultSchema } from './schema.js';
+export async function tripPurposeKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = tripPurposeKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Decide which purpose the traveler expresses for the trip in message, using context only to interpret references in the message. Judge from what the traveler says about why they are going, not from the destination, budget, or booking channel. If the message gives no indication of purpose, or several purposes carry equal weight, choose unclear.', {
+        business: 'The traveler says the trip is for work: meetings, a conference for their job, client visits, site work, or employer-directed travel.',
+        leisure: 'The traveler says the trip is for vacation, sightseeing, rest, or recreation with no other stated purpose.',
+        family_visit: 'The traveler says the trip is to visit or spend time with family or close friends where they live.',
+        medical: 'The traveler says the trip is to receive or accompany someone to medical treatment, consultation, or recovery.',
+        relocation: 'The traveler says they are moving to the destination to live, whether permanently or for an extended posting, rather than visiting.',
+        event: 'The traveler says the trip is to attend a specific occasion such as a wedding, concert, festival, sporting event, or graduation that is not their own job.',
+        unclear: 'The message does not express why the traveler is going, or it names several purposes with no dominant one.',
+    }, options);
+    return tripPurposeKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { tripPurposeKindInputSchema, tripPurposeKindResultSchema, tripPurposeKindVerdictSchema, } from './schema.js';

package/dist/recipes/trip-purpose-kind/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const tripPurposeKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    business: "business";
+    leisure: "leisure";
+    family_visit: "family_visit";
+    medical: "medical";
+    relocation: "relocation";
+    event: "event";
+}>;
+export declare const tripPurposeKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const tripPurposeKindResultSchema: 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";
+        business: "business";
+        leisure: "leisure";
+        family_visit: "family_visit";
+        medical: "medical";
+        relocation: "relocation";
+        event: "event";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        business: "business";
+        leisure: "leisure";
+        family_visit: "family_visit";
+        medical: "medical";
+        relocation: "relocation";
+        event: "event";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TripPurposeKindVerdict = z.infer<typeof tripPurposeKindVerdictSchema>;
+export type TripPurposeKindInput = z.infer<typeof tripPurposeKindInputSchema>;
+export type TripPurposeKindResult = z.infer<typeof tripPurposeKindResultSchema>;

package/dist/recipes/trip-purpose-kind/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const tripPurposeKindVerdictSchema = z.enum([
+    'business',
+    'leisure',
+    'family_visit',
+    'medical',
+    'relocation',
+    'event',
+    'unclear',
+]);
+export const tripPurposeKindInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const tripPurposeKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: tripPurposeKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(tripPurposeKindVerdictSchema, probability),
+});

package/dist/recipes/turn-intent/schema.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const turnIntentVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
     answer: "answer";
     cancellation: "cancellation";
     correction: "correction";
-    unclear: "unclear";
     request: "request";
     other: "other";
     acknowledgment: "acknowledgment";
@@ -24,20 +24,20 @@ export declare const turnIntentResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
+        unclear: "unclear";
         answer: "answer";
         cancellation: "cancellation";
         correction: "correction";
-        unclear: "unclear";
         request: "request";
         other: "other";
         acknowledgment: "acknowledgment";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
         answer: "answer";
         cancellation: "cancellation";
         correction: "correction";
-        unclear: "unclear";
         request: "request";
         other: "other";
         acknowledgment: "acknowledgment";

package/dist/src/answers.d.ts

@@ -5,3 +5,9 @@ export declare function parseChoiceAnswer<T extends string>(answer: unknown, cho
     probabilities: Record<({ [k_1 in T]: k_1; } extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never)[T], number>;
 };
 export declare function parseYesProbability(answer: unknown): number;
+export declare function parseScoreAnswer(answer: unknown, levelCount: number): {
+    score: number;
+    level: number;
+    confidence: number;
+    probabilities: Record<string, number>;
+};

package/dist/src/answers.js

@@ -29,3 +29,26 @@ function hasMostLikelyChoice(answer) {
     const highestProbability = Math.max(...Object.values(answer.probabilities));
     return selectedProbability !== undefined && selectedProbability >= highestProbability - 1e-9;
 }
+export function parseScoreAnswer(answer, levelCount) {
+    const levels = Array.from({ length: levelCount }, (_, index) => String(index));
+    const scoreAnswerSchema = z
+        .object({
+        type: z.literal('score'),
+        score: z
+            .number()
+            .min(0)
+            .max(levelCount - 1),
+        confidence: probability,
+        probabilities: z.record(z.enum(levels), probability),
+    })
+        .refine(hasCompleteProbabilityMass, 'Jev probabilities must sum to 1.')
+        .refine((parsed) => Object.keys(parsed.probabilities).length === levelCount, 'Jev must report a probability for every rubric level.');
+    const parsed = scoreAnswerSchema.parse(answer);
+    const [mostLikelyLevel] = Object.entries(parsed.probabilities).reduce((best, entry) => entry[1] > best[1] ? entry : best);
+    return {
+        score: parsed.score,
+        level: Number(mostLikelyLevel),
+        confidence: parsed.confidence,
+        probabilities: parsed.probabilities,
+    };
+}

package/dist/src/comparisons.d.ts

@@ -0,0 +1,11 @@
+import type { ComparisonCriteria, RecipeOptions } from './schema.js';
+export declare function evaluateComparison(state: Record<string, unknown>, instruction: string, criteria: ComparisonCriteria, options?: RecipeOptions, questionName?: string): Promise<{
+    verdict: "first" | "second" | "tie" | "neither" | "unclear";
+    confidence: number;
+    probabilities: Record<string, number>;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}>;

package/dist/src/comparisons.js

@@ -0,0 +1,9 @@
+import { evaluateChoice } from './decisions.js';
+import { comparisonCriteriaSchema, comparisonVerdictSchema } from './schema.js';
+export async function evaluateComparison(state, instruction, criteria, options = {}, questionName = 'decision') {
+    const decision = await evaluateChoice(state, `${instruction} Treat presentation order as irrelevant. Allow a tie or neither.`, {
+        ...comparisonCriteriaSchema.parse(criteria),
+        unclear: 'There is insufficient information to make the comparison.',
+    }, options, questionName);
+    return { ...decision, verdict: comparisonVerdictSchema.parse(decision.verdict) };
+}

package/dist/src/gates.d.ts

@@ -0,0 +1,10 @@
+import type { GateCriteria, RecipeOptions } from './schema.js';
+export declare function evaluateGate(state: Record<string, unknown>, instruction: string, criteria: GateCriteria, options?: RecipeOptions, questionName?: string): Promise<{
+    probability: number;
+    confidence: number;
+    model: string;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}>;

package/dist/src/gates.js

@@ -0,0 +1,20 @@
+import { noul } from '@typesafe-ai/sdk';
+import { evaluateWithJev } from './client.js';
+import { parseYesProbability } from './answers.js';
+import { asDecisionInstruction, parseDecisionState } from './decisions.js';
+import { gateCriteriaSchema } from './schema.js';
+export async function evaluateGate(state, instruction, criteria, options = {}, questionName = 'gate') {
+    const response = await evaluateWithJev({
+        state: parseDecisionState(state),
+        questions: {
+            [questionName]: noul(asDecisionInstruction(instruction), gateCriteriaSchema.parse(criteria)),
+        },
+    }, options);
+    const probability = parseYesProbability(response.answers[questionName]);
+    return {
+        probability,
+        confidence: Math.max(probability, 1 - probability),
+        model: response.model,
+        usage: response.usage,
+    };
+}