jev-recipes 0.0.4 → 0.2.0

package/dist/recipes/draft-compare/schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const draftCompareVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+}>;
+export declare const draftCompareInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    firstDraft: z.ZodString;
+    secondDraft: z.ZodString;
+    rubric: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const draftCompareResultSchema: 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<{
+        unclear: "unclear";
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type DraftCompareInput = z.infer<typeof draftCompareInputSchema>;
+export type DraftCompareResult = z.infer<typeof draftCompareResultSchema>;
+export type DraftCompareVerdict = z.infer<typeof draftCompareVerdictSchema>;

package/dist/recipes/draft-compare/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const draftCompareVerdictSchema = z.enum(['first', 'second', 'tie', 'neither', 'unclear']);
+export const draftCompareInputSchema = z.object({
+    request: nonEmptyText,
+    firstDraft: nonEmptyText,
+    secondDraft: nonEmptyText,
+    rubric: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const draftCompareResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: draftCompareVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(draftCompareVerdictSchema, probability),
+});

package/dist/recipes/evidence-conflict/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { EvidenceConflictInput, EvidenceConflictResult } from './schema.js';
+export declare function evidenceConflict(input: EvidenceConflictInput, options?: RecipeOptions): Promise<EvidenceConflictResult>;
+export { evidenceConflictInputSchema, evidenceConflictResultSchema, evidenceConflictVerdictSchema, } from './schema.js';
+export type { EvidenceConflictInput, EvidenceConflictResult, EvidenceConflictVerdict, } from './schema.js';

package/dist/recipes/evidence-conflict/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { evidenceConflictInputSchema, evidenceConflictResultSchema } from './schema.js';
+export async function evidenceConflict(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = evidenceConflictInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do firstPassage and secondPassage give incompatible evidence relevant to question under the same conditions? Different scopes are not automatically contradictions.', {
+        compatible: 'The passages address the same scope and can both be true.',
+        conflicting: 'The passages address the same scope and make incompatible claims.',
+        different_scope: 'The apparent comparison concerns different subjects, circumstances, or conditions.',
+        unclear: 'The scope or meaning cannot be resolved from the supplied evidence.',
+    }, options);
+    return evidenceConflictResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { evidenceConflictInputSchema, evidenceConflictResultSchema, evidenceConflictVerdictSchema, } from './schema.js';

package/dist/recipes/evidence-conflict/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "retrieval";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/evidence-conflict/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'evidence-conflict',
+    title: 'Compare evidence for conflicts',
+    description: 'Do firstPassage and secondPassage give incompatible evidence relevant to question under the same conditions?',
+    category: 'retrieval',
+    tags: ['retrieval', 'evidence', 'conflict', 'rag'],
+    limitations: [
+        'Does not decide which source is authoritative. Exact numbers, timestamps, and version ordering should be compared in code.',
+    ],
+};

