jev-recipes 0.0.4 → 0.2.0

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

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'preference-kind',
+    title: 'Identify a stated preference',
+    description: 'Does statement express an ongoing preference, a factual assertion, or a temporary request?',
+    category: 'memory',
+    tags: ['memory', 'preference', 'kind'],
+    limitations: [
+        'Classifies a statement. It does not infer unexpressed preferences or grant permission to store personal information.',
+    ],
+};

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const preferenceKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    fact: "fact";
+    preference: "preference";
+    temporary_request: "temporary_request";
+}>;
+export declare const preferenceKindInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const preferenceKindResultSchema: 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";
+        fact: "fact";
+        preference: "preference";
+        temporary_request: "temporary_request";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        fact: "fact";
+        preference: "preference";
+        temporary_request: "temporary_request";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PreferenceKindInput = z.infer<typeof preferenceKindInputSchema>;
+export type PreferenceKindResult = z.infer<typeof preferenceKindResultSchema>;
+export type PreferenceKindVerdict = z.infer<typeof preferenceKindVerdictSchema>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const preferenceKindVerdictSchema = z.enum([
+    'preference',
+    'fact',
+    'temporary_request',
+    'unclear',
+]);
+export const preferenceKindInputSchema = z.object({
+    statement: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const preferenceKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: preferenceKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(preferenceKindVerdictSchema, probability),
+});

package/dist/recipes/promise-check/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PromiseCheckInput, PromiseCheckResult } from './schema.js';
+export declare function promiseCheck(input: PromiseCheckInput, options?: RecipeOptions): Promise<PromiseCheckResult>;
+export { promiseCheckInputSchema, promiseCheckResultSchema, promiseCheckVerdictSchema, } from './schema.js';
+export type { PromiseCheckInput, PromiseCheckResult, PromiseCheckVerdict } from './schema.js';

package/dist/recipes/promise-check/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { promiseCheckInputSchema, promiseCheckResultSchema } from './schema.js';
+export async function promiseCheck(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = promiseCheckInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does reply promise actions or outcomes beyond allowedCommitments? A conditional possibility is not a guarantee. Judge the whole reply; one unsupported promise is enough.', {
+        within_commitments: 'Every promise is permitted by the supplied commitments, or the reply contains no promise.',
+        unsupported: 'At least one promise exceeds or contradicts the supplied commitments.',
+        unclear: 'The wording or allowed commitments leave a promise ambiguous.',
+    }, options);
+    return promiseCheckResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { promiseCheckInputSchema, promiseCheckResultSchema, promiseCheckVerdictSchema, } from './schema.js';

package/dist/recipes/promise-check/metadata.d.ts

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

package/dist/recipes/promise-check/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'promise-check',
+    title: 'Check reply commitments',
+    description: 'Does reply promise actions or outcomes beyond allowedCommitments?',
+    category: 'answer-quality',
+    tags: ['answer-quality', 'promise', 'check', 'rag', 'evidence'],
+    limitations: [
+        'Reviews expressed promises. It does not approve refunds, establish contractual obligations, or execute actions.',
+    ],
+};

