jev-recipes 0.2.0 → 0.4.0

package/dist/catalog/groups/conversation.js

@@ -1,90 +0,0 @@
-import { clarify, clarifyInputSchema, clarifyResultSchema } from '../../recipes/clarify/index.js';
-import { metadata as clarifyMetadata } from '../../recipes/clarify/metadata.js';
-import { turnIntent, turnIntentInputSchema, turnIntentResultSchema, } from '../../recipes/turn-intent/index.js';
-import { metadata as turnIntentMetadata } from '../../recipes/turn-intent/metadata.js';
-import { followupLink, followupLinkInputSchema, followupLinkResultSchema, } from '../../recipes/followup-link/index.js';
-import { metadata as followupLinkMetadata } from '../../recipes/followup-link/metadata.js';
-import { referenceResolve, referenceResolveInputSchema, referenceResolveResultSchema, } from '../../recipes/reference-resolve/index.js';
-import { metadata as referenceResolveMetadata } from '../../recipes/reference-resolve/metadata.js';
-import { intentChange, intentChangeInputSchema, intentChangeResultSchema, } from '../../recipes/intent-change/index.js';
-import { metadata as intentChangeMetadata } from '../../recipes/intent-change/metadata.js';
-import { correctionTarget, correctionTargetInputSchema, correctionTargetResultSchema, } from '../../recipes/correction-target/index.js';
-import { metadata as correctionTargetMetadata } from '../../recipes/correction-target/metadata.js';
-import { confirmationMatch, confirmationMatchInputSchema, confirmationMatchResultSchema, } from '../../recipes/confirmation-match/index.js';
-import { metadata as confirmationMatchMetadata } from '../../recipes/confirmation-match/metadata.js';
-import { cancellationCheck, cancellationCheckInputSchema, cancellationCheckResultSchema, } from '../../recipes/cancellation-check/index.js';
-import { metadata as cancellationCheckMetadata } from '../../recipes/cancellation-check/metadata.js';
-import { topicShift, topicShiftInputSchema, topicShiftResultSchema, } from '../../recipes/topic-shift/index.js';
-import { metadata as topicShiftMetadata } from '../../recipes/topic-shift/metadata.js';
-import { responseNeeded, responseNeededInputSchema, responseNeededResultSchema, } from '../../recipes/response-needed/index.js';
-import { metadata as responseNeededMetadata } from '../../recipes/response-needed/metadata.js';
-import { resolutionCheck, resolutionCheckInputSchema, resolutionCheckResultSchema, } from '../../recipes/resolution-check/index.js';
-import { metadata as resolutionCheckMetadata } from '../../recipes/resolution-check/metadata.js';
-export const conversationRecipes = {
-    clarify: {
-        metadata: clarifyMetadata,
-        inputSchema: clarifyInputSchema,
-        resultSchema: clarifyResultSchema,
-        run: (input, options) => clarify(clarifyInputSchema.parse(input), options),
-    },
-    'turn-intent': {
-        metadata: turnIntentMetadata,
-        inputSchema: turnIntentInputSchema,
-        resultSchema: turnIntentResultSchema,
-        run: (input, options) => turnIntent(turnIntentInputSchema.parse(input), options),
-    },
-    'followup-link': {
-        metadata: followupLinkMetadata,
-        inputSchema: followupLinkInputSchema,
-        resultSchema: followupLinkResultSchema,
-        run: (input, options) => followupLink(followupLinkInputSchema.parse(input), options),
-    },
-    'reference-resolve': {
-        metadata: referenceResolveMetadata,
-        inputSchema: referenceResolveInputSchema,
-        resultSchema: referenceResolveResultSchema,
-        run: (input, options) => referenceResolve(referenceResolveInputSchema.parse(input), options),
-    },
-    'intent-change': {
-        metadata: intentChangeMetadata,
-        inputSchema: intentChangeInputSchema,
-        resultSchema: intentChangeResultSchema,
-        run: (input, options) => intentChange(intentChangeInputSchema.parse(input), options),
-    },
-    'correction-target': {
-        metadata: correctionTargetMetadata,
-        inputSchema: correctionTargetInputSchema,
-        resultSchema: correctionTargetResultSchema,
-        run: (input, options) => correctionTarget(correctionTargetInputSchema.parse(input), options),
-    },
-    'confirmation-match': {
-        metadata: confirmationMatchMetadata,
-        inputSchema: confirmationMatchInputSchema,
-        resultSchema: confirmationMatchResultSchema,
-        run: (input, options) => confirmationMatch(confirmationMatchInputSchema.parse(input), options),
-    },
-    'cancellation-check': {
-        metadata: cancellationCheckMetadata,
-        inputSchema: cancellationCheckInputSchema,
-        resultSchema: cancellationCheckResultSchema,
-        run: (input, options) => cancellationCheck(cancellationCheckInputSchema.parse(input), options),
-    },
-    'topic-shift': {
-        metadata: topicShiftMetadata,
-        inputSchema: topicShiftInputSchema,
-        resultSchema: topicShiftResultSchema,
-        run: (input, options) => topicShift(topicShiftInputSchema.parse(input), options),
-    },
-    'response-needed': {
-        metadata: responseNeededMetadata,
-        inputSchema: responseNeededInputSchema,
-        resultSchema: responseNeededResultSchema,
-        run: (input, options) => responseNeeded(responseNeededInputSchema.parse(input), options),
-    },
-    'resolution-check': {
-        metadata: resolutionCheckMetadata,
-        inputSchema: resolutionCheckInputSchema,
-        resultSchema: resolutionCheckResultSchema,
-        run: (input, options) => resolutionCheck(resolutionCheckInputSchema.parse(input), options),
-    },
-};