package/dist/recipes/evidence-conflict/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const evidenceConflictVerdictSchema: z.ZodEnum<{
+    conflicting: "conflicting";
+    unclear: "unclear";
+    compatible: "compatible";
+    different_scope: "different_scope";
+}>;
+export declare const evidenceConflictInputSchema: z.ZodObject<{
+    firstPassage: z.ZodString;
+    secondPassage: z.ZodString;
+    question: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const evidenceConflictResultSchema: 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<{
+        conflicting: "conflicting";
+        unclear: "unclear";
+        compatible: "compatible";
+        different_scope: "different_scope";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        conflicting: "conflicting";
+        unclear: "unclear";
+        compatible: "compatible";
+        different_scope: "different_scope";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type EvidenceConflictInput = z.infer<typeof evidenceConflictInputSchema>;
+export type EvidenceConflictResult = z.infer<typeof evidenceConflictResultSchema>;
+export type EvidenceConflictVerdict = z.infer<typeof evidenceConflictVerdictSchema>;

package/dist/recipes/evidence-conflict/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const evidenceConflictVerdictSchema = z.enum([
+    'compatible',
+    'conflicting',
+    'different_scope',
+    'unclear',
+]);
+export const evidenceConflictInputSchema = z.object({
+    firstPassage: nonEmptyText,
+    secondPassage: nonEmptyText,
+    question: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const evidenceConflictResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: evidenceConflictVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(evidenceConflictVerdictSchema, probability),
+});

package/dist/recipes/evidence-novelty/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { EvidenceNoveltyInput, EvidenceNoveltyResult } from './schema.js';
+export declare function evidenceNovelty(input: EvidenceNoveltyInput, options?: RecipeOptions): Promise<EvidenceNoveltyResult>;
+export { evidenceNoveltyInputSchema, evidenceNoveltyResultSchema, evidenceNoveltyVerdictSchema, } from './schema.js';
+export type { EvidenceNoveltyInput, EvidenceNoveltyResult, EvidenceNoveltyVerdict, } from './schema.js';

package/dist/recipes/evidence-novelty/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { evidenceNoveltyInputSchema, evidenceNoveltyResultSchema } from './schema.js';
+export async function evidenceNovelty(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = evidenceNoveltyInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does passage add material information relevant to question beyond existingEvidence? New information may conflict with existing evidence; novelty alone is not correctness.', {
+        adds_information: 'The passage adds a material relevant fact or distinction not already represented.',
+        repeats_information: 'It only repeats information already represented.',
+        irrelevant: 'It contributes no information relevant to the question.',
+        unclear: 'Its contribution cannot be determined from the supplied material.',
+    }, options);
+    return evidenceNoveltyResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { evidenceNoveltyInputSchema, evidenceNoveltyResultSchema, evidenceNoveltyVerdictSchema, } from './schema.js';

package/dist/recipes/evidence-novelty/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "retrieval";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/evidence-novelty/metadata.js

@@ -0,0 +1,11 @@
+export const metadata = {
+    id: 'evidence-novelty',
+    title: 'Check new evidence',
+    description: 'Does passage add material information relevant to question beyond existingEvidence?',
+    category: 'retrieval',
+    tags: ['retrieval', 'evidence', 'novelty', 'rag'],
+    limitations: [
+        'Assesses novelty within the supplied set. It does not establish correctness or decide when retrieval must stop.',
+        'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+    ],
+};

package/dist/recipes/evidence-novelty/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const evidenceNoveltyVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    adds_information: "adds_information";
+    repeats_information: "repeats_information";
+    irrelevant: "irrelevant";
+}>;
+export declare const evidenceNoveltyInputSchema: z.ZodObject<{
+    passage: z.ZodString;
+    existingEvidence: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    question: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const evidenceNoveltyResultSchema: 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<{
+        unclear: "unclear";
+        adds_information: "adds_information";
+        repeats_information: "repeats_information";
+        irrelevant: "irrelevant";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        adds_information: "adds_information";
+        repeats_information: "repeats_information";
+        irrelevant: "irrelevant";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type EvidenceNoveltyInput = z.infer<typeof evidenceNoveltyInputSchema>;
+export type EvidenceNoveltyResult = z.infer<typeof evidenceNoveltyResultSchema>;
+export type EvidenceNoveltyVerdict = z.infer<typeof evidenceNoveltyVerdictSchema>;

package/dist/recipes/evidence-novelty/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, textItemsSchema, } from '../../src/schema.js';
+export const evidenceNoveltyVerdictSchema = z.enum([
+    'adds_information',
+    'repeats_information',
+    'irrelevant',
+    'unclear',
+]);
+export const evidenceNoveltyInputSchema = z.object({
+    passage: nonEmptyText,
+    existingEvidence: textItemsSchema,
+    question: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const evidenceNoveltyResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: evidenceNoveltyVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(evidenceNoveltyVerdictSchema, probability),
+});

package/dist/recipes/fact-stability/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { FactStabilityInput, FactStabilityResult } from './schema.js';
+export declare function factStability(input: FactStabilityInput, options?: RecipeOptions): Promise<FactStabilityResult>;
+export { factStabilityInputSchema, factStabilityResultSchema, factStabilityVerdictSchema, } from './schema.js';
+export type { FactStabilityInput, FactStabilityResult, FactStabilityVerdict } from './schema.js';

package/dist/recipes/fact-stability/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { factStabilityInputSchema, factStabilityResultSchema } from './schema.js';
+export async function factStability(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = factStabilityInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Is fact about an enduring or historical attribute, or a state that is expected to change? Classify the kind of information, not whether this particular fact is currently true.', {
+        stable: 'The fact describes a historical event, definition, or enduring attribute unlikely to change in the relevant context.',
+        changeable: 'The fact describes a current state, preference, configuration, or other information that can change.',
+        unclear: 'The kind or relevant timescale is not established.',
+    }, options);
+    return factStabilityResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { factStabilityInputSchema, factStabilityResultSchema, factStabilityVerdictSchema, } from './schema.js';

package/dist/recipes/fact-stability/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "memory";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/fact-stability/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'fact-stability',
+    title: 'Assess fact stability',
+    description: 'Is fact about an enduring or historical attribute, or a state that is expected to change?',
+    category: 'memory',
+    tags: ['memory', 'fact', 'stability'],
+    limitations: [
+        'Does not establish truth, expiration times, or freshness. Refresh policies and timestamp comparisons belong in code.',
+    ],
+};