package/dist/recipes/promise-check/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const promiseCheckVerdictSchema: z.ZodEnum<{
+    unsupported: "unsupported";
+    unclear: "unclear";
+    within_commitments: "within_commitments";
+}>;
+export declare const promiseCheckInputSchema: z.ZodObject<{
+    reply: z.ZodString;
+    allowedCommitments: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const promiseCheckResultSchema: 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<{
+        unsupported: "unsupported";
+        unclear: "unclear";
+        within_commitments: "within_commitments";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unsupported: "unsupported";
+        unclear: "unclear";
+        within_commitments: "within_commitments";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PromiseCheckInput = z.infer<typeof promiseCheckInputSchema>;
+export type PromiseCheckResult = z.infer<typeof promiseCheckResultSchema>;
+export type PromiseCheckVerdict = z.infer<typeof promiseCheckVerdictSchema>;

package/dist/recipes/promise-check/schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const promiseCheckVerdictSchema = z.enum(['within_commitments', 'unsupported', 'unclear']);
+export const promiseCheckInputSchema = z.object({
+    reply: nonEmptyText,
+    allowedCommitments: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const promiseCheckResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: promiseCheckVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(promiseCheckVerdictSchema, probability),
+});

package/dist/recipes/query-equivalence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QueryEquivalenceInput, QueryEquivalenceResult } from './schema.js';
+export declare function queryEquivalence(input: QueryEquivalenceInput, options?: RecipeOptions): Promise<QueryEquivalenceResult>;
+export { queryEquivalenceInputSchema, queryEquivalenceResultSchema, queryEquivalenceVerdictSchema, } from './schema.js';
+export type { QueryEquivalenceInput, QueryEquivalenceResult, QueryEquivalenceVerdict, } from './schema.js';

package/dist/recipes/query-equivalence/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { queryEquivalenceInputSchema, queryEquivalenceResultSchema } from './schema.js';
+export async function queryEquivalence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = queryEquivalenceInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do firstQuestion and secondQuestion request the same information under the same stated conditions? Shared vocabulary or topic alone is not equivalence.', {
+        equivalent: 'Both questions request the same information with compatible conditions.',
+        related: 'They share a topic but differ in a material information need or condition.',
+        different: 'They request different subjects or unrelated information.',
+        unclear: 'The intended meanings cannot be resolved.',
+    }, options);
+    return queryEquivalenceResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { queryEquivalenceInputSchema, queryEquivalenceResultSchema, queryEquivalenceVerdictSchema, } from './schema.js';

package/dist/recipes/query-equivalence/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/query-equivalence/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'query-equivalence',
+    title: 'Compare question meaning',
+    description: 'Do firstQuestion and secondQuestion request the same information under the same stated conditions?',
+    category: 'retrieval',
+    tags: ['retrieval', 'query', 'equivalence', 'rag', 'evidence'],
+    limitations: [
+        'Compares supplied questions. It does not rewrite them or establish that an existing answer is still valid.',
+    ],
+};

package/dist/recipes/query-equivalence/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const queryEquivalenceVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    equivalent: "equivalent";
+    related: "related";
+    different: "different";
+}>;
+export declare const queryEquivalenceInputSchema: z.ZodObject<{
+    firstQuestion: z.ZodString;
+    secondQuestion: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const queryEquivalenceResultSchema: 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";
+        equivalent: "equivalent";
+        related: "related";
+        different: "different";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        equivalent: "equivalent";
+        related: "related";
+        different: "different";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type QueryEquivalenceInput = z.infer<typeof queryEquivalenceInputSchema>;
+export type QueryEquivalenceResult = z.infer<typeof queryEquivalenceResultSchema>;
+export type QueryEquivalenceVerdict = z.infer<typeof queryEquivalenceVerdictSchema>;

package/dist/recipes/query-equivalence/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const queryEquivalenceVerdictSchema = z.enum([
+    'equivalent',
+    'related',
+    'different',
+    'unclear',
+]);
+export const queryEquivalenceInputSchema = z.object({
+    firstQuestion: nonEmptyText,
+    secondQuestion: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const queryEquivalenceResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: queryEquivalenceVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(queryEquivalenceVerdictSchema, probability),
+});

package/dist/recipes/query-specificity/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { QuerySpecificityInput, QuerySpecificityResult } from './schema.js';
+export declare function querySpecificity(input: QuerySpecificityInput, options?: RecipeOptions): Promise<QuerySpecificityResult>;
+export { querySpecificityInputSchema, querySpecificityResultSchema, querySpecificityVerdictSchema, } from './schema.js';
+export type { QuerySpecificityInput, QuerySpecificityResult, QuerySpecificityVerdict, } from './schema.js';

package/dist/recipes/query-specificity/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { querySpecificityInputSchema, querySpecificityResultSchema } from './schema.js';
+export async function querySpecificity(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = querySpecificityInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does question, interpreted with context, identify a focused information need? A broad but clear request differs from an ambiguous reference or missing subject.', {
+        specific: 'The subject and requested information are sufficiently clear and focused.',
+        too_broad: 'The intended subject is clear but the request spans an open-ended range of information.',
+        ambiguous: 'The subject, reference, or intended information has multiple unresolved meanings.',
+    }, options);
+    return querySpecificityResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'ambiguous' ? 'review' : 'ready',
+    });
+}
+export { querySpecificityInputSchema, querySpecificityResultSchema, querySpecificityVerdictSchema, } from './schema.js';

