jev-recipes 0.0.4 → 0.2.0

package/dist/catalog/groups/conversation.js

@@ -0,0 +1,90 @@
+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

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