package/dist/recipes/fact-stability/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const factStabilityVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    stable: "stable";
+    changeable: "changeable";
+}>;
+export declare const factStabilityInputSchema: z.ZodObject<{
+    fact: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const factStabilityResultSchema: 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<{
+        unclear: "unclear";
+        stable: "stable";
+        changeable: "changeable";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        stable: "stable";
+        changeable: "changeable";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type FactStabilityInput = z.infer<typeof factStabilityInputSchema>;
+export type FactStabilityResult = z.infer<typeof factStabilityResultSchema>;
+export type FactStabilityVerdict = z.infer<typeof factStabilityVerdictSchema>;

package/dist/recipes/fact-stability/schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const factStabilityVerdictSchema = z.enum(['stable', 'changeable', 'unclear']);
+export const factStabilityInputSchema = z.object({
+    fact: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const factStabilityResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: factStabilityVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(factStabilityVerdictSchema, probability),
+});

package/dist/recipes/failure-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { FailureKindInput, FailureKindResult } from './schema.js';
+export declare function failureKind(input: FailureKindInput, options?: RecipeOptions): Promise<FailureKindResult>;
+export { failureKindInputSchema, failureKindResultSchema } from './schema.js';
+export type { FailureKindInput, FailureKindResult } from './schema.js';

package/dist/recipes/failure-kind/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { failureKindInputSchema } from './schema.js';
+export async function failureKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = failureKindInputSchema.parse(input);
+    return selectCandidate(state, state.categories, 'Which supplied category best describes the observed failure? Classify the described failure rather than inventing an underlying cause.', minConfidence, options);
+}
+export { failureKindInputSchema, failureKindResultSchema } from './schema.js';

package/dist/recipes/failure-kind/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "workflow";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/failure-kind/metadata.js

@@ -0,0 +1,11 @@
+export const metadata = {
+    id: 'failure-kind',
+    title: 'Classify a described failure',
+    description: 'Which supplied category best describes the observed failure?',
+    category: 'workflow',
+    tags: ['workflow', 'failure', 'kind'],
+    limitations: [
+        'Maps text to your categories. Use structured error codes first; this recipe does not diagnose a root cause or initiate retries.',
+        'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+    ],
+};

package/dist/recipes/failure-kind/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const failureKindInputSchema: z.ZodObject<{
+    failure: z.ZodString;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const failureKindResultSchema: 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<{
+        matched: "matched";
+        none: "none";
+        ambiguous: "ambiguous";
+    }>;
+    selection: z.ZodNullable<z.ZodString>;
+    suggestedSelection: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodObject<{
+        candidates: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        none: z.ZodNumber;
+        ambiguous: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FailureKindInput = z.infer<typeof failureKindInputSchema>;
+export type FailureKindResult = z.infer<typeof failureKindResultSchema>;

package/dist/recipes/failure-kind/schema.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const failureKindInputSchema = z.object({
+    failure: nonEmptyText,
+    categories: textItemsSchema,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const failureKindResultSchema = selectionResultSchema;

package/dist/recipes/feedback-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { FeedbackKindInput, FeedbackKindResult } from './schema.js';
+export declare function feedbackKind(input: FeedbackKindInput, options?: RecipeOptions): Promise<FeedbackKindResult>;
+export { feedbackKindInputSchema, feedbackKindResultSchema, feedbackKindVerdictSchema, } from './schema.js';
+export type { FeedbackKindInput, FeedbackKindResult, FeedbackKindVerdict } from './schema.js';

package/dist/recipes/feedback-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { feedbackKindInputSchema, feedbackKindResultSchema } from './schema.js';
+export async function feedbackKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = feedbackKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What is the primary kind of feedback in message? Prefer the explicit requested outcome over incidental tone. Choose unclear when several kinds are equally central.', {
+        bug_report: 'Reports existing functionality behaving incorrectly.',
+        feature_request: 'Requests a new capability or changed behavior.',
+        question: 'Asks for information or instructions.',
+        praise: 'Primarily expresses positive feedback without another requested outcome.',
+        complaint: 'Primarily expresses dissatisfaction without a specific bug report, feature request, or question.',
+        other: 'The feedback has a clear purpose outside these categories.',
+        unclear: 'The primary kind cannot be established.',
+    }, options);
+    return feedbackKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { feedbackKindInputSchema, feedbackKindResultSchema, feedbackKindVerdictSchema, } from './schema.js';

package/dist/recipes/feedback-kind/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "support";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/feedback-kind/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'feedback-kind',
+    title: 'Classify customer feedback',
+    description: 'What is the primary kind of feedback in message?',
+    category: 'support',
+    tags: ['support', 'feedback', 'kind'],
+    limitations: [
+        'Returns one primary category. It does not create a ticket, extract multiple issues, or set a priority.',
+    ],
+};

package/dist/recipes/feedback-kind/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const feedbackKindVerdictSchema: z.ZodEnum<{
+    question: "question";
+    unclear: "unclear";
+    other: "other";
+    bug_report: "bug_report";
+    feature_request: "feature_request";
+    praise: "praise";
+    complaint: "complaint";
+}>;
+export declare const feedbackKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const feedbackKindResultSchema: 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<{
+        question: "question";
+        unclear: "unclear";
+        other: "other";
+        bug_report: "bug_report";
+        feature_request: "feature_request";
+        praise: "praise";
+        complaint: "complaint";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        question: "question";
+        unclear: "unclear";
+        other: "other";
+        bug_report: "bug_report";
+        feature_request: "feature_request";
+        praise: "praise";
+        complaint: "complaint";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type FeedbackKindInput = z.infer<typeof feedbackKindInputSchema>;
+export type FeedbackKindResult = z.infer<typeof feedbackKindResultSchema>;
+export type FeedbackKindVerdict = z.infer<typeof feedbackKindVerdictSchema>;

package/dist/recipes/feedback-kind/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const feedbackKindVerdictSchema = z.enum([
+    'bug_report',
+    'feature_request',
+    'question',
+    'praise',
+    'complaint',
+    'other',
+    'unclear',
+]);
+export const feedbackKindInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const feedbackKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: feedbackKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(feedbackKindVerdictSchema, probability),
+});

package/dist/recipes/field-select/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { FieldSelectInput, FieldSelectResult } from './schema.js';
+export declare function fieldSelect(input: FieldSelectInput, options?: RecipeOptions): Promise<FieldSelectResult>;
+export { fieldSelectInputSchema, fieldSelectResultSchema } from './schema.js';
+export type { FieldSelectInput, FieldSelectResult } from './schema.js';

package/dist/recipes/field-select/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { fieldSelectInputSchema } from './schema.js';
+export async function fieldSelect(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = fieldSelectInputSchema.parse(input);
+    return selectCandidate(state, state.candidates, 'Which supplied candidate is the value of field in document? Select an existing candidate only. Do not calculate a value, invent one, or infer an unstated field.', minConfidence, options);
+}
+export { fieldSelectInputSchema, fieldSelectResultSchema } from './schema.js';

package/dist/recipes/field-select/metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const metadata: {
+    id: string;
+    title: string;
+    description: string;
+    category: "knowledge";
+    tags: string[];
+    limitations: string[];
+};

package/dist/recipes/field-select/metadata.js

@@ -0,0 +1,11 @@
+export const metadata = {
+    id: 'field-select',
+    title: 'Select a field value',
+    description: 'Which supplied candidate is the value of field in document?',
+    category: 'knowledge',
+    tags: ['knowledge', 'field', 'select'],
+    limitations: [
+        'Chooses among caller-supplied candidates. Extract candidates with a parser or generator first; validate exact formats and identifiers in code.',
+        'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+    ],
+};