jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/repetition-level/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';
+export async function repetitionLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = repetitionLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How repetitive is recentMaterial? Judge only the material supplied: how often the same pitches, figure, or rhythm return, whether repeats are exact or altered, and whether anything new appears between them. Varied material keeps changing contour, rhythm, or pitch content. Some repetition means a figure recurs but is answered by new material. Repetitive means the same figure or rhythm dominates with only small changes such as one altered note or a shift of register. Looping means the same figure repeats several times verbatim with nothing new between repeats. Stuck means the material has collapsed to a single note, interval, or chord with no other content at all. Ignore whether the repetition is stylistically appropriate.', [
+        'The material changes contour, rhythm, or pitch content from figure to figure, with at most an incidental echo.',
+        'A figure or rhythm recurs once or twice but is answered or followed by new material.',
+        'The same figure or rhythm returns for most of the material with only small changes, such as one altered note or a shift of register.',
+        'The same figure repeats several times verbatim with nothing new between the repeats.',
+        'The material has collapsed to a single note, interval, or chord repeated with no other content at all.',
+    ], options);
+    return repetitionLevelResultSchema.parse({
+        ...decision,
+        repetition: repetitionLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { repetitionLevelInputSchema, repetitionLevelResultSchema, repetitionLevelVerdictSchema, } from './schema.js';

package/dist/recipes/repetition-level/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const repetitionLevelVerdictSchema: z.ZodEnum<{
+    some: "some";
+    varied: "varied";
+    repetitive: "repetitive";
+    looping: "looping";
+    stuck: "stuck";
+}>;
+export declare const repetitionLevelInputSchema: z.ZodObject<{
+    recentMaterial: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const repetitionLevelResultSchema: 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";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    repetition: z.ZodEnum<{
+        some: "some";
+        varied: "varied";
+        repetitive: "repetitive";
+        looping: "looping";
+        stuck: "stuck";
+    }>;
+}, z.core.$strip>;
+export type RepetitionLevelVerdict = z.infer<typeof repetitionLevelVerdictSchema>;
+export type RepetitionLevelInput = z.infer<typeof repetitionLevelInputSchema>;
+export type RepetitionLevelResult = z.infer<typeof repetitionLevelResultSchema>;

package/dist/recipes/repetition-level/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const repetitionLevelVerdictSchema = z.enum([
+    'varied',
+    'some',
+    'repetitive',
+    'looping',
+    'stuck',
+]);
+export const repetitionLevelInputSchema = z.object({
+    recentMaterial: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const repetitionLevelResultSchema = scoreResultSchema.extend({
+    repetition: repetitionLevelVerdictSchema,
+});

package/dist/recipes/report-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "report": "Migrated 4 of the 6 legacy endpoints to the new router; all 38 tests in tests/api pass (run log attached). The remaining two endpoints depend on the auth middleware rewrite, which is still blocked on the token format decision from the platform team. Next I will stub the middleware so the last two endpoints can be migrated behind a feature flag.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesOutcome": { "type": "noul", "noul": 0.95 },
+      "providesEvidence": { "type": "noul", "noul": 0.88 },
+      "statesBlockers": { "type": "noul", "noul": 0.91 },
+      "statesNextStep": { "type": "noul", "noul": 0.93 },
+      "raisesQuestions": { "type": "noul", "noul": 0.12 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/report-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReportFacetsInput, ReportFacetsResult } from './schema.js';
+export declare function reportFacets(input: ReportFacetsInput, options?: RecipeOptions): Promise<ReportFacetsResult>;
+export { reportFacetsInputSchema, reportFacetsResultSchema, reportFacetsLabelSchema, } from './schema.js';
+export type { ReportFacetsInput, ReportFacetsResult, ReportFacetsLabel } from './schema.js';

package/dist/recipes/report-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { reportFacetsInputSchema, reportFacetsResultSchema } from './schema.js';
+export async function reportFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reportFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesOutcome: {
+            instruction: 'Does report state an outcome: what was accomplished, what failed, or what the current result is?',
+            criteria: {
+                true: 'The report states what was achieved, what failed, or where the work stands.',
+                false: 'The report describes activity without stating an outcome.',
+            },
+        },
+        providesEvidence: {
+            instruction: 'Does report provide evidence that supports its claims, such as test output, measurements, file paths, quotes, or links?',
+            criteria: {
+                true: 'The report includes concrete evidence a reader could check.',
+                false: 'The report makes claims without supporting evidence.',
+            },
+        },
+        statesBlockers: {
+            instruction: 'Does report state a blocker: something preventing progress that the agent cannot resolve alone?',
+            criteria: {
+                true: 'The report names at least one blocker or obstacle to progress.',
+                false: 'The report names no blocker.',
+            },
+        },
+        statesNextStep: {
+            instruction: 'Does report state a next step: what the agent will do, or proposes to do, after this report?',
+            criteria: {
+                true: 'The report states a concrete next step.',
+                false: 'The report states no next step.',
+            },
+        },
+        raisesQuestions: {
+            instruction: 'Does report raise an open question or request a decision from the reader?',
+            criteria: {
+                true: 'The report asks at least one question or requests a decision.',
+                false: 'The report asks nothing of the reader.',
+            },
+        },
+    }, options);
+    return reportFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { reportFacetsInputSchema, reportFacetsResultSchema, reportFacetsLabelSchema, } from './schema.js';

package/dist/recipes/report-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const reportFacetsLabelSchema: z.ZodEnum<{
+    providesEvidence: "providesEvidence";
+    statesOutcome: "statesOutcome";
+    statesBlockers: "statesBlockers";
+    statesNextStep: "statesNextStep";
+    raisesQuestions: "raisesQuestions";
+}>;
+export declare const reportFacetsInputSchema: z.ZodObject<{
+    report: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reportFacetsResultSchema: 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";
+    }>;
+    detected: z.ZodArray<z.ZodEnum<{
+        providesEvidence: "providesEvidence";
+        statesOutcome: "statesOutcome";
+        statesBlockers: "statesBlockers";
+        statesNextStep: "statesNextStep";
+        raisesQuestions: "raisesQuestions";
+    }>>;
+    labels: z.ZodObject<{
+        statesOutcome: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        providesEvidence: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesBlockers: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesNextStep: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        raisesQuestions: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ReportFacetsLabel = z.infer<typeof reportFacetsLabelSchema>;
+export type ReportFacetsInput = z.infer<typeof reportFacetsInputSchema>;
+export type ReportFacetsResult = z.infer<typeof reportFacetsResultSchema>;

package/dist/recipes/report-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const reportFacetsLabelSchema = z.enum([
+    'statesOutcome',
+    'providesEvidence',
+    'statesBlockers',
+    'statesNextStep',
+    'raisesQuestions',
+]);
+export const reportFacetsInputSchema = z.object({
+    report: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const reportFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(reportFacetsLabelSchema),
+    labels: z.object({
+        statesOutcome: labelCheckSchema,
+        providesEvidence: labelCheckSchema,
+        statesBlockers: labelCheckSchema,
+        statesNextStep: labelCheckSchema,
+        raisesQuestions: labelCheckSchema,
+    }),
+});

package/dist/recipes/requirement-testability/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const requirementTestabilityVerdictSchema: z.ZodEnum<{
-    testable: "testable";
     unclear: "unclear";
+    testable: "testable";
     not_testable: "not_testable";
 }>;
 export declare const requirementTestabilityInputSchema: z.ZodObject<{
@@ -20,14 +20,14 @@ export declare const requirementTestabilityResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        testable: "testable";
         unclear: "unclear";
+        testable: "testable";
         not_testable: "not_testable";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        testable: "testable";
         unclear: "unclear";
+        testable: "testable";
         not_testable: "not_testable";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/response-refusal/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const responseRefusalVerdictSchema: z.ZodEnum<{
-    attempted: "attempted";
     unclear: "unclear";
+    attempted: "attempted";
     mixed: "mixed";
     not_addressed: "not_addressed";
     refused: "refused";
@@ -24,8 +24,8 @@ export declare const responseRefusalResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        attempted: "attempted";
         unclear: "unclear";
+        attempted: "attempted";
         mixed: "mixed";
         not_addressed: "not_addressed";
         refused: "refused";
@@ -33,8 +33,8 @@ export declare const responseRefusalResultSchema: z.ZodObject<{
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        attempted: "attempted";
         unclear: "unclear";
+        attempted: "attempted";
         mixed: "mixed";
         not_addressed: "not_addressed";
         refused: "refused";

package/dist/recipes/result-outcome/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const resultOutcomeVerdictSchema: z.ZodEnum<{
     success: "success";
-    failure: "failure";
     unclear: "unclear";
+    failure: "failure";
     partial_success: "partial_success";
 }>;
 export declare const resultOutcomeInputSchema: z.ZodObject<{
@@ -22,15 +22,15 @@ export declare const resultOutcomeResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         success: "success";
-        failure: "failure";
         unclear: "unclear";
+        failure: "failure";
         partial_success: "partial_success";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         success: "success";
-        failure: "failure";
         unclear: "unclear";
+        failure: "failure";
         partial_success: "partial_success";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/result-plausibility/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "request": "List the three most recent production deploys with their commit SHAs and deploy times.",
+    "result": "[{\"id\": 1, \"sha\": \"abc123\", \"deployed_at\": \"2024-01-01T00:00:00Z\"}, {\"id\": 2, \"sha\": \"abc123\", \"deployed_at\": \"2024-01-01T00:00:00Z\"}, {\"id\": 3, \"sha\": \"abc123\", \"deployed_at\": \"2024-01-01T00:00:00Z\"}]",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.07 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/result-plausibility/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ResultPlausibilityInput, ResultPlausibilityResult } from './schema.js';
+export declare function resultPlausibility(input: ResultPlausibilityInput, options?: RecipeOptions): Promise<ResultPlausibilityResult>;
+export { resultPlausibilityInputSchema, resultPlausibilityResultSchema, resultPlausibilityVerdictSchema, } from './schema.js';
+export type { ResultPlausibilityInput, ResultPlausibilityResult, ResultPlausibilityVerdict, } from './schema.js';

package/dist/recipes/result-plausibility/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { resultPlausibilityInputSchema, resultPlausibilityResultSchema } from './schema.js';
+export async function resultPlausibility(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = resultPlausibilityInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Is result a plausible, internally consistent answer to request? Count result as implausible when it is an error message, a placeholder or template, empty or near-empty output, repeated or filler values, self-contradictory content, or output about something other than what request asked for, even when it is formatted as valid data. Judge only the supplied result. Do not verify its values against outside knowledge.', {
+        true: 'The result reads as a genuine, internally consistent answer to the request.',
+        false: 'The result is an error, placeholder, empty, inconsistent, or unrelated output rather than a real answer.',
+    }, options);
+    return resultPlausibilityResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'plausible' : 'implausible',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { resultPlausibilityInputSchema, resultPlausibilityResultSchema, resultPlausibilityVerdictSchema, } from './schema.js';

package/dist/recipes/result-plausibility/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const resultPlausibilityVerdictSchema: z.ZodEnum<{
+    plausible: "plausible";
+    implausible: "implausible";
+}>;
+export declare const resultPlausibilityInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    result: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const resultPlausibilityResultSchema: 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";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        plausible: "plausible";
+        implausible: "implausible";
+    }>;
+}, z.core.$strip>;
+export type ResultPlausibilityVerdict = z.infer<typeof resultPlausibilityVerdictSchema>;
+export type ResultPlausibilityInput = z.infer<typeof resultPlausibilityInputSchema>;
+export type ResultPlausibilityResult = z.infer<typeof resultPlausibilityResultSchema>;

package/dist/recipes/result-plausibility/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const resultPlausibilityVerdictSchema = z.enum(['plausible', 'implausible']);
+export const resultPlausibilityInputSchema = z.object({
+    request: nonEmptyText,
+    result: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const resultPlausibilityResultSchema = gateResultSchema.extend({
+    verdict: resultPlausibilityVerdictSchema,
+});

package/dist/recipes/retrieval-needed/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const retrievalNeededVerdictSchema: z.ZodEnum<{
-    needed: "needed";
     unclear: "unclear";
+    needed: "needed";
     unnecessary: "unnecessary";
 }>;
 export declare const retrievalNeededInputSchema: z.ZodObject<{
@@ -20,14 +20,14 @@ export declare const retrievalNeededResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        needed: "needed";
         unclear: "unclear";
+        needed: "needed";
         unnecessary: "unnecessary";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        needed: "needed";
         unclear: "unclear";
+        needed: "needed";
         unnecessary: "unnecessary";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/retry-worthwhile/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "failure": "HTTP 429 Too Many Requests: rate limit exceeded for this API key. Retry-After: 30.",
+    "attempt": "First attempt, issued immediately after a batch of 50 similar calls to the same endpoint.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.95 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/retry-worthwhile/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RetryWorthwhileInput, RetryWorthwhileResult } from './schema.js';
+export declare function retryWorthwhile(input: RetryWorthwhileInput, options?: RecipeOptions): Promise<RetryWorthwhileResult>;
+export { retryWorthwhileInputSchema, retryWorthwhileResultSchema, retryWorthwhileVerdictSchema, } from './schema.js';
+export type { RetryWorthwhileInput, RetryWorthwhileResult, RetryWorthwhileVerdict, } from './schema.js';

package/dist/recipes/retry-worthwhile/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { retryWorthwhileInputSchema, retryWorthwhileResultSchema } from './schema.js';
+export async function retryWorthwhile(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = retryWorthwhileInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does failure describe a transient condition where repeating the identical attempt could succeed? Transient conditions include timeouts, rate limits, temporary unavailability, lock contention, and interrupted connections. Deterministic failures include invalid input, permission denied, resources that do not exist, and logic errors, which recur unchanged on retry. Use attempt, when supplied, for how many times and how recently the same action has already been tried; repeated identical failures make a further retry less worthwhile.', {
+        true: 'The failure is transient and an identical retry could succeed.',
+        false: 'The failure is deterministic and an identical retry would fail the same way.',
+    }, options);
+    return retryWorthwhileResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'retry' : 'stop',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { retryWorthwhileInputSchema, retryWorthwhileResultSchema, retryWorthwhileVerdictSchema, } from './schema.js';

package/dist/recipes/retry-worthwhile/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const retryWorthwhileVerdictSchema: z.ZodEnum<{
+    retry: "retry";
+    stop: "stop";
+}>;
+export declare const retryWorthwhileInputSchema: z.ZodObject<{
+    failure: z.ZodString;
+    attempt: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const retryWorthwhileResultSchema: 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";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        retry: "retry";
+        stop: "stop";
+    }>;
+}, z.core.$strip>;
+export type RetryWorthwhileVerdict = z.infer<typeof retryWorthwhileVerdictSchema>;
+export type RetryWorthwhileInput = z.infer<typeof retryWorthwhileInputSchema>;
+export type RetryWorthwhileResult = z.infer<typeof retryWorthwhileResultSchema>;

package/dist/recipes/retry-worthwhile/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const retryWorthwhileVerdictSchema = z.enum(['retry', 'stop']);
+export const retryWorthwhileInputSchema = z.object({
+    failure: nonEmptyText,
+    attempt: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const retryWorthwhileResultSchema = gateResultSchema.extend({
+    verdict: retryWorthwhileVerdictSchema,
+});

package/dist/recipes/review-comment-kind/demo.json

@@ -0,0 +1,29 @@
+{
+  "input": {
+    "comment": "This returns undefined when the list is empty because items[0] is read before the length check. Guard on items.length first.",
+    "context": "Comment left on a helper function in a pull request that adds a formatting utility."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "bug",
+        "confidence": 0.91,
+        "probabilities": {
+          "bug": 0.91,
+          "design": 0.04,
+          "style": 0.01,
+          "question": 0.01,
+          "nit": 0.02,
+          "praise": 0,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/review-comment-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ReviewCommentKindInput, ReviewCommentKindResult } from './schema.js';
+export declare function reviewCommentKind(input: ReviewCommentKindInput, options?: RecipeOptions): Promise<ReviewCommentKindResult>;
+export { reviewCommentKindInputSchema, reviewCommentKindResultSchema, reviewCommentKindVerdictSchema, } from './schema.js';
+export type { ReviewCommentKindInput, ReviewCommentKindResult, ReviewCommentKindVerdict, } from './schema.js';

package/dist/recipes/review-comment-kind/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { reviewCommentKindInputSchema, reviewCommentKindResultSchema } from './schema.js';
+export async function reviewCommentKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = reviewCommentKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What is the primary kind of comment, given any context? Judge what the reviewer is mainly asking the author to do or notice, not the tone or length of the wording.', {
+        bug: 'The comment points at incorrect behavior, a defect, or a case the code handles wrongly.',
+        design: 'The comment concerns structure, architecture, or the overall approach rather than a specific defect.',
+        style: 'The comment concerns naming, formatting, or idiom without changing behavior.',
+        question: 'The comment asks for clarification or explanation without asserting a problem.',
+        nit: 'The comment suggests trivial optional polish that the author may ignore.',
+        praise: 'The comment expresses approval or appreciation without requesting a change.',
+        unclear: 'The primary kind of the comment is not established by the supplied text.',
+    }, options);
+    return reviewCommentKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { reviewCommentKindInputSchema, reviewCommentKindResultSchema, reviewCommentKindVerdictSchema, } from './schema.js';

package/dist/recipes/review-comment-kind/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const reviewCommentKindVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    style: "style";
+    question: "question";
+    praise: "praise";
+    bug: "bug";
+    design: "design";
+    nit: "nit";
+}>;
+export declare const reviewCommentKindInputSchema: z.ZodObject<{
+    comment: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const reviewCommentKindResultSchema: 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";
+        style: "style";
+        question: "question";
+        praise: "praise";
+        bug: "bug";
+        design: "design";
+        nit: "nit";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        style: "style";
+        question: "question";
+        praise: "praise";
+        bug: "bug";
+        design: "design";
+        nit: "nit";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ReviewCommentKindInput = z.infer<typeof reviewCommentKindInputSchema>;
+export type ReviewCommentKindResult = z.infer<typeof reviewCommentKindResultSchema>;
+export type ReviewCommentKindVerdict = z.infer<typeof reviewCommentKindVerdictSchema>;