jev-recipes 0.0.1 → 0.0.4

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

@@ -0,0 +1,566 @@
+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<{
+                present: "present";
+                missing: "missing";
+                ambiguous: "ambiguous";
+            }>;
+            confidence: z.ZodNumber;
+            probabilities: z.ZodRecord<z.ZodEnum<{
+                present: "present";
+                missing: "missing";
+                ambiguous: "ambiguous";
+            }>, 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<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>;
+                confidence: z.ZodNumber;
+                probabilities: z.ZodRecord<z.ZodEnum<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>, 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";
+        rerank: "rerank";
+        verify: "verify";
+        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<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>;
+                confidence: z.ZodNumber;
+                probabilities: z.ZodRecord<z.ZodEnum<{
+                    present: "present";
+                    missing: "missing";
+                    ambiguous: "ambiguous";
+                }>, 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

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

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

@@ -0,0 +1,3 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { SupportInput, SupportDraftContext, SupportDraft, SupportResult } from './schema.js';
+export declare function answerSupportRequest(input: SupportInput, draftAnswer: (context: SupportDraftContext) => Promise<SupportDraft>, options?: RecipeOptions): Promise<SupportResult>;