jev-recipes 0.0.1 → 0.0.4

package/dist/catalog/recipes.d.ts

@@ -0,0 +1,351 @@
+import type { RecipeOptions } from '../src/schema.js';
+export declare const recipes: {
+    route: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            routes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            route: import("zod").ZodNullable<import("zod").ZodString>;
+            suggestedRoute: import("zod").ZodNullable<import("zod").ZodString>;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            route: string | null;
+            suggestedRoute: string | null;
+            confidence: number;
+            probabilities: Record<string, number>;
+        }>;
+    };
+    rerank: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "retrieval";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            query: import("zod").ZodString;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+            minRelevance: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            items: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                text: import("zod").ZodString;
+                relevance: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            evaluated: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            items: {
+                id: string;
+                text: string;
+                relevance: number;
+            }[];
+            evaluated: number;
+        }>;
+    };
+    verify: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "retrieval";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            claims: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                claim: import("zod").ZodString;
+                evidence: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    supported: "supported";
+                    contradicted: "contradicted";
+                    unsupported: "unsupported";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    supported: "supported";
+                    contradicted: "contradicted";
+                    unsupported: "unsupported";
+                }>, import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            allSupported: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "supported" | "contradicted" | "unsupported";
+                confidence: number;
+                probabilities: Record<"supported" | "contradicted" | "unsupported", number>;
+            }[];
+            allSupported: boolean;
+        }>;
+    };
+    answerability: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "retrieval";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            question: import("zod").ZodString;
+            evidence: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                text: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: import("zod").ZodEnum<{
+                sufficient: "sufficient";
+                partial: "partial";
+                insufficient: "insufficient";
+                conflicting: "conflicting";
+            }>;
+            canAnswer: import("zod").ZodBoolean;
+            confidence: import("zod").ZodNumber;
+            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                sufficient: "sufficient";
+                partial: "partial";
+                insufficient: "insufficient";
+                conflicting: "conflicting";
+            }>, import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            verdict: "sufficient" | "partial" | "insufficient" | "conflicting";
+            canAnswer: boolean;
+            confidence: number;
+            probabilities: Record<"sufficient" | "partial" | "insufficient" | "conflicting", number>;
+        }>;
+    };
+    clarify: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "conversation";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            requirements: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                description: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            canProceed: import("zod").ZodBoolean;
+            missing: import("zod").ZodArray<import("zod").ZodString>;
+            ambiguous: import("zod").ZodArray<import("zod").ZodString>;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>, import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            canProceed: boolean;
+            missing: string[];
+            ambiguous: string[];
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "present" | "missing" | "ambiguous";
+                confidence: number;
+                probabilities: Record<"present" | "missing" | "ambiguous", number>;
+            }[];
+        }>;
+    };
+    handoff: {
+        metadata: {
+            id: string;
+            title: string;
+            description: string;
+            category: "workflow";
+            tags: string[];
+            limitations: string[];
+        };
+        inputSchema: import("zod").ZodObject<{
+            request: import("zod").ZodString;
+            context: import("zod").ZodOptional<import("zod").ZodString>;
+            rules: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                description: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>;
+            minConfidence: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>;
+        resultSchema: import("zod").ZodObject<{
+            model: import("zod").ZodString;
+            usage: import("zod").ZodObject<{
+                input_tokens: import("zod").ZodNumber;
+                output_tokens: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>;
+            status: import("zod").ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            decision: import("zod").ZodEnum<{
+                review: "review";
+                human: "human";
+                continue: "continue";
+            }>;
+            matchedRules: import("zod").ZodArray<import("zod").ZodString>;
+            uncertainRules: import("zod").ZodArray<import("zod").ZodString>;
+            checks: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                status: import("zod").ZodEnum<{
+                    ready: "ready";
+                    review: "review";
+                }>;
+                verdict: import("zod").ZodEnum<{
+                    matches: "matches";
+                    does_not_match: "does_not_match";
+                    unclear: "unclear";
+                }>;
+                confidence: import("zod").ZodNumber;
+                probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
+                    matches: "matches";
+                    does_not_match: "does_not_match";
+                    unclear: "unclear";
+                }>, import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+        run: (input: unknown, options?: RecipeOptions) => Promise<{
+            model: string;
+            usage: {
+                input_tokens: number;
+                output_tokens: number;
+            };
+            status: "ready" | "review";
+            decision: "review" | "human" | "continue";
+            matchedRules: string[];
+            uncertainRules: string[];
+            checks: {
+                id: string;
+                status: "ready" | "review";
+                verdict: "matches" | "does_not_match" | "unclear";
+                confidence: number;
+                probabilities: Record<"matches" | "does_not_match" | "unclear", number>;
+            }[];
+        }>;
+    };
+};

package/dist/catalog/recipes.js

@@ -0,0 +1,50 @@
+import { route, routeInputSchema, routeResultSchema } from '../recipes/route/index.js';
+import { metadata as routeMetadata } from '../recipes/route/metadata.js';
+import { rerank, rerankInputSchema, rerankResultSchema } from '../recipes/rerank/index.js';
+import { metadata as rerankMetadata } from '../recipes/rerank/metadata.js';
+import { verify, verifyInputSchema, verifyResultSchema } from '../recipes/verify/index.js';
+import { metadata as verifyMetadata } from '../recipes/verify/metadata.js';
+import { answerability, answerabilityInputSchema, answerabilityResultSchema, } from '../recipes/answerability/index.js';
+import { metadata as answerabilityMetadata } from '../recipes/answerability/metadata.js';
+import { clarify, clarifyInputSchema, clarifyResultSchema } from '../recipes/clarify/index.js';
+import { metadata as clarifyMetadata } from '../recipes/clarify/metadata.js';
+import { handoff, handoffInputSchema, handoffResultSchema } from '../recipes/handoff/index.js';
+import { metadata as handoffMetadata } from '../recipes/handoff/metadata.js';
+export const recipes = {
+    route: {
+        metadata: routeMetadata,
+        inputSchema: routeInputSchema,
+        resultSchema: routeResultSchema,
+        run: (input, options) => route(routeInputSchema.parse(input), options),
+    },
+    rerank: {
+        metadata: rerankMetadata,
+        inputSchema: rerankInputSchema,
+        resultSchema: rerankResultSchema,
+        run: (input, options) => rerank(rerankInputSchema.parse(input), options),
+    },
+    verify: {
+        metadata: verifyMetadata,
+        inputSchema: verifyInputSchema,
+        resultSchema: verifyResultSchema,
+        run: (input, options) => verify(verifyInputSchema.parse(input), options),
+    },
+    answerability: {
+        metadata: answerabilityMetadata,
+        inputSchema: answerabilityInputSchema,
+        resultSchema: answerabilityResultSchema,
+        run: (input, options) => answerability(answerabilityInputSchema.parse(input), options),
+    },
+    clarify: {
+        metadata: clarifyMetadata,
+        inputSchema: clarifyInputSchema,
+        resultSchema: clarifyResultSchema,
+        run: (input, options) => clarify(clarifyInputSchema.parse(input), options),
+    },
+    handoff: {
+        metadata: handoffMetadata,
+        inputSchema: handoffInputSchema,
+        resultSchema: handoffResultSchema,
+        run: (input, options) => handoff(handoffInputSchema.parse(input), options),
+    },
+};

package/dist/catalog/schema.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const recipeNameSchema: z.ZodEnum<{
+    route: "route";
+    answerability: "answerability";
+    rerank: "rerank";
+    verify: "verify";
+    clarify: "clarify";
+    handoff: "handoff";
+}>;
+export declare const recipeFiltersSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodEnum<{
+        retrieval: "retrieval";
+        conversation: "conversation";
+        workflow: "workflow";
+    }>>;
+}, z.core.$strip>;
+export type RecipeName = z.infer<typeof recipeNameSchema>;
+export type RecipeFilters = z.infer<typeof recipeFiltersSchema>;