package/dist/recipes/query-specificity/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/query-specificity/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'query-specificity',
+    title: 'Check question specificity',
+    description: 'Does question, interpreted with context, identify a focused information need?',
+    category: 'retrieval',
+    tags: ['retrieval', 'query', 'specificity', 'rag', 'evidence'],
+    limitations: [
+        'Assesses focus only. Use clarify when the application has explicit required fields to check.',
+    ],
+};

package/dist/recipes/query-specificity/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const querySpecificityVerdictSchema: z.ZodEnum<{
+    ambiguous: "ambiguous";
+    specific: "specific";
+    too_broad: "too_broad";
+}>;
+export declare const querySpecificityInputSchema: z.ZodObject<{
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const querySpecificityResultSchema: 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<{
+        ambiguous: "ambiguous";
+        specific: "specific";
+        too_broad: "too_broad";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        ambiguous: "ambiguous";
+        specific: "specific";
+        too_broad: "too_broad";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type QuerySpecificityInput = z.infer<typeof querySpecificityInputSchema>;
+export type QuerySpecificityResult = z.infer<typeof querySpecificityResultSchema>;
+export type QuerySpecificityVerdict = z.infer<typeof querySpecificityVerdictSchema>;

package/dist/recipes/query-specificity/schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const querySpecificityVerdictSchema = z.enum(['specific', 'too_broad', 'ambiguous']);
+export const querySpecificityInputSchema = z.object({
+    question: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const querySpecificityResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: querySpecificityVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(querySpecificityVerdictSchema, probability),
+});

package/dist/recipes/reference-resolve/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReferenceResolveInput, ReferenceResolveResult } from './schema.js';
+export declare function referenceResolve(input: ReferenceResolveInput, options?: RecipeOptions): Promise<ReferenceResolveResult>;
+export { referenceResolveInputSchema, referenceResolveResultSchema } from './schema.js';
+export type { ReferenceResolveInput, ReferenceResolveResult } from './schema.js';

package/dist/recipes/reference-resolve/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { referenceResolveInputSchema } from './schema.js';
+export async function referenceResolve(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = referenceResolveInputSchema.parse(input);
+    return selectCandidate(state, state.candidates, 'Which supplied candidate does reference refer to in message and context? Resolve only this reference. Do not invent an entity or break a genuine tie.', minConfidence, options);
+}
+export { referenceResolveInputSchema, referenceResolveResultSchema } from './schema.js';

package/dist/recipes/reference-resolve/metadata.d.ts

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

package/dist/recipes/reference-resolve/metadata.js

@@ -0,0 +1,11 @@
+export const metadata = {
+    id: 'reference-resolve',
+    title: 'Resolve a reference',
+    description: 'Which supplied candidate does reference refer to in message and context?',
+    category: 'conversation',
+    tags: ['conversation', 'reference', 'resolve'],
+    limitations: [
+        'Resolves a supplied reference among candidates. It does not extract references, verify identity, or authorize changes.',
+        'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+    ],
+};

package/dist/recipes/reference-resolve/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const referenceResolveInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    reference: z.ZodString;
+    candidates: 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 referenceResolveResultSchema: 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 ReferenceResolveInput = z.infer<typeof referenceResolveInputSchema>;
+export type ReferenceResolveResult = z.infer<typeof referenceResolveResultSchema>;

package/dist/recipes/reference-resolve/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, selectionResultSchema, textItemsSchema, } from '../../src/schema.js';
+export const referenceResolveInputSchema = z.object({
+    message: nonEmptyText,
+    reference: nonEmptyText,
+    candidates: textItemsSchema,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const referenceResolveResultSchema = selectionResultSchema;

package/dist/recipes/repeated-attempt/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RepeatedAttemptInput, RepeatedAttemptResult } from './schema.js';
+export declare function repeatedAttempt(input: RepeatedAttemptInput, options?: RecipeOptions): Promise<RepeatedAttemptResult>;
+export { repeatedAttemptInputSchema, repeatedAttemptResultSchema, repeatedAttemptVerdictSchema, } from './schema.js';
+export type { RepeatedAttemptInput, RepeatedAttemptResult, RepeatedAttemptVerdict, } from './schema.js';

package/dist/recipes/repeated-attempt/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { repeatedAttemptInputSchema, repeatedAttemptResultSchema } from './schema.js';
+export async function repeatedAttempt(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = repeatedAttemptInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does proposedAttempt use essentially the same approach as previousAttempt for objective? Rewording the same query without a material strategy change counts as the same approach.', {
+        same_approach: 'The proposed attempt repeats the material method and relevant assumptions.',
+        different_approach: 'The proposed attempt changes a material method, source, or assumption.',
+        unclear: 'The attempts are not described precisely enough to compare.',
+    }, options);
+    return repeatedAttemptResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { repeatedAttemptInputSchema, repeatedAttemptResultSchema, repeatedAttemptVerdictSchema, } from './schema.js';

package/dist/recipes/repeated-attempt/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/repeated-attempt/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'repeated-attempt',
+    title: 'Compare attempted approaches',
+    description: 'Does proposedAttempt use essentially the same approach as previousAttempt for objective?',
+    category: 'workflow',
+    tags: ['workflow', 'repeated', 'attempt'],
+    limitations: [
+        'Compares two attempts only. Counting repeats, deciding whether a retry is justified, and stopping loops belong in application code.',
+    ],
+};

