jev-recipes 0.2.0 → 0.4.0

package/dist/catalog/recipes.js

@@ -1,14 +0,0 @@
-import { answersRecipes } from './groups/answers.js';
-import { retrievalRecipes } from './groups/retrieval.js';
-import { conversationRecipes } from './groups/conversation.js';
-import { workflowRecipes } from './groups/workflow.js';
-import { supportRecipes } from './groups/support.js';
-import { knowledgeRecipes } from './groups/knowledge.js';
-export const recipes = {
-    ...answersRecipes,
-    ...retrievalRecipes,
-    ...conversationRecipes,
-    ...workflowRecipes,
-    ...supportRecipes,
-    ...knowledgeRecipes,
-};

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

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

package/dist/examples/support/index.js

@@ -1,37 +0,0 @@
-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;
-});

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

@@ -1,566 +0,0 @@
-import { z } from 'zod';
-export declare const supportInputSchema: z.ZodObject<{
-    request: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-    routes: z.ZodRecord<z.ZodString, z.ZodString>;
-    requirements: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-    }, z.core.$strip>>;
-    handoffRules: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        description: z.ZodString;
-    }, z.core.$strip>>;
-    evidence: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        text: z.ZodString;
-    }, z.core.$strip>>;
-    minConfidence: z.ZodOptional<z.ZodNumber>;
-    minRelevance: z.ZodOptional<z.ZodNumber>;
-    topK: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const supportDraftContextSchema: z.ZodObject<{
-    request: z.ZodString;
-    context: z.ZodOptional<z.ZodString>;
-    route: z.ZodString;
-    evidence: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        text: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const supportDraftSchema: z.ZodObject<{
-    claims: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        claim: z.ZodString;
-        evidenceIds: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const supportDecisionsSchema: z.ZodObject<{
-    handoff: z.ZodOptional<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";
-        }>;
-        decision: z.ZodEnum<{
-            review: "review";
-            human: "human";
-            continue: "continue";
-        }>;
-        matchedRules: z.ZodArray<z.ZodString>;
-        uncertainRules: z.ZodArray<z.ZodString>;
-        checks: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            status: z.ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: z.ZodEnum<{
-                matches: "matches";
-                does_not_match: "does_not_match";
-                unclear: "unclear";
-            }>;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodEnum<{
-                matches: "matches";
-                does_not_match: "does_not_match";
-                unclear: "unclear";
-            }>, z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    clarify: z.ZodOptional<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";
-        }>;
-        canProceed: z.ZodBoolean;
-        missing: z.ZodArray<z.ZodString>;
-        ambiguous: z.ZodArray<z.ZodString>;
-        checks: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            status: z.ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: z.ZodEnum<{
-                ambiguous: "ambiguous";
-                present: "present";
-                missing: "missing";
-            }>;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodEnum<{
-                ambiguous: "ambiguous";
-                present: "present";
-                missing: "missing";
-            }>, z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    route: z.ZodOptional<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";
-        }>;
-        route: z.ZodNullable<z.ZodString>;
-        suggestedRoute: z.ZodNullable<z.ZodString>;
-        confidence: z.ZodNumber;
-        probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
-    }, z.core.$strip>>;
-    rerank: z.ZodOptional<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;
-            text: z.ZodString;
-            relevance: z.ZodNumber;
-        }, z.core.$strip>>;
-        evaluated: z.ZodNumber;
-    }, z.core.$strip>>;
-    answerability: z.ZodOptional<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<{
-            sufficient: "sufficient";
-            partial: "partial";
-            insufficient: "insufficient";
-            conflicting: "conflicting";
-        }>;
-        canAnswer: z.ZodBoolean;
-        confidence: z.ZodNumber;
-        probabilities: z.ZodRecord<z.ZodEnum<{
-            sufficient: "sufficient";
-            partial: "partial";
-            insufficient: "insufficient";
-            conflicting: "conflicting";
-        }>, z.ZodNumber>;
-    }, z.core.$strip>>;
-    verify: z.ZodOptional<z.ZodObject<{
-        model: z.ZodString;
-        usage: z.ZodObject<{
-            input_tokens: z.ZodNumber;
-            output_tokens: z.ZodNumber;
-        }, z.core.$strip>;
-        checks: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            status: z.ZodEnum<{
-                ready: "ready";
-                review: "review";
-            }>;
-            verdict: z.ZodEnum<{
-                supported: "supported";
-                contradicted: "contradicted";
-                unsupported: "unsupported";
-            }>;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodEnum<{
-                supported: "supported";
-                contradicted: "contradicted";
-                unsupported: "unsupported";
-            }>, z.ZodNumber>;
-        }, z.core.$strip>>;
-        allSupported: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const supportResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    outcome: z.ZodLiteral<"answered">;
-    answer: z.ZodString;
-    draft: z.ZodObject<{
-        claims: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            claim: z.ZodString;
-            evidenceIds: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    decisions: z.ZodObject<{
-        handoff: z.ZodOptional<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";
-            }>;
-            decision: z.ZodEnum<{
-                review: "review";
-                human: "human";
-                continue: "continue";
-            }>;
-            matchedRules: z.ZodArray<z.ZodString>;
-            uncertainRules: z.ZodArray<z.ZodString>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        clarify: z.ZodOptional<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";
-            }>;
-            canProceed: z.ZodBoolean;
-            missing: z.ZodArray<z.ZodString>;
-            ambiguous: z.ZodArray<z.ZodString>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        route: z.ZodOptional<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";
-            }>;
-            route: z.ZodNullable<z.ZodString>;
-            suggestedRoute: z.ZodNullable<z.ZodString>;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
-        }, z.core.$strip>>;
-        rerank: z.ZodOptional<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;
-                text: z.ZodString;
-                relevance: z.ZodNumber;
-            }, z.core.$strip>>;
-            evaluated: z.ZodNumber;
-        }, z.core.$strip>>;
-        answerability: z.ZodOptional<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<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>;
-            canAnswer: z.ZodBoolean;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>, z.ZodNumber>;
-        }, z.core.$strip>>;
-        verify: z.ZodOptional<z.ZodObject<{
-            model: z.ZodString;
-            usage: z.ZodObject<{
-                input_tokens: z.ZodNumber;
-                output_tokens: z.ZodNumber;
-            }, z.core.$strip>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-            allSupported: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    outcome: z.ZodEnum<{
-        review: "review";
-        human: "human";
-        clarification: "clarification";
-        no_evidence: "no_evidence";
-        cannot_answer: "cannot_answer";
-        unverified: "unverified";
-    }>;
-    stage: z.ZodEnum<{
-        route: "route";
-        answerability: "answerability";
-        verify: "verify";
-        rerank: "rerank";
-        clarify: "clarify";
-        handoff: "handoff";
-    }>;
-    decisions: z.ZodObject<{
-        handoff: z.ZodOptional<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";
-            }>;
-            decision: z.ZodEnum<{
-                review: "review";
-                human: "human";
-                continue: "continue";
-            }>;
-            matchedRules: z.ZodArray<z.ZodString>;
-            uncertainRules: z.ZodArray<z.ZodString>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    matches: "matches";
-                    does_not_match: "does_not_match";
-                    unclear: "unclear";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        clarify: z.ZodOptional<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";
-            }>;
-            canProceed: z.ZodBoolean;
-            missing: z.ZodArray<z.ZodString>;
-            ambiguous: z.ZodArray<z.ZodString>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    ambiguous: "ambiguous";
-                    present: "present";
-                    missing: "missing";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        route: z.ZodOptional<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";
-            }>;
-            route: z.ZodNullable<z.ZodString>;
-            suggestedRoute: z.ZodNullable<z.ZodString>;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
-        }, z.core.$strip>>;
-        rerank: z.ZodOptional<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;
-                text: z.ZodString;
-                relevance: z.ZodNumber;
-            }, z.core.$strip>>;
-            evaluated: z.ZodNumber;
-        }, z.core.$strip>>;
-        answerability: z.ZodOptional<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<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>;
-            canAnswer: z.ZodBoolean;
-            confidence: z.ZodNumber;
-            probabilities: z.ZodRecord<z.ZodEnum<{
-                sufficient: "sufficient";
-                partial: "partial";
-                insufficient: "insufficient";
-                conflicting: "conflicting";
-            }>, z.ZodNumber>;
-        }, z.core.$strip>>;
-        verify: z.ZodOptional<z.ZodObject<{
-            model: z.ZodString;
-            usage: z.ZodObject<{
-                input_tokens: z.ZodNumber;
-                output_tokens: z.ZodNumber;
-            }, z.core.$strip>;
-            checks: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                status: z.ZodEnum<{
-                    ready: "ready";
-                    review: "review";
-                }>;
-                verdict: z.ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>;
-                confidence: z.ZodNumber;
-                probabilities: z.ZodRecord<z.ZodEnum<{
-                    supported: "supported";
-                    contradicted: "contradicted";
-                    unsupported: "unsupported";
-                }>, z.ZodNumber>;
-            }, z.core.$strip>>;
-            allSupported: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>], "outcome">;
-export declare const supportFixtureSchema: z.ZodObject<{
-    input: z.ZodObject<{
-        request: z.ZodString;
-        context: z.ZodOptional<z.ZodString>;
-        routes: z.ZodRecord<z.ZodString, z.ZodString>;
-        requirements: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            description: z.ZodString;
-        }, z.core.$strip>>;
-        handoffRules: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            description: z.ZodString;
-        }, z.core.$strip>>;
-        evidence: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-        }, z.core.$strip>>;
-        minConfidence: z.ZodOptional<z.ZodNumber>;
-        minRelevance: z.ZodOptional<z.ZodNumber>;
-        topK: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
-    draft: z.ZodObject<{
-        claims: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            claim: z.ZodString;
-            evidenceIds: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    responses: z.ZodRecord<z.ZodString, z.ZodObject<{
-        model: z.ZodString;
-        usage: z.ZodObject<{
-            input_tokens: z.ZodNumber;
-            output_tokens: z.ZodNumber;
-        }, z.core.$strip>;
-        answers: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type SupportInput = z.infer<typeof supportInputSchema>;
-export type SupportDraftContext = z.infer<typeof supportDraftContextSchema>;
-export type SupportDraft = z.infer<typeof supportDraftSchema>;
-export type SupportDecisions = z.infer<typeof supportDecisionsSchema>;
-export type SupportResult = z.infer<typeof supportResultSchema>;

package/dist/examples/support/schema.js

@@ -1,76 +0,0 @@
-import { z } from 'zod';
-import { nonEmptyText, probability, decisionResponseSchema } from '../../src/schema.js';
-import { routeInputSchema, routeResultSchema } from '../../recipes/route/schema.js';
-import { rerankResultSchema } from '../../recipes/rerank/schema.js';
-import { verifyResultSchema } from '../../recipes/verify/schema.js';
-import { answerabilityEvidenceSchema, answerabilityResultSchema, } from '../../recipes/answerability/schema.js';
-import { clarifyInputSchema, clarifyResultSchema } from '../../recipes/clarify/schema.js';
-import { handoffInputSchema, handoffResultSchema } from '../../recipes/handoff/schema.js';
-export const supportInputSchema = z.object({
-    request: nonEmptyText,
-    context: nonEmptyText.optional(),
-    routes: routeInputSchema.shape.routes,
-    requirements: clarifyInputSchema.shape.requirements,
-    handoffRules: handoffInputSchema.shape.rules,
-    evidence: z
-        .array(answerabilityEvidenceSchema)
-        .max(100)
-        .refine((items) => new Set(items.map((item) => item.id)).size === items.length, 'Evidence IDs must be unique.'),
-    minConfidence: probability.optional(),
-    minRelevance: probability.optional(),
-    topK: z.number().int().min(1).max(50).optional(),
-});
-export const supportDraftContextSchema = z.object({
-    request: nonEmptyText,
-    context: nonEmptyText.optional(),
-    route: nonEmptyText,
-    evidence: z.array(answerabilityEvidenceSchema).min(1).max(50),
-});
-export const supportDraftSchema = z.object({
-    claims: z
-        .array(z.object({
-        id: nonEmptyText,
-        claim: nonEmptyText,
-        evidenceIds: z
-            .array(nonEmptyText)
-            .min(1)
-            .max(50)
-            .refine((ids) => new Set(ids).size === ids.length, 'Evidence references must be unique.'),
-    }))
-        .min(1)
-        .max(100)
-        .refine((claims) => new Set(claims.map((claim) => claim.id)).size === claims.length, 'Claim IDs must be unique.'),
-});
-export const supportDecisionsSchema = z.object({
-    handoff: handoffResultSchema.optional(),
-    clarify: clarifyResultSchema.optional(),
-    route: routeResultSchema.optional(),
-    rerank: rerankResultSchema.optional(),
-    answerability: answerabilityResultSchema.optional(),
-    verify: verifyResultSchema.optional(),
-});
-export const supportResultSchema = z.discriminatedUnion('outcome', [
-    z.object({
-        outcome: z.literal('answered'),
-        answer: nonEmptyText,
-        draft: supportDraftSchema,
-        decisions: supportDecisionsSchema,
-    }),
-    z.object({
-        outcome: z.enum([
-            'human',
-            'review',
-            'clarification',
-            'no_evidence',
-            'cannot_answer',
-            'unverified',
-        ]),
-        stage: z.enum(['handoff', 'clarify', 'route', 'rerank', 'answerability', 'verify']),
-        decisions: supportDecisionsSchema,
-    }),
-]);
-export const supportFixtureSchema = z.object({
-    input: supportInputSchema,
-    draft: supportDraftSchema,
-    responses: z.record(nonEmptyText, decisionResponseSchema),
-});