jev-recipes 0.0.4 → 0.2.0

package/dist/recipes/intent-change/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const intentChangeVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    continues: "continues";
+    refines: "refines";
+    replaces: "replaces";
+}>;
+export declare const intentChangeInputSchema: z.ZodObject<{
+    currentGoal: z.ZodString;
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const intentChangeResultSchema: 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";
+        continues: "continues";
+        refines: "refines";
+        replaces: "replaces";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        continues: "continues";
+        refines: "refines";
+        replaces: "replaces";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type IntentChangeInput = z.infer<typeof intentChangeInputSchema>;
+export type IntentChangeResult = z.infer<typeof intentChangeResultSchema>;
+export type IntentChangeVerdict = z.infer<typeof intentChangeVerdictSchema>;

package/dist/recipes/intent-change/schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const intentChangeVerdictSchema = z.enum(['continues', 'refines', 'replaces', 'unclear']);
+export const intentChangeInputSchema = z.object({
+    currentGoal: nonEmptyText,
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const intentChangeResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: intentChangeVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(intentChangeVerdictSchema, probability),
+});

package/dist/recipes/issue-impact/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { IssueImpactInput, IssueImpactResult } from './schema.js';
+export declare function issueImpact(input: IssueImpactInput, options?: RecipeOptions): Promise<IssueImpactResult>;
+export { issueImpactInputSchema, issueImpactResultSchema, issueImpactVerdictSchema, } from './schema.js';
+export type { IssueImpactInput, IssueImpactResult, IssueImpactVerdict } from './schema.js';

package/dist/recipes/issue-impact/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { issueImpactInputSchema, issueImpactResultSchema } from './schema.js';
+export async function issueImpact(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = issueImpactInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "What practical impact does message explicitly describe? Use the customer's described ability to work, not emotional intensity or the volume of complaints.", {
+        blocked: 'The customer reports being unable to perform the intended task with no described working alternative.',
+        degraded: 'The task remains possible but with a meaningful limitation or workaround.',
+        cosmetic: 'The reported problem concerns appearance without a described functional limitation.',
+        unclear: 'The practical impact is not established by the supplied report.',
+    }, options);
+    return issueImpactResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { issueImpactInputSchema, issueImpactResultSchema, issueImpactVerdictSchema, } from './schema.js';

package/dist/recipes/issue-impact/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/issue-impact/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'issue-impact',
+    title: 'Assess reported issue impact',
+    description: 'What practical impact does message explicitly describe?',
+    category: 'support',
+    tags: ['support', 'issue', 'impact'],
+    limitations: [
+        'Assesses reported impact, not verified system severity. Service commitments and escalation thresholds remain application rules.',
+    ],
+};

package/dist/recipes/issue-impact/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const issueImpactVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    blocked: "blocked";
+    degraded: "degraded";
+    cosmetic: "cosmetic";
+}>;
+export declare const issueImpactInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const issueImpactResultSchema: 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";
+        blocked: "blocked";
+        degraded: "degraded";
+        cosmetic: "cosmetic";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        blocked: "blocked";
+        degraded: "degraded";
+        cosmetic: "cosmetic";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type IssueImpactInput = z.infer<typeof issueImpactInputSchema>;
+export type IssueImpactResult = z.infer<typeof issueImpactResultSchema>;
+export type IssueImpactVerdict = z.infer<typeof issueImpactVerdictSchema>;

package/dist/recipes/issue-impact/schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const issueImpactVerdictSchema = z.enum(['blocked', 'degraded', 'cosmetic', 'unclear']);
+export const issueImpactInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const issueImpactResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: issueImpactVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(issueImpactVerdictSchema, probability),
+});

package/dist/recipes/memory-relation/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MemoryRelationInput, MemoryRelationResult } from './schema.js';
+export declare function memoryRelation(input: MemoryRelationInput, options?: RecipeOptions): Promise<MemoryRelationResult>;
+export { memoryRelationInputSchema, memoryRelationResultSchema, memoryRelationVerdictSchema, } from './schema.js';
+export type { MemoryRelationInput, MemoryRelationResult, MemoryRelationVerdict } from './schema.js';