package/dist/catalog/groups/knowledge.d.ts

@@ -1,522 +0,0 @@
-import type { RecipeOptions } from '../../src/schema.js';
-export declare const knowledgeRecipes: {
-    'memory-value': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            purpose: import("zod").ZodString;
-            context: import("zod").ZodOptional<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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                ongoing_value: "ongoing_value";
-                task_only: "task_only";
-                incidental: "incidental";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                ongoing_value: "ongoing_value";
-                task_only: "task_only";
-                incidental: "incidental";
-            }>, 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: "unclear" | "ongoing_value" | "task_only" | "incidental";
-            confidence: number;
-            probabilities: Record<"unclear" | "ongoing_value" | "task_only" | "incidental", number>;
-        }>;
-    };
-    'memory-scope': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            context: 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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                task: "task";
-                user: "user";
-                project: "project";
-                session: "session";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                task: "task";
-                user: "user";
-                project: "project";
-                session: "session";
-            }>, 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: "unclear" | "task" | "user" | "project" | "session";
-            confidence: number;
-            probabilities: Record<"unclear" | "task" | "user" | "project" | "session", number>;
-        }>;
-    };
-    'memory-relation': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            existingMemory: import("zod").ZodString;
-            newFact: import("zod").ZodString;
-            context: import("zod").ZodOptional<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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                conflicts: "conflicts";
-                repeats: "repeats";
-                supplements: "supplements";
-                updates: "updates";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                unrelated: "unrelated";
-                conflicts: "conflicts";
-                repeats: "repeats";
-                supplements: "supplements";
-                updates: "updates";
-            }>, 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: "unclear" | "unrelated" | "conflicts" | "repeats" | "supplements" | "updates";
-            confidence: number;
-            probabilities: Record<"unclear" | "unrelated" | "conflicts" | "repeats" | "supplements" | "updates", number>;
-        }>;
-    };
-    'preference-kind': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            statement: import("zod").ZodString;
-            context: import("zod").ZodOptional<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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                fact: "fact";
-                preference: "preference";
-                temporary_request: "temporary_request";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                fact: "fact";
-                preference: "preference";
-                temporary_request: "temporary_request";
-            }>, 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: "unclear" | "fact" | "preference" | "temporary_request";
-            confidence: number;
-            probabilities: Record<"unclear" | "fact" | "preference" | "temporary_request", number>;
-        }>;
-    };
-    'fact-stability': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "memory";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            fact: import("zod").ZodString;
-            context: import("zod").ZodOptional<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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                stable: "stable";
-                changeable: "changeable";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                stable: "stable";
-                changeable: "changeable";
-            }>, 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: "unclear" | "stable" | "changeable";
-            confidence: number;
-            probabilities: Record<"unclear" | "stable" | "changeable", number>;
-        }>;
-    };
-    'document-role': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            document: 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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                other: "other";
-                reference: "reference";
-                troubleshooting: "troubleshooting";
-                policy: "policy";
-                tutorial: "tutorial";
-                release_note: "release_note";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                other: "other";
-                reference: "reference";
-                troubleshooting: "troubleshooting";
-                policy: "policy";
-                tutorial: "tutorial";
-                release_note: "release_note";
-            }>, 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: "unclear" | "other" | "reference" | "troubleshooting" | "policy" | "tutorial" | "release_note";
-            confidence: number;
-            probabilities: Record<"unclear" | "other" | "reference" | "troubleshooting" | "policy" | "tutorial" | "release_note", number>;
-        }>;
-    };
-    'audience-fit': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            document: import("zod").ZodString;
-            audience: 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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                appropriate: "appropriate";
-                too_technical: "too_technical";
-                too_basic: "too_basic";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                appropriate: "appropriate";
-                too_technical: "too_technical";
-                too_basic: "too_basic";
-            }>, 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: "unclear" | "appropriate" | "too_technical" | "too_basic";
-            confidence: number;
-            probabilities: Record<"unclear" | "appropriate" | "too_technical" | "too_basic", number>;
-        }>;
-    };
-    'change-meaning': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            before: import("zod").ZodString;
-            after: import("zod").ZodString;
-            context: import("zod").ZodOptional<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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                meaning_changed: "meaning_changed";
-                editorial_only: "editorial_only";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                meaning_changed: "meaning_changed";
-                editorial_only: "editorial_only";
-            }>, 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: "unclear" | "meaning_changed" | "editorial_only";
-            confidence: number;
-            probabilities: Record<"unclear" | "meaning_changed" | "editorial_only", number>;
-        }>;
-    };
-    'answer-invalidation': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            claim: import("zod").ZodString;
-            previousEvidence: import("zod").ZodString;
-            updatedEvidence: 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";
-            }>;
-            verdict: import("zod").ZodEnum<{
-                unclear: "unclear";
-                still_supported: "still_supported";
-                invalidated: "invalidated";
-            }>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodRecord<import("zod").ZodEnum<{
-                unclear: "unclear";
-                still_supported: "still_supported";
-                invalidated: "invalidated";
-            }>, 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: "unclear" | "still_supported" | "invalidated";
-            confidence: number;
-            probabilities: Record<"unclear" | "still_supported" | "invalidated", number>;
-        }>;
-    };
-    'field-select': {
-        metadata: {
-            id: string;
-            title: string;
-            description: string;
-            category: "knowledge";
-            tags: string[];
-            limitations: string[];
-        };
-        inputSchema: import("zod").ZodObject<{
-            field: import("zod").ZodString;
-            document: import("zod").ZodString;
-            candidates: 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<{
-                matched: "matched";
-                none: "none";
-                ambiguous: "ambiguous";
-            }>;
-            selection: import("zod").ZodNullable<import("zod").ZodString>;
-            suggestedSelection: import("zod").ZodNullable<import("zod").ZodString>;
-            confidence: import("zod").ZodNumber;
-            probabilities: import("zod").ZodObject<{
-                candidates: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodNumber>;
-                none: import("zod").ZodNumber;
-                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";
-            verdict: "matched" | "none" | "ambiguous";
-            selection: string | null;
-            suggestedSelection: string | null;
-            confidence: number;
-            probabilities: {
-                candidates: Record<string, number>;
-                none: number;
-                ambiguous: number;
-            };
-        }>;
-    };
-};