package/dist/catalog/schema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { nonEmptyText, recipeCategorySchema } from '../src/schema.js';
+import { recipes } from './recipes.js';
+const recipeNames = Object.keys(recipes);
+export const recipeNameSchema = z.enum(recipeNames);
+export const recipeFiltersSchema = z.object({
+    query: nonEmptyText.optional(),
+    category: recipeCategorySchema.optional(),
+});

package/dist/cli/index.js

@@ -2,7 +2,8 @@
 import { readFile } from 'node:fs/promises';
 import { stdin, stdout, stderr } from 'node:process';
 import { z } from 'zod';
-import { recipes } from './recipes.js';
+import { recipes } from '../catalog/recipes.js';
+import { listRecipes, describeRecipe, recipeCategorySchema } from '../catalog/index.js';
 import { commandArgumentsSchema, demoFixtureSchema } from './schema.js';
 async function main() {
     const command = parseCommandArguments(process.argv.slice(2));
@@ -13,11 +14,13 @@ async function main() {
         case '--version':
             return printVersion();
         case 'list':
-            return printRecipeList();
+            return printRecipeList(command.slice(1));
+        case 'describe':
+            return printRecipeDescription(command[1]);
         case 'example':
             return printExampleInput(command[1]);
         case 'demo':
-            return runOfflineRecipe(command[1]);
+            return runOfflineRecipes(command[1]);
         case 'run':
             return runLiveRecipe(command[1], command[2]);
     }
@@ -31,12 +34,15 @@ function parseCommandArguments(args) {
 function printHelp() {
     stdout.write(`jev-recipes
 
-  jev-recipes list                       List recipes
-  jev-recipes demo <recipe>              Run an offline fixture (no model call)
-  jev-recipes example <recipe>           Print example input as JSON
-  jev-recipes run <recipe> <file|->       Run live with a JSON file or stdin
+  jev-recipes list [query] [--category <category>]
+                                        Discover recipes (all search terms must match)
+  jev-recipes describe <recipe>         Print metadata, JSON schemas, and example input
+  jev-recipes demo <recipe|all>         Run offline fixtures (no model calls)
+  jev-recipes example <recipe>          Print example input as JSON
+  jev-recipes run <recipe> <file|->      Run live with a JSON file or stdin
   jev-recipes --version
 
+Categories: retrieval, conversation, workflow. Quote multi-word search queries.
 Live runs send your input to TypeSafe and require TYPESAFE_API_KEY.
 Output is JSON. Errors go to stderr and exit with code 1.
 Review outcomes are successful evaluations; inspect status before acting.
@@ -47,26 +53,36 @@ async function printVersion() {
     const { version } = JSON.parse(packageJson);
     stdout.write(`${version}\n`);
 }
-function printRecipeList() {
-    const recipeList = Object.entries(recipes).map(([id, recipe]) => ({
-        id,
-        description: recipe.description,
-    }));
-    printJson(recipeList);
+function printRecipeList(args) {
+    const categoryPosition = args.indexOf('--category');
+    const query = args[0] === '--category' ? undefined : args[0];
+    const category = categoryPosition === -1 ? undefined : recipeCategorySchema.parse(args[categoryPosition + 1]);
+    printJson(listRecipes({ query, category }));
+}
+async function printRecipeDescription(name) {
+    const fixture = await readDemoFixture(name);
+    printJson({ ...describeRecipe(name), example: fixture.input });
 }
 async function printExampleInput(name) {
     const fixture = await readDemoFixture(name);
     printJson(fixture.input);
 }
-async function runOfflineRecipe(name) {
+async function runOfflineRecipes(name) {
+    const output = name === 'all'
+        ? await Promise.all(listRecipes().map((recipe) => evaluateOfflineRecipe(recipe.id)))
+        : await evaluateOfflineRecipe(name);
+    printJson(output);
+}
+async function evaluateOfflineRecipe(name) {
     const fixture = await readDemoFixture(name);
     const fixtureClient = { systemOne: async () => fixture.response };
     const result = await recipes[name].run(fixture.input, { client: fixtureClient });
-    printJson({
+    return {
         mode: 'demo',
+        recipe: name,
         note: 'Hand-authored fixture. No model was called; this does not measure accuracy.',
         result,
-    });
+    };
 }
 async function runLiveRecipe(name, source) {
     const inputJson = source === '-' ? await readStandardInput() : await readFile(source, 'utf8');

package/dist/cli/schema.d.ts

@@ -1,23 +1,39 @@
 import { z } from 'zod';
-export declare const recipeNameSchema: z.ZodEnum<{
-    route: "route";
-    rerank: "rerank";
-    verify: "verify";
-}>;
 export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.ZodEnum<{
     "--help": "--help";
     "-h": "-h";
-}>], null>, z.ZodTuple<[z.ZodLiteral<"--version">], null>, z.ZodTuple<[z.ZodLiteral<"list">], null>, z.ZodTuple<[z.ZodEnum<{
-    demo: "demo";
+}>], null>, z.ZodTuple<[z.ZodLiteral<"--version">], null>, z.ZodTuple<[z.ZodLiteral<"list">], null>, z.ZodTuple<[z.ZodLiteral<"list">, z.ZodString], null>, z.ZodTuple<[z.ZodLiteral<"list">, z.ZodLiteral<"--category">, z.ZodEnum<{
+    retrieval: "retrieval";
+    conversation: "conversation";
+    workflow: "workflow";
+}>], null>, z.ZodTuple<[z.ZodLiteral<"list">, z.ZodString, z.ZodLiteral<"--category">, z.ZodEnum<{
+    retrieval: "retrieval";
+    conversation: "conversation";
+    workflow: "workflow";
+}>], null>, z.ZodTuple<[z.ZodLiteral<"demo">, z.ZodUnion<readonly [z.ZodEnum<{
+    route: "route";
+    answerability: "answerability";
+    rerank: "rerank";
+    verify: "verify";
+    clarify: "clarify";
+    handoff: "handoff";
+}>, z.ZodLiteral<"all">]>], null>, z.ZodTuple<[z.ZodEnum<{
     example: "example";
+    describe: "describe";
 }>, z.ZodEnum<{
     route: "route";
+    answerability: "answerability";
     rerank: "rerank";
     verify: "verify";
+    clarify: "clarify";
+    handoff: "handoff";
 }>], null>, z.ZodTuple<[z.ZodLiteral<"run">, z.ZodEnum<{
     route: "route";
+    answerability: "answerability";
     rerank: "rerank";
     verify: "verify";
+    clarify: "clarify";
+    handoff: "handoff";
 }>, z.ZodString], null>]>;
 export declare const demoFixtureSchema: z.ZodObject<{
     input: z.ZodUnknown;
@@ -30,4 +46,3 @@ export declare const demoFixtureSchema: z.ZodObject<{
         answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type RecipeName = z.infer<typeof recipeNameSchema>;

package/dist/cli/schema.js

@@ -1,16 +1,16 @@
 import { z } from 'zod';
-import { decisionResponseSchema } from '../src/schema.js';
-import { recipes } from './recipes.js';
-const recipeNames = Object.keys(recipes);
-export const recipeNameSchema = z.enum(recipeNames);
+import { decisionResponseSchema, nonEmptyText, recipeCategorySchema } from '../src/schema.js';
+import { recipeNameSchema } from '../catalog/schema.js';
+const searchQuery = nonEmptyText.refine((query) => !query.startsWith('--'), 'Expected a search query.');
 export const commandArgumentsSchema = z.union([
     z.tuple([z.enum(['--help', '-h'])]),
     z.tuple([z.literal('--version')]),
     z.tuple([z.literal('list')]),
-    z.tuple([z.enum(['demo', 'example']), recipeNameSchema]),
-    z.tuple([z.literal('run'), recipeNameSchema, z.string().min(1)]),
+    z.tuple([z.literal('list'), searchQuery]),
+    z.tuple([z.literal('list'), z.literal('--category'), recipeCategorySchema]),
+    z.tuple([z.literal('list'), searchQuery, z.literal('--category'), recipeCategorySchema]),
+    z.tuple([z.literal('demo'), z.union([recipeNameSchema, z.literal('all')])]),
+    z.tuple([z.enum(['example', 'describe']), recipeNameSchema]),
+    z.tuple([z.literal('run'), recipeNameSchema, nonEmptyText]),
 ]);
-export const demoFixtureSchema = z.object({
-    input: z.unknown(),
-    response: decisionResponseSchema,
-});
+export const demoFixtureSchema = z.object({ input: z.unknown(), response: decisionResponseSchema });

package/dist/examples/support/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/support/index.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { createClient } from '../../src/client.js';
+import { answerSupportRequest } from './workflow.js';
+import { supportFixtureSchema } from './schema.js';
+async function main() {
+    const args = z.union([z.tuple([]), z.tuple([z.literal('--live')])]).parse(process.argv.slice(2));
+    const fixtureJson = await readFile(new URL('../../../examples/support/demo.json', import.meta.url), 'utf8');
+    const fixture = supportFixtureSchema.parse(JSON.parse(fixtureJson));
+    const live = args[0] === '--live';
+    const client = live
+        ? createClient({ timeout: 20_000, retry: { maxRetries: 0 } })
+        : createFixtureClient(fixture.responses);
+    const result = await answerSupportRequest(fixture.input, async () => fixture.draft, { client });
+    process.stdout.write(`${JSON.stringify({
+        mode: live ? 'live' : 'demo',
+        note: live
+            ? 'Live Jev decisions with a saved draft answer. No generative model was called.'
+            : 'Hand-authored decision fixtures and a saved draft. No model was called; this does not measure accuracy.',
+        result,
+    }, null, 2)}\n`);
+}
+function createFixtureClient(responses) {
+    return {
+        systemOne: async (request) => {
+            const key = Object.keys(request.questions).join(',');
+            const response = responses[key];
+            if (response === undefined)
+                throw new Error(`No offline response for questions: ${key}`);
+            return response;
+        },
+    };
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});