package/dist/recipes/memory-relation/index.js

@@ -0,0 +1,18 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { memoryRelationInputSchema, memoryRelationResultSchema } from './schema.js';
+export async function memoryRelation(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = memoryRelationInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How does newFact relate to existingMemory? Choose updates only when a change or replacement is explicitly established, not merely because newFact was supplied later.', {
+        repeats: 'The new fact restates the existing meaning without a material addition.',
+        supplements: 'The new fact adds compatible information while the existing memory still applies.',
+        updates: 'The new fact explicitly changes or replaces the existing fact within the same scope.',
+        conflicts: 'The facts are incompatible within the same scope without an established replacement.',
+        unrelated: 'The facts concern unrelated subjects or scopes.',
+        unclear: 'Their relationship cannot be resolved.',
+    }, options);
+    return memoryRelationResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { memoryRelationInputSchema, memoryRelationResultSchema, memoryRelationVerdictSchema, } from './schema.js';

package/dist/recipes/memory-relation/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/memory-relation/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'memory-relation',
+    title: 'Compare a new fact with memory',
+    description: 'How does newFact relate to existingMemory?',
+    category: 'memory',
+    tags: ['memory', 'relation'],
+    limitations: [
+        'Compares two supplied facts. It does not select a memory to overwrite or resolve conflicts by timestamp alone.',
+    ],
+};

package/dist/recipes/memory-relation/schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const memoryRelationVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    unrelated: "unrelated";
+    conflicts: "conflicts";
+    repeats: "repeats";
+    supplements: "supplements";
+    updates: "updates";
+}>;
+export declare const memoryRelationInputSchema: z.ZodObject<{
+    existingMemory: z.ZodString;
+    newFact: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const memoryRelationResultSchema: 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";
+        unrelated: "unrelated";
+        conflicts: "conflicts";
+        repeats: "repeats";
+        supplements: "supplements";
+        updates: "updates";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        unrelated: "unrelated";
+        conflicts: "conflicts";
+        repeats: "repeats";
+        supplements: "supplements";
+        updates: "updates";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MemoryRelationInput = z.infer<typeof memoryRelationInputSchema>;
+export type MemoryRelationResult = z.infer<typeof memoryRelationResultSchema>;
+export type MemoryRelationVerdict = z.infer<typeof memoryRelationVerdictSchema>;

package/dist/recipes/memory-relation/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const memoryRelationVerdictSchema = z.enum([
+    'repeats',
+    'supplements',
+    'updates',
+    'conflicts',
+    'unrelated',
+    'unclear',
+]);
+export const memoryRelationInputSchema = z.object({
+    existingMemory: nonEmptyText,
+    newFact: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const memoryRelationResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: memoryRelationVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(memoryRelationVerdictSchema, probability),
+});

package/dist/recipes/memory-scope/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MemoryScopeInput, MemoryScopeResult } from './schema.js';
+export declare function memoryScope(input: MemoryScopeInput, options?: RecipeOptions): Promise<MemoryScopeResult>;
+export { memoryScopeInputSchema, memoryScopeResultSchema, memoryScopeVerdictSchema, } from './schema.js';
+export type { MemoryScopeInput, MemoryScopeResult, MemoryScopeVerdict } from './schema.js';

package/dist/recipes/memory-scope/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { memoryScopeInputSchema, memoryScopeResultSchema } from './schema.js';
+export async function memoryScope(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = memoryScopeInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What is the narrowest explicitly supported scope of fact in context? Do not generalize a one-off instruction into a lasting user preference.', {
+        user: 'The fact explicitly applies to the user across projects or tasks.',
+        project: 'The fact applies to the identified project across its tasks.',
+        task: 'The fact applies to the current task only.',
+        session: 'The fact applies to this conversation session across its immediate tasks.',
+        unclear: 'The intended scope is not established.',
+    }, options);
+    return memoryScopeResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { memoryScopeInputSchema, memoryScopeResultSchema, memoryScopeVerdictSchema, } from './schema.js';

