jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/action-compare/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "goal": "Find out why the nightly export job failed last night.",
+    "firstAction": "Open the job's log for last night's run and read the last 200 lines.",
+    "secondAction": "Re-run the export job now and see if it fails again.",
+    "constraints": "Do not trigger production jobs during business hours.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "first",
+        "confidence": 0.88,
+        "probabilities": {
+          "first": 0.88,
+          "second": 0.04,
+          "tie": 0.04,
+          "neither": 0.02,
+          "unclear": 0.02
+        }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/action-compare/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ActionCompareInput, ActionCompareResult } from './schema.js';
+export declare function actionCompare(input: ActionCompareInput, options?: RecipeOptions): Promise<ActionCompareResult>;
+export { actionCompareInputSchema, actionCompareResultSchema, actionCompareVerdictSchema, } from './schema.js';
+export type { ActionCompareInput, ActionCompareResult, ActionCompareVerdict } from './schema.js';

package/dist/recipes/action-compare/index.js

@@ -0,0 +1,16 @@
+import { evaluateComparison } from '../../src/comparisons.js';
+import { actionCompareInputSchema, actionCompareResultSchema } from './schema.js';
+export async function actionCompare(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = actionCompareInputSchema.parse(input);
+    const decision = await evaluateComparison(state, 'Which action better advances goal while respecting any constraints? Judge expected progress toward the goal and compliance with the constraints, not effort or wording.', {
+        first: 'Only the first action advances the goal within the constraints, or it clearly does so better.',
+        second: 'Only the second action advances the goal within the constraints, or it clearly does so better.',
+        tie: 'Both actions advance the goal within the constraints about equally.',
+        neither: 'Neither action advances the goal within the constraints.',
+    }, options);
+    return actionCompareResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { actionCompareInputSchema, actionCompareResultSchema, actionCompareVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const actionCompareVerdictSchema: z.ZodEnum<{
+    first: "first";
+    second: "second";
+    tie: "tie";
+    neither: "neither";
+    unclear: "unclear";
+}>;
+export declare const actionCompareInputSchema: z.ZodObject<{
+    goal: z.ZodString;
+    firstAction: z.ZodString;
+    secondAction: z.ZodString;
+    constraints: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const actionCompareResultSchema: 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<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        first: "first";
+        second: "second";
+        tie: "tie";
+        neither: "neither";
+        unclear: "unclear";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ActionCompareVerdict = z.infer<typeof actionCompareVerdictSchema>;
+export type ActionCompareInput = z.infer<typeof actionCompareInputSchema>;
+export type ActionCompareResult = z.infer<typeof actionCompareResultSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { comparisonResultSchema, comparisonVerdictSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const actionCompareVerdictSchema = comparisonVerdictSchema;
+export const actionCompareInputSchema = z.object({
+    goal: nonEmptyText,
+    firstAction: nonEmptyText,
+    secondAction: nonEmptyText,
+    constraints: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const actionCompareResultSchema = comparisonResultSchema;

package/dist/recipes/action-effects/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "action": "Send the weekly product digest to all 1,240 subscribers on the newsletter list through the SendGrid API, then set last_digest_sent_at to now on each subscriber row in the users table.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "writesData": { "type": "noul", "noul": 0.94 },
+      "sendsMessage": { "type": "noul", "noul": 0.97 },
+      "spendsMoney": { "type": "noul", "noul": 0.04 },
+      "deletesData": { "type": "noul", "noul": 0.02 },
+      "callsExternal": { "type": "noul", "noul": 0.93 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/action-effects/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ActionEffectsInput, ActionEffectsResult } from './schema.js';
+export declare function actionEffects(input: ActionEffectsInput, options?: RecipeOptions): Promise<ActionEffectsResult>;
+export { actionEffectsInputSchema, actionEffectsResultSchema, actionEffectsLabelSchema, } from './schema.js';
+export type { ActionEffectsInput, ActionEffectsResult, ActionEffectsLabel } from './schema.js';

package/dist/recipes/action-effects/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { actionEffectsInputSchema, actionEffectsResultSchema } from './schema.js';
+export async function actionEffects(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = actionEffectsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        writesData: {
+            instruction: 'Does action create or modify stored data, such as records, files, settings, or state, without merely deleting it?',
+            criteria: {
+                true: 'The action creates, updates, or overwrites stored records, files, fields, or configuration.',
+                false: 'The action only reads, computes, sends, deletes, or does nothing to stored data.',
+            },
+        },
+        sendsMessage: {
+            instruction: 'Does action send a message or notification to a person or channel, such as an email, chat message, SMS, push notification, or post?',
+            criteria: {
+                true: 'The action transmits a message or notification that a person or channel will receive.',
+                false: 'The action sends nothing that a person or channel would receive as a message.',
+            },
+        },
+        spendsMoney: {
+            instruction: 'Does action spend, transfer, refund, or otherwise move money or paid credits?',
+            criteria: {
+                true: 'The action makes a purchase, payment, transfer, refund, or charge, or consumes paid credits the description names.',
+                false: 'The action moves no money and consumes no paid credits that the description names.',
+            },
+        },
+        deletesData: {
+            instruction: 'Does action delete, remove, drop, or purge stored data, records, files, or resources?',
+            criteria: {
+                true: 'The action removes stored data, records, files, or resources so they no longer exist in their current location.',
+                false: 'The action removes nothing; archiving or marking as inactive without removal does not count.',
+            },
+        },
+        callsExternal: {
+            instruction: "Does action call a service outside the system running the agent, such as a third-party API, a web request, or another vendor's platform?",
+            criteria: {
+                true: "The action contacts a third-party API, external web endpoint, or another organization's service.",
+                false: "The action stays within the system's own data and code with no outbound call to an external service.",
+            },
+        },
+    }, options);
+    return actionEffectsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { actionEffectsInputSchema, actionEffectsResultSchema, actionEffectsLabelSchema, } from './schema.js';

package/dist/recipes/action-effects/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const actionEffectsLabelSchema: z.ZodEnum<{
+    writesData: "writesData";
+    sendsMessage: "sendsMessage";
+    spendsMoney: "spendsMoney";
+    deletesData: "deletesData";
+    callsExternal: "callsExternal";
+}>;
+export declare const actionEffectsInputSchema: z.ZodObject<{
+    action: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const actionEffectsResultSchema: 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<{
+        writesData: "writesData";
+        sendsMessage: "sendsMessage";
+        spendsMoney: "spendsMoney";
+        deletesData: "deletesData";
+        callsExternal: "callsExternal";
+    }>>;
+    labels: z.ZodObject<{
+        writesData: 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>;
+        sendsMessage: 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>;
+        spendsMoney: 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>;
+        deletesData: 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>;
+        callsExternal: 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 ActionEffectsLabel = z.infer<typeof actionEffectsLabelSchema>;
+export type ActionEffectsInput = z.infer<typeof actionEffectsInputSchema>;
+export type ActionEffectsResult = z.infer<typeof actionEffectsResultSchema>;

package/dist/recipes/action-effects/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const actionEffectsLabelSchema = z.enum([
+    'writesData',
+    'sendsMessage',
+    'spendsMoney',
+    'deletesData',
+    'callsExternal',
+]);
+export const actionEffectsInputSchema = z.object({
+    action: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const actionEffectsResultSchema = labelsResultSchema.extend({
+    detected: z.array(actionEffectsLabelSchema),
+    labels: z.object({
+        writesData: labelCheckSchema,
+        sendsMessage: labelCheckSchema,
+        spendsMoney: labelCheckSchema,
+        deletesData: labelCheckSchema,
+        callsExternal: labelCheckSchema,
+    }),
+});

package/dist/recipes/action-reversibility/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "action": "Send the drafted outage apology email to the 1,200 customers on the affected-accounts list.",
+    "context": "The draft has been approved. The send goes through the marketing platform, which has no recall feature once a campaign is dispatched.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.85,
+        "confidence": 0.89,
+        "probabilities": { "0": 0.0, "1": 0.01, "2": 0.02, "3": 0.08, "4": 0.89 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/action-reversibility/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ActionReversibilityInput, ActionReversibilityResult } from './schema.js';
+export declare function actionReversibility(input: ActionReversibilityInput, options?: RecipeOptions): Promise<ActionReversibilityResult>;
+export { actionReversibilityInputSchema, actionReversibilityResultSchema, actionReversibilityVerdictSchema, } from './schema.js';
+export type { ActionReversibilityInput, ActionReversibilityResult, ActionReversibilityVerdict, } from './schema.js';

package/dist/recipes/action-reversibility/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { actionReversibilityInputSchema, actionReversibilityResultSchema, actionReversibilityVerdictSchema, } from './schema.js';
+export async function actionReversibility(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = actionReversibilityInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How reversible is action, given any context? Judge whether its effects can be undone, how much work undoing would take, and whether any effect reaches outside the system where it can no longer be recalled. Grade the action as described, not whether it should be taken.', [
+        'The action can be undone in a single step, has no lasting effect, and nothing leaves the system, such as a local edit or a change to a draft.',
+        'The action can be fully undone, but undoing it takes deliberate work such as restoring a backup, reverting several changes, or reissuing a request.',
+        'The action can be mostly undone, but some effects persist afterward, such as notifications already delivered, quota consumed, or records others have already seen.',
+        'The action cannot realistically be undone, though its effects stay within the system, such as overwriting data with no backup or discarding history.',
+        'The action cannot be undone and its effect has already reached the outside world, such as a sent message, a completed payment, a permanent deletion, or a public publication.',
+    ], options);
+    return actionReversibilityResultSchema.parse({
+        ...decision,
+        reversibility: actionReversibilityVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { actionReversibilityInputSchema, actionReversibilityResultSchema, actionReversibilityVerdictSchema, } from './schema.js';

package/dist/recipes/action-reversibility/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const actionReversibilityVerdictSchema: z.ZodEnum<{
+    trivial: "trivial";
+    effortful: "effortful";
+    partial: "partial";
+    practical: "practical";
+    irreversible: "irreversible";
+}>;
+export declare const actionReversibilityInputSchema: z.ZodObject<{
+    action: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const actionReversibilityResultSchema: 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>;
+    reversibility: z.ZodEnum<{
+        trivial: "trivial";
+        effortful: "effortful";
+        partial: "partial";
+        practical: "practical";
+        irreversible: "irreversible";
+    }>;
+}, z.core.$strip>;
+export type ActionReversibilityVerdict = z.infer<typeof actionReversibilityVerdictSchema>;
+export type ActionReversibilityInput = z.infer<typeof actionReversibilityInputSchema>;
+export type ActionReversibilityResult = z.infer<typeof actionReversibilityResultSchema>;

package/dist/recipes/action-reversibility/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const actionReversibilityVerdictSchema = z.enum([
+    'trivial',
+    'effortful',
+    'partial',
+    'practical',
+    'irreversible',
+]);
+export const actionReversibilityInputSchema = z.object({
+    action: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const actionReversibilityResultSchema = scoreResultSchema.extend({
+    reversibility: actionReversibilityVerdictSchema,
+});

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const actionScopeVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
     within_scope: "within_scope";
     additional_work: "additional_work";
-    unclear: "unclear";
 }>;
 export declare const actionScopeInputSchema: z.ZodObject<{
     request: z.ZodString;
@@ -21,15 +21,15 @@ export declare const actionScopeResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
+        unclear: "unclear";
         within_scope: "within_scope";
         additional_work: "additional_work";
-        unclear: "unclear";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
         within_scope: "within_scope";
         additional_work: "additional_work";
-        unclear: "unclear";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type ActionScopeInput = z.infer<typeof actionScopeInputSchema>;

package/dist/recipes/age-appropriateness/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "content": "The two friends raced their bikes down the hill, laughing as the wind whipped past. At the bottom, Maya skidded and scraped her knee, but she grinned and said it was the best ride ever.",
+    "context": "Short story submitted to a reading app for young readers.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 0.21,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.82, "1": 0.15, "2": 0.03, "3": 0.0, "4": 0.0 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/age-appropriateness/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AgeAppropriatenessInput, AgeAppropriatenessResult } from './schema.js';
+export declare function ageAppropriateness(input: AgeAppropriatenessInput, options?: RecipeOptions): Promise<AgeAppropriatenessResult>;
+export { ageAppropriatenessInputSchema, ageAppropriatenessResultSchema, ageAppropriatenessVerdictSchema, } from './schema.js';
+export type { AgeAppropriatenessInput, AgeAppropriatenessResult, AgeAppropriatenessVerdict, } from './schema.js';

package/dist/recipes/age-appropriateness/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { ageAppropriatenessInputSchema, ageAppropriatenessResultSchema, ageAppropriatenessVerdictSchema, } from './schema.js';
+export async function ageAppropriateness(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = ageAppropriatenessInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'What is the youngest general audience for which content is appropriate, given any context? Judge the themes, language, and depictions as written. Ignore the length and quality of the writing.', [
+        'Suitable for all ages, with no coarse language, peril, or mature themes.',
+        'Suitable for older children; may include mild language, mild peril, or cartoonish conflict.',
+        'Suitable for teens; mature themes such as romance, violence, or substance use are handled non-graphically.',
+        'Suitable for mature audiences; includes graphic violence, sexual content, or drug use.',
+        'Suitable for adults only; includes explicit sexual content or extreme depictions.',
+    ], options);
+    return ageAppropriatenessResultSchema.parse({
+        ...decision,
+        rating: ageAppropriatenessVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { ageAppropriatenessInputSchema, ageAppropriatenessResultSchema, ageAppropriatenessVerdictSchema, } from './schema.js';

package/dist/recipes/age-appropriateness/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const ageAppropriatenessVerdictSchema: z.ZodEnum<{
+    everyone: "everyone";
+    children: "children";
+    teens: "teens";
+    mature: "mature";
+    adults: "adults";
+}>;
+export declare const ageAppropriatenessInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ageAppropriatenessResultSchema: 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>;
+    rating: z.ZodEnum<{
+        everyone: "everyone";
+        children: "children";
+        teens: "teens";
+        mature: "mature";
+        adults: "adults";
+    }>;
+}, z.core.$strip>;
+export type AgeAppropriatenessVerdict = z.infer<typeof ageAppropriatenessVerdictSchema>;
+export type AgeAppropriatenessInput = z.infer<typeof ageAppropriatenessInputSchema>;
+export type AgeAppropriatenessResult = z.infer<typeof ageAppropriatenessResultSchema>;

package/dist/recipes/age-appropriateness/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const ageAppropriatenessVerdictSchema = z.enum([
+    'everyone',
+    'children',
+    'teens',
+    'mature',
+    'adults',
+]);
+export const ageAppropriatenessInputSchema = z.object({
+    content: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const ageAppropriatenessResultSchema = scoreResultSchema.extend({
+    rating: ageAppropriatenessVerdictSchema,
+});

package/dist/recipes/alert-actionability/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "alert": "HIGH: payments-gateway 5xx rate is 6.4% over the last 5 minutes (threshold 2%) in prod-eu-west-1. Upstream dependency stripe-proxy is returning 502s for 40% of calls.",
+    "context": "payments-gateway is the public API in front of card processing. stripe-proxy is an internal sidecar that batches calls to Stripe.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.96,
+        "confidence": 0.78,
+        "probabilities": { "0": 0, "1": 0.02, "2": 0.1, "3": 0.78, "4": 0.1 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/alert-actionability/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { AlertActionabilityInput, AlertActionabilityResult } from './schema.js';
+export declare function alertActionability(input: AlertActionabilityInput, options?: RecipeOptions): Promise<AlertActionabilityResult>;
+export { alertActionabilityInputSchema, alertActionabilityResultSchema, alertActionabilityVerdictSchema, } from './schema.js';
+export type { AlertActionabilityInput, AlertActionabilityResult, AlertActionabilityVerdict, } from './schema.js';

package/dist/recipes/alert-actionability/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { alertActionabilityInputSchema, alertActionabilityResultSchema, alertActionabilityVerdictSchema, } from './schema.js';
+export async function alertActionability(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = alertActionabilityInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How actionable is alert for the on-call engineer who receives it? Judge only what the text of alert tells a responder: whether it names an observable symptom, whether it points at a specific component or location, and whether it suggests a concrete first step. Use context only to interpret abbreviations or service names. Ignore formatting, severity labels, and whether the alert is likely to be a true positive.', [
+        'The alert gives the responder nothing to act on: no symptom, no component, and no threshold, such as a bare status code or a heartbeat with no failure described.',
+        "The alert hints that something is wrong but names neither a concrete symptom nor a component, such as 'service degraded' or 'errors detected'.",
+        'The alert names an observable symptom with a measure or threshold, such as an error rate or latency figure, but does not say where it is happening.',
+        'The alert names both the symptom and the specific component, host, region, or dependency involved, so the responder knows where to look first.',
+        'The alert names the symptom, the component, and a concrete first step, link, or runbook the responder can follow immediately.',
+    ], options);
+    return alertActionabilityResultSchema.parse({
+        ...decision,
+        actionability: alertActionabilityVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { alertActionabilityInputSchema, alertActionabilityResultSchema, alertActionabilityVerdictSchema, } from './schema.js';

package/dist/recipes/alert-actionability/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const alertActionabilityVerdictSchema: z.ZodEnum<{
+    noise: "noise";
+    vague: "vague";
+    symptom: "symptom";
+    located: "located";
+    guided: "guided";
+}>;
+export declare const alertActionabilityInputSchema: z.ZodObject<{
+    alert: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const alertActionabilityResultSchema: 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>;
+    actionability: z.ZodEnum<{
+        noise: "noise";
+        vague: "vague";
+        symptom: "symptom";
+        located: "located";
+        guided: "guided";
+    }>;
+}, z.core.$strip>;
+export type AlertActionabilityVerdict = z.infer<typeof alertActionabilityVerdictSchema>;
+export type AlertActionabilityInput = z.infer<typeof alertActionabilityInputSchema>;
+export type AlertActionabilityResult = z.infer<typeof alertActionabilityResultSchema>;

package/dist/recipes/alert-actionability/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const alertActionabilityVerdictSchema = z.enum([
+    'noise',
+    'vague',
+    'symptom',
+    'located',
+    'guided',
+]);
+export const alertActionabilityInputSchema = z.object({
+    alert: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const alertActionabilityResultSchema = scoreResultSchema.extend({
+    actionability: alertActionabilityVerdictSchema,
+});