package/dist/recipes/repeated-attempt/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const repeatedAttemptVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    same_approach: "same_approach";
+    different_approach: "different_approach";
+}>;
+export declare const repeatedAttemptInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    previousAttempt: z.ZodString;
+    proposedAttempt: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const repeatedAttemptResultSchema: 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";
+        same_approach: "same_approach";
+        different_approach: "different_approach";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        same_approach: "same_approach";
+        different_approach: "different_approach";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type RepeatedAttemptInput = z.infer<typeof repeatedAttemptInputSchema>;
+export type RepeatedAttemptResult = z.infer<typeof repeatedAttemptResultSchema>;
+export type RepeatedAttemptVerdict = z.infer<typeof repeatedAttemptVerdictSchema>;

package/dist/recipes/repeated-attempt/schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const repeatedAttemptVerdictSchema = z.enum([
+    'same_approach',
+    'different_approach',
+    'unclear',
+]);
+export const repeatedAttemptInputSchema = z.object({
+    objective: nonEmptyText,
+    previousAttempt: nonEmptyText,
+    proposedAttempt: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const repeatedAttemptResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: repeatedAttemptVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(repeatedAttemptVerdictSchema, probability),
+});

package/dist/recipes/reply-template-match/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReplyTemplateMatchInput, ReplyTemplateMatchResult } from './schema.js';
+export declare function replyTemplateMatch(input: ReplyTemplateMatchInput, options?: RecipeOptions): Promise<ReplyTemplateMatchResult>;
+export { replyTemplateMatchInputSchema, replyTemplateMatchResultSchema } from './schema.js';
+export type { ReplyTemplateMatchInput, ReplyTemplateMatchResult } from './schema.js';

package/dist/recipes/reply-template-match/index.js

@@ -0,0 +1,7 @@
+import { selectCandidate } from '../../src/selection.js';
+import { replyTemplateMatchInputSchema } from './schema.js';
+export async function replyTemplateMatch(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = replyTemplateMatchInputSchema.parse(input);
+    return selectCandidate(state, state.templates, 'Which supplied approved template applies to request and context? Match any stated template conditions and do not select a template that promises unsupported actions.', minConfidence, options);
+}
+export { replyTemplateMatchInputSchema, replyTemplateMatchResultSchema } from './schema.js';

package/dist/recipes/reply-template-match/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/reply-template-match/metadata.js

@@ -0,0 +1,11 @@
+export const metadata = {
+    id: 'reply-template-match',
+    title: 'Select a reply template',
+    description: 'Which supplied approved template applies to request and context?',
+    category: 'support',
+    tags: ['support', 'reply', 'template', 'match'],
+    limitations: [
+        'Selects a supplied template. It does not fill placeholders, approve its content, personalize it, or send a response.',
+        'Supply 1 to 50 items per list, each with a unique non-empty ID and non-empty text.',
+    ],
+};