package/dist/recipes/memory-scope/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/memory-scope/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'memory-scope',
+    title: 'Identify memory scope',
+    description: 'What is the narrowest explicitly supported scope of fact in context?',
+    category: 'memory',
+    tags: ['memory', 'scope'],
+    limitations: [
+        'Identifies semantic scope. It does not identify a storage tenant, establish consent, or persist a memory.',
+    ],
+};

package/dist/recipes/memory-scope/schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const memoryScopeVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    task: "task";
+    user: "user";
+    project: "project";
+    session: "session";
+}>;
+export declare const memoryScopeInputSchema: z.ZodObject<{
+    fact: z.ZodString;
+    context: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const memoryScopeResultSchema: 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";
+        task: "task";
+        user: "user";
+        project: "project";
+        session: "session";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        task: "task";
+        user: "user";
+        project: "project";
+        session: "session";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MemoryScopeInput = z.infer<typeof memoryScopeInputSchema>;
+export type MemoryScopeResult = z.infer<typeof memoryScopeResultSchema>;
+export type MemoryScopeVerdict = z.infer<typeof memoryScopeVerdictSchema>;

package/dist/recipes/memory-scope/schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const memoryScopeVerdictSchema = z.enum(['user', 'project', 'task', 'session', 'unclear']);
+export const memoryScopeInputSchema = z.object({
+    fact: nonEmptyText,
+    context: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const memoryScopeResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: memoryScopeVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(memoryScopeVerdictSchema, probability),
+});

package/dist/recipes/memory-value/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { MemoryValueInput, MemoryValueResult } from './schema.js';
+export declare function memoryValue(input: MemoryValueInput, options?: RecipeOptions): Promise<MemoryValueResult>;
+export { memoryValueInputSchema, memoryValueResultSchema, memoryValueVerdictSchema, } from './schema.js';
+export type { MemoryValueInput, MemoryValueResult, MemoryValueVerdict } from './schema.js';

package/dist/recipes/memory-value/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { memoryValueInputSchema, memoryValueResultSchema } from './schema.js';
+export async function memoryValue(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = memoryValueInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How useful is fact for future work under purpose? Distinguish lasting relevance from a current-task detail. Use the supplied purpose rather than assuming every personal fact is worth retaining.', {
+        ongoing_value: 'The fact has a clear recurring use for the supplied purpose beyond this task.',
+        task_only: 'The fact helps the current task but has no established recurring use.',
+        incidental: 'The fact has no clear use for the supplied purpose.',
+        unclear: 'Its future usefulness cannot be established.',
+    }, options);
+    return memoryValueResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { memoryValueInputSchema, memoryValueResultSchema, memoryValueVerdictSchema, } from './schema.js';

package/dist/recipes/memory-value/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/memory-value/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'memory-value',
+    title: 'Assess a candidate memory',
+    description: 'How useful is fact for future work under purpose?',
+    category: 'memory',
+    tags: ['memory', 'value'],
+    limitations: [
+        'Assesses usefulness only. Storage consent, sensitive-data policy, retention, and deletion must be enforced separately.',
+    ],
+};

package/dist/recipes/memory-value/schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const memoryValueVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    ongoing_value: "ongoing_value";
+    task_only: "task_only";
+    incidental: "incidental";
+}>;
+export declare const memoryValueInputSchema: z.ZodObject<{
+    fact: z.ZodString;
+    purpose: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const memoryValueResultSchema: 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";
+        ongoing_value: "ongoing_value";
+        task_only: "task_only";
+        incidental: "incidental";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        ongoing_value: "ongoing_value";
+        task_only: "task_only";
+        incidental: "incidental";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type MemoryValueInput = z.infer<typeof memoryValueInputSchema>;
+export type MemoryValueResult = z.infer<typeof memoryValueResultSchema>;
+export type MemoryValueVerdict = z.infer<typeof memoryValueVerdictSchema>;

package/dist/recipes/memory-value/schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const memoryValueVerdictSchema = z.enum([
+    'ongoing_value',
+    'task_only',
+    'incidental',
+    'unclear',
+]);
+export const memoryValueInputSchema = z.object({
+    fact: nonEmptyText,
+    purpose: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const memoryValueResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: memoryValueVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(memoryValueVerdictSchema, probability),
+});

package/dist/recipes/passage-duplicate/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PassageDuplicateInput, PassageDuplicateResult } from './schema.js';
+export declare function passageDuplicate(input: PassageDuplicateInput, options?: RecipeOptions): Promise<PassageDuplicateResult>;
+export { passageDuplicateInputSchema, passageDuplicateResultSchema, passageDuplicateVerdictSchema, } from './schema.js';
+export type { PassageDuplicateInput, PassageDuplicateResult, PassageDuplicateVerdict, } from './schema.js';

