jev-recipes 0.6.0 → 0.7.0

package/dist/recipes/context-prune/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ContextPruneInput, ContextPruneResult } from './schema.js';
+export declare function contextPrune(input: ContextPruneInput, options?: RecipeOptions): Promise<ContextPruneResult>;
+export { contextPruneInputSchema, contextPruneResultSchema, contextPruneItemSchema, contextPruneVerdictSchema, } from './schema.js';
+export type { ContextPruneInput, ContextPruneResult, ContextPruneItem, ContextPruneVerdict, } from './schema.js';

package/dist/recipes/context-prune/index.js

@@ -0,0 +1,42 @@
+import { noul } from '@typesafe-ai/sdk';
+import { evaluateWithJev } from '../../src/client.js';
+import { parseYesProbability } from '../../src/answers.js';
+import { asDecisionInstruction, parseDecisionState } from '../../src/decisions.js';
+import { contextPruneInputSchema, contextPruneResultSchema } from './schema.js';
+export async function contextPrune(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = contextPruneInputSchema.parse(input);
+    const response = await evaluateWithJev({
+        state: parseDecisionState(state),
+        questions: Object.fromEntries(state.items.map((_, index) => [
+            `item_${index}`,
+            noul(asDecisionInstruction(`Will items[${index}].text still be needed to finish objective? Count it needed when it holds facts, results, decisions, errors, or user instructions the remaining work depends on, or when it is the only record of something that must not be redone. Do not count it needed merely because it was useful earlier, is long, or is recent; use recent, when supplied, for what has already been handled. Judge only this item.`), {
+                true: 'The remaining work depends on this item.',
+                false: 'The remaining work can proceed without this item.',
+            }),
+        ])),
+    }, options);
+    const items = state.items.map((item, index) => {
+        const probability = parseYesProbability(response.answers[`item_${index}`]);
+        const confidence = Math.max(probability, 1 - probability);
+        return {
+            id: item.id,
+            status: confidence < minConfidence ? 'review' : 'ready',
+            verdict: probability >= 0.5 ? 'keep' : 'drop',
+            probability,
+            confidence,
+        };
+    });
+    const drop = items
+        .filter((item) => item.status === 'ready' && item.verdict === 'drop')
+        .map((item) => item.id);
+    return contextPruneResultSchema.parse({
+        status: items.some((item) => item.status === 'review') ? 'review' : 'ready',
+        items,
+        keep: items.filter((item) => !drop.includes(item.id)).map((item) => item.id),
+        drop,
+        evaluated: items.length,
+        model: response.model,
+        usage: response.usage,
+    });
+}
+export { contextPruneInputSchema, contextPruneResultSchema, contextPruneItemSchema, contextPruneVerdictSchema, } from './schema.js';

package/dist/recipes/context-prune/schema.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export declare const contextPruneVerdictSchema: z.ZodEnum<{
+    keep: "keep";
+    drop: "drop";
+}>;
+export declare const contextPruneInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    recent: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const contextPruneItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        keep: "keep";
+        drop: "drop";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const contextPruneResultSchema: 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";
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            review: "review";
+        }>;
+        verdict: z.ZodEnum<{
+            keep: "keep";
+            drop: "drop";
+        }>;
+        probability: z.ZodNumber;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>;
+    keep: z.ZodArray<z.ZodString>;
+    drop: z.ZodArray<z.ZodString>;
+    evaluated: z.ZodNumber;
+}, z.core.$strip>;
+export type ContextPruneVerdict = z.infer<typeof contextPruneVerdictSchema>;
+export type ContextPruneInput = z.infer<typeof contextPruneInputSchema>;
+export type ContextPruneItem = z.infer<typeof contextPruneItemSchema>;
+export type ContextPruneResult = z.infer<typeof contextPruneResultSchema>;

package/dist/recipes/context-prune/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, textItemsSchema, } from '../../src/schema.js';
+export const contextPruneVerdictSchema = z.enum(['keep', 'drop']);
+export const contextPruneInputSchema = z.object({
+    objective: nonEmptyText,
+    items: textItemsSchema,
+    recent: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const contextPruneItemSchema = z.object({
+    id: nonEmptyText,
+    status: decisionStatusSchema,
+    verdict: contextPruneVerdictSchema,
+    probability,
+    confidence: probability,
+});
+export const contextPruneResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    items: z.array(contextPruneItemSchema),
+    keep: z.array(nonEmptyText),
+    drop: z.array(nonEmptyText),
+    evaluated: z.number().int().nonnegative(),
+});

package/dist/recipes/diff-hazards/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "diff": "--- a/src/payments.ts\n+++ b/src/payments.ts\n@@ -1,6 +1,9 @@\n import { Stripe } from 'stripe';\n-const stripe = new Stripe(process.env.STRIPE_KEY);\n+const stripe = new Stripe('sk_prod_51Hq9zLKj3mD8vXyZ2pQ7rT4wN6bF0cE1gA5hJ8kL');\n+console.log('DEBUG charge payload', payload);\n export async function charge(payload) {\n   return stripe.charges.create(payload);\n }",
+    "context": "Pre-commit screen for a payments service.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "secretLeak": { "type": "noul", "noul": 0.97 },
+      "destructiveCommand": { "type": "noul", "noul": 0.03 },
+      "debugLeftover": { "type": "noul", "noul": 0.93 },
+      "testsWeakened": { "type": "noul", "noul": 0.04 },
+      "dependencyChange": { "type": "noul", "noul": 0.05 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/diff-hazards/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { DiffHazardsInput, DiffHazardsResult } from './schema.js';
+export declare function diffHazards(input: DiffHazardsInput, options?: RecipeOptions): Promise<DiffHazardsResult>;
+export { diffHazardsInputSchema, diffHazardsResultSchema, diffHazardsLabelSchema, } from './schema.js';
+export type { DiffHazardsInput, DiffHazardsResult, DiffHazardsLabel } from './schema.js';

package/dist/recipes/diff-hazards/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { diffHazardsInputSchema, diffHazardsResultSchema } from './schema.js';
+export async function diffHazards(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = diffHazardsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        secretLeak: {
+            instruction: 'Does diff add a credential, API key, token, password, private key, or connection string containing a secret? Placeholders such as YOUR_KEY_HERE, environment variable references, and clearly fake example values do not count.',
+            criteria: {
+                true: 'The diff adds what appears to be a real secret value.',
+                false: 'The diff adds no secret value, or only placeholders and references.',
+            },
+        },
+        destructiveCommand: {
+            instruction: 'Does diff add a command or statement that deletes, drops, truncates, overwrites, or force-pushes data or history, such as rm -rf, DROP TABLE, TRUNCATE, git push --force, or a migration that removes columns or rows?',
+            criteria: {
+                true: 'The diff adds a destructive command or data-removing statement.',
+                false: 'The diff adds no destructive command.',
+            },
+        },
+        debugLeftover: {
+            instruction: 'Does diff add debugging artifacts that should not ship, such as print or console.log statements used for tracing, debugger statements, commented-out code blocks, hard-coded test values, or notes like TODO remove or HACK?',
+            criteria: {
+                true: 'The diff adds debugging or scaffolding leftovers.',
+                false: 'The diff adds no debugging leftovers, or only intentional logging.',
+            },
+        },
+        testsWeakened: {
+            instruction: 'Does diff remove or weaken tests, for example by deleting test cases, skipping or disabling tests, removing assertions, loosening expected values, or adding broad exception catches inside tests?',
+            criteria: {
+                true: 'The diff removes, skips, or weakens tests.',
+                false: 'The diff leaves tests as strong as before or strengthens them.',
+            },
+        },
+        dependencyChange: {
+            instruction: 'Does diff add, remove, or change the version of a third-party dependency, for example in package.json, requirements.txt, go.mod, Cargo.toml, a lockfile, or an import of a package that is not already used?',
+            criteria: {
+                true: "The diff changes the project's third-party dependencies.",
+                false: 'The diff does not change dependencies.',
+            },
+        },
+    }, options);
+    return diffHazardsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { diffHazardsInputSchema, diffHazardsResultSchema, diffHazardsLabelSchema, } from './schema.js';

package/dist/recipes/diff-hazards/schema.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+export declare const diffHazardsLabelSchema: z.ZodEnum<{
+    secretLeak: "secretLeak";
+    destructiveCommand: "destructiveCommand";
+    debugLeftover: "debugLeftover";
+    testsWeakened: "testsWeakened";
+    dependencyChange: "dependencyChange";
+}>;
+export declare const diffHazardsInputSchema: z.ZodObject<{
+    diff: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const diffHazardsResultSchema: 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<{
+        secretLeak: "secretLeak";
+        destructiveCommand: "destructiveCommand";
+        debugLeftover: "debugLeftover";
+        testsWeakened: "testsWeakened";
+        dependencyChange: "dependencyChange";
+    }>>;
+    labels: z.ZodObject<{
+        secretLeak: 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>;
+        destructiveCommand: 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>;
+        debugLeftover: 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>;
+        testsWeakened: 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>;
+        dependencyChange: 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 DiffHazardsLabel = z.infer<typeof diffHazardsLabelSchema>;
+export type DiffHazardsInput = z.infer<typeof diffHazardsInputSchema>;
+export type DiffHazardsResult = z.infer<typeof diffHazardsResultSchema>;

package/dist/recipes/diff-hazards/schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const diffHazardsLabelSchema = z.enum([
+    'secretLeak',
+    'destructiveCommand',
+    'debugLeftover',
+    'testsWeakened',
+    'dependencyChange',
+]);
+export const diffHazardsInputSchema = z.object({
+    diff: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const diffHazardsResultSchema = labelsResultSchema.extend({
+    detected: z.array(diffHazardsLabelSchema),
+    labels: z.object({
+        secretLeak: labelCheckSchema,
+        destructiveCommand: labelCheckSchema,
+        debugLeftover: labelCheckSchema,
+        testsWeakened: labelCheckSchema,
+        dependencyChange: labelCheckSchema,
+    }),
+});

package/dist/recipes/extraction-fidelity/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const extractionFidelityVerdictSchema: z.ZodEnum<{
+    exact: "exact";
     low: "low";
     high: "high";
-    exact: "exact";
     poor: "poor";
     fair: "fair";
 }>;
@@ -26,9 +26,9 @@ export declare const extractionFidelityResultSchema: z.ZodObject<{
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
     fidelity: z.ZodEnum<{
+        exact: "exact";
         low: "low";
         high: "high";
-        exact: "exact";
         poor: "poor";
         fair: "fair";
     }>;

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/recipes/handoff/schema.d.ts

@@ -29,8 +29,8 @@ export declare const handoffResultSchema: z.ZodObject<{
     }>;
     decision: z.ZodEnum<{
         review: "review";
-        human: "human";
         continue: "continue";
+        human: "human";
     }>;
     matchedRules: z.ZodArray<z.ZodString>;
     uncertainRules: z.ZodArray<z.ZodString>;

package/dist/recipes/model-route/demo.json

@@ -0,0 +1,45 @@
+{
+  "input": {
+    "request": "Rename the variable `usr` to `user` in src/session.ts and fix any references.",
+    "models": [
+      {
+        "id": "fast",
+        "text": "Small, cheap, fast model. Good for edits with one obvious approach, reformatting, short answers, and simple lookups. Weak at multi-step reasoning and subtle bugs."
+      },
+      {
+        "id": "balanced",
+        "text": "Mid-size model at moderate cost. Handles multi-file changes, explanations, and routine debugging. Occasionally misses subtle design issues."
+      },
+      {
+        "id": "frontier",
+        "text": "Largest, slowest, most expensive model. Best for architecture, security-sensitive code, ambiguous requirements, and hard debugging."
+      }
+    ],
+    "context": "Coding agent inside a small TypeScript repository with tests.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "candidate_0",
+        "confidence": 0.92,
+        "probabilities": {
+          "candidate_0": 0.92,
+          "candidate_1": 0.05,
+          "candidate_2": 0.01,
+          "none": 0.01,
+          "ambiguous": 0.01
+        }
+      },
+      "effort": {
+        "type": "score",
+        "score": 0.1,
+        "confidence": 0.9,
+        "probabilities": { "0": 0.9, "1": 0.1, "2": 0 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/model-route/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ModelRouteInput, ModelRouteResult } from './schema.js';
+export declare function modelRoute(input: ModelRouteInput, options?: RecipeOptions): Promise<ModelRouteResult>;
+export { modelRouteInputSchema, modelRouteResultSchema, modelRouteEffortSchema } from './schema.js';
+export type { ModelRouteInput, ModelRouteResult, ModelRouteEffort } from './schema.js';

package/dist/recipes/model-route/index.js

@@ -0,0 +1,35 @@
+import { score } from '@typesafe-ai/sdk';
+import { evaluateWithJev } from '../../src/client.js';
+import { parseScoreAnswer } from '../../src/answers.js';
+import { parseDecisionState } from '../../src/decisions.js';
+import { asScoreInstruction } from '../../src/scores.js';
+import { resolveSelection, selectionQuestion } from '../../src/selection.js';
+import { modelRouteInputSchema, modelRouteResultSchema, modelRouteEffortSchema } from './schema.js';
+const EFFORT_RUBRIC = [
+    'A direct lookup, small edit, reformat, or short factual answer with one obvious approach and little risk if slightly wrong.',
+    'A task with a few interacting parts, some judgment about approach, or moderate consequences, such as a multi-file change or an explanation that must be accurate.',
+    'A task that needs careful multi-step reasoning, novel design, subtle debugging, or where a mistake is costly, such as architecture decisions, security-sensitive code, or ambiguous requirements.',
+];
+export async function modelRoute(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = modelRouteInputSchema.parse(input);
+    const response = await evaluateWithJev({
+        state: parseDecisionState(state),
+        questions: {
+            decision: selectionQuestion(state.models, 'Which of models should handle request, given any context? Each model describes its strengths, weaknesses, and cost. Prefer the cheapest model whose described capabilities clearly cover the request; escalate only when the request needs a capability a cheaper model lacks.'),
+            effort: score(asScoreInstruction('How much reasoning effort does request need to be handled well, given any context?', EFFORT_RUBRIC), EFFORT_RUBRIC),
+        },
+    }, options);
+    const selection = resolveSelection(response.answers.decision, state.models, minConfidence);
+    const effort = parseScoreAnswer(response.answers.effort, EFFORT_RUBRIC.length);
+    return modelRouteResultSchema.parse({
+        ...selection,
+        effort: modelRouteEffortSchema.options[effort.level],
+        effortLevel: effort.level,
+        effortScore: effort.score,
+        effortConfidence: effort.confidence,
+        effortProbabilities: effort.probabilities,
+        model: response.model,
+        usage: response.usage,
+    });
+}
+export { modelRouteInputSchema, modelRouteResultSchema, modelRouteEffortSchema } from './schema.js';

package/dist/recipes/model-route/schema.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const modelRouteEffortSchema: z.ZodEnum<{
+    low: "low";
+    high: "high";
+    medium: "medium";
+}>;
+export declare const modelRouteInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const modelRouteResultSchema: 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<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+    effort: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        medium: "medium";
+    }>;
+    effortLevel: z.ZodNumber;
+    effortScore: z.ZodNumber;
+    effortConfidence: z.ZodNumber;
+    effortProbabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type ModelRouteEffort = z.infer<typeof modelRouteEffortSchema>;
+export type ModelRouteInput = z.infer<typeof modelRouteInputSchema>;
+export type ModelRouteResult = z.infer<typeof modelRouteResultSchema>;

package/dist/recipes/model-route/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const modelRouteEffortSchema = z.enum(['low', 'medium', 'high']);
+export const modelRouteInputSchema = z.object({
+    request: nonEmptyText,
+    models: textItemsSchema,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const modelRouteResultSchema = selectionResultSchema.extend({
+    effort: modelRouteEffortSchema,
+    effortLevel: z.number().int().min(0).max(2),
+    effortScore: z.number().min(0).max(2),
+    effortConfidence: probability,
+    effortProbabilities: z.record(z.string(), probability),
+});