package/dist/recipes/passage-duplicate/index.js

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { passageDuplicateInputSchema, passageDuplicateResultSchema } from './schema.js';
+export async function passageDuplicate(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = passageDuplicateInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How much material information do firstPassage and secondPassage share? Different wording can express the same information. Shared subject matter alone does not make a duplicate.', {
+        duplicate: 'Both passages convey substantially the same material information.',
+        overlapping: 'They share material information but at least one adds meaningful details.',
+        distinct: 'They convey materially different information.',
+        unclear: 'The meaning cannot be compared reliably.',
+    }, options);
+    return passageDuplicateResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { passageDuplicateInputSchema, passageDuplicateResultSchema, passageDuplicateVerdictSchema, } from './schema.js';

package/dist/recipes/passage-duplicate/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/passage-duplicate/metadata.js

@@ -0,0 +1,10 @@
+export const metadata = {
+    id: 'passage-duplicate',
+    title: 'Compare passages for duplication',
+    description: 'How much material information do firstPassage and secondPassage share?',
+    category: 'retrieval',
+    tags: ['retrieval', 'passage', 'duplicate', 'rag', 'evidence'],
+    limitations: [
+        'Compares a supplied pair. It does not search a corpus, cluster documents, or remove content.',
+    ],
+};

package/dist/recipes/passage-duplicate/schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const passageDuplicateVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    duplicate: "duplicate";
+    overlapping: "overlapping";
+    distinct: "distinct";
+}>;
+export declare const passageDuplicateInputSchema: z.ZodObject<{
+    firstPassage: z.ZodString;
+    secondPassage: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const passageDuplicateResultSchema: 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";
+        duplicate: "duplicate";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        duplicate: "duplicate";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PassageDuplicateInput = z.infer<typeof passageDuplicateInputSchema>;
+export type PassageDuplicateResult = z.infer<typeof passageDuplicateResultSchema>;
+export type PassageDuplicateVerdict = z.infer<typeof passageDuplicateVerdictSchema>;

package/dist/recipes/passage-duplicate/schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const passageDuplicateVerdictSchema = z.enum([
+    'duplicate',
+    'overlapping',
+    'distinct',
+    'unclear',
+]);
+export const passageDuplicateInputSchema = z.object({
+    firstPassage: nonEmptyText,
+    secondPassage: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const passageDuplicateResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: passageDuplicateVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(passageDuplicateVerdictSchema, probability),
+});

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PreferenceKindInput, PreferenceKindResult } from './schema.js';
+export declare function preferenceKind(input: PreferenceKindInput, options?: RecipeOptions): Promise<PreferenceKindResult>;
+export { preferenceKindInputSchema, preferenceKindResultSchema, preferenceKindVerdictSchema, } from './schema.js';
+export type { PreferenceKindInput, PreferenceKindResult, PreferenceKindVerdict } from './schema.js';

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

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { preferenceKindInputSchema, preferenceKindResultSchema } from './schema.js';
+export async function preferenceKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = preferenceKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does statement express an ongoing preference, a factual assertion, or a temporary request? Do not treat a task-specific instruction as a lasting preference without evidence of scope.', {
+        preference: 'The statement expresses an ongoing choice or preferred way of working.',
+        fact: 'The statement asserts information without expressing a preference or requesting an action.',
+        temporary_request: 'The statement asks for something in the current situation without establishing a lasting preference.',
+        unclear: 'The intended kind cannot be established.',
+    }, options);
+    return preferenceKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { preferenceKindInputSchema, preferenceKindResultSchema, preferenceKindVerdictSchema, } from './schema.js';

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

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