jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/performance-feedback-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const performanceFeedbackFacetsLabelSchema = z.enum([
+    'mentionsRhythm',
+    'mentionsPitch',
+    'mentionsDynamics',
+    'mentionsTechnique',
+    'mentionsExpression',
+]);
+export const performanceFeedbackFacetsInputSchema = z.object({
+    feedback: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const performanceFeedbackFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(performanceFeedbackFacetsLabelSchema),
+    labels: z.object({
+        mentionsRhythm: labelCheckSchema,
+        mentionsPitch: labelCheckSchema,
+        mentionsDynamics: labelCheckSchema,
+        mentionsTechnique: labelCheckSchema,
+        mentionsExpression: labelCheckSchema,
+    }),
+});

package/dist/recipes/persuasion-technique/demo.json

@@ -0,0 +1,28 @@
+{
+  "input": {
+    "message": "Only 3 seats left at this price, and the offer closes at midnight tonight. Book now before they are gone."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "scarcity",
+        "confidence": 0.91,
+        "probabilities": {
+          "authority": 0,
+          "scarcity": 0.91,
+          "social_proof": 0.02,
+          "reciprocity": 0,
+          "emotional_appeal": 0.04,
+          "none": 0.01,
+          "unclear": 0.02
+        }
+      }
+    }
+  }
+}

package/dist/recipes/persuasion-technique/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PersuasionTechniqueInput, PersuasionTechniqueResult } from './schema.js';
+export declare function persuasionTechnique(input: PersuasionTechniqueInput, options?: RecipeOptions): Promise<PersuasionTechniqueResult>;
+export { persuasionTechniqueInputSchema, persuasionTechniqueResultSchema, persuasionTechniqueVerdictSchema, } from './schema.js';
+export type { PersuasionTechniqueInput, PersuasionTechniqueResult, PersuasionTechniqueVerdict, } from './schema.js';

package/dist/recipes/persuasion-technique/index.js

@@ -0,0 +1,19 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { persuasionTechniqueInputSchema, persuasionTechniqueResultSchema } from './schema.js';
+export async function persuasionTechnique(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = persuasionTechniqueInputSchema.parse(input);
+    const decision = await evaluateChoice(state, "Which persuasion technique, if any, does the wording of message primarily use, given any context? Label the expressed wording only, not the writer's intent or the effect on the reader. Choose the single technique that carries the most weight.", {
+        authority: 'The wording appeals to experts, credentials, official status, or institutional endorsement.',
+        scarcity: 'The wording stresses limited supply, limited time, or exclusivity.',
+        social_proof: 'The wording points to what many others do, choose, or approve of.',
+        reciprocity: 'The wording offers or recalls a favor, gift, or concession to prompt something in return.',
+        emotional_appeal: 'The wording relies on evoking fear, guilt, hope, pride, or another feeling.',
+        none: 'The wording informs or requests plainly without a persuasion technique.',
+        unclear: 'The wording is ambiguous between techniques or depends on context that is not supplied.',
+    }, options);
+    return persuasionTechniqueResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { persuasionTechniqueInputSchema, persuasionTechniqueResultSchema, persuasionTechniqueVerdictSchema, } from './schema.js';

package/dist/recipes/persuasion-technique/schema.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const persuasionTechniqueVerdictSchema: z.ZodEnum<{
+    none: "none";
+    unclear: "unclear";
+    authority: "authority";
+    scarcity: "scarcity";
+    social_proof: "social_proof";
+    reciprocity: "reciprocity";
+    emotional_appeal: "emotional_appeal";
+}>;
+export declare const persuasionTechniqueInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const persuasionTechniqueResultSchema: 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<{
+        none: "none";
+        unclear: "unclear";
+        authority: "authority";
+        scarcity: "scarcity";
+        social_proof: "social_proof";
+        reciprocity: "reciprocity";
+        emotional_appeal: "emotional_appeal";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        none: "none";
+        unclear: "unclear";
+        authority: "authority";
+        scarcity: "scarcity";
+        social_proof: "social_proof";
+        reciprocity: "reciprocity";
+        emotional_appeal: "emotional_appeal";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type PersuasionTechniqueInput = z.infer<typeof persuasionTechniqueInputSchema>;
+export type PersuasionTechniqueResult = z.infer<typeof persuasionTechniqueResultSchema>;
+export type PersuasionTechniqueVerdict = z.infer<typeof persuasionTechniqueVerdictSchema>;

package/dist/recipes/persuasion-technique/schema.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const persuasionTechniqueVerdictSchema = z.enum([
+    'authority',
+    'scarcity',
+    'social_proof',
+    'reciprocity',
+    'emotional_appeal',
+    'none',
+    'unclear',
+]);
+export const persuasionTechniqueInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const persuasionTechniqueResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: persuasionTechniqueVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(persuasionTechniqueVerdictSchema, probability),
+});

package/dist/recipes/phrase-complete/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "recentNotes": "C major. E4 D4 C4 D4 | E4 E4 E4 (half) | D4 D4 E4 D4 | C4 (whole note, held)",
+    "meter": "4/4",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.91 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/phrase-complete/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PhraseCompleteInput, PhraseCompleteResult } from './schema.js';
+export declare function phraseComplete(input: PhraseCompleteInput, options?: RecipeOptions): Promise<PhraseCompleteResult>;
+export { phraseCompleteInputSchema, phraseCompleteResultSchema, phraseCompleteVerdictSchema, } from './schema.js';
+export type { PhraseCompleteInput, PhraseCompleteResult, PhraseCompleteVerdict } from './schema.js';

package/dist/recipes/phrase-complete/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { phraseCompleteInputSchema, phraseCompleteResultSchema } from './schema.js';
+export async function phraseComplete(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = phraseCompleteInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does recentNotes form a complete musical phrase that is ready to cadence or rest, given meter when it is supplied? Judge only the notes and annotations given: whether the final note is long, repeated, or held, whether the line arrives on a stable tone such as the tonic or a chord tone that the text identifies, whether the contour has come down or settled, and whether the length feels like a whole unit. Answer open when the last note is short or unstable, the contour is still rising or mid-sequence, or the line stops mid-bar without a sense of arrival. Do not compute scale membership or beat counts; judge the sense of closure as described.', {
+        true: 'recentNotes ends with a settled arrival: a long, held, or repeated final note on a stable tone, a contour that has come to rest, and a length that reads as a whole unit.',
+        false: 'recentNotes ends in motion: a short or unstable final note, a rising or unfinished contour, or a line that stops mid-bar without a sense of arrival.',
+    }, options);
+    return phraseCompleteResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'complete' : 'open',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { phraseCompleteInputSchema, phraseCompleteResultSchema, phraseCompleteVerdictSchema, } from './schema.js';

package/dist/recipes/phrase-complete/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const phraseCompleteVerdictSchema: z.ZodEnum<{
+    complete: "complete";
+    open: "open";
+}>;
+export declare const phraseCompleteInputSchema: z.ZodObject<{
+    recentNotes: z.ZodString;
+    meter: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const phraseCompleteResultSchema: 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<{
+        complete: "complete";
+        open: "open";
+    }>;
+}, z.core.$strip>;
+export type PhraseCompleteVerdict = z.infer<typeof phraseCompleteVerdictSchema>;
+export type PhraseCompleteInput = z.infer<typeof phraseCompleteInputSchema>;
+export type PhraseCompleteResult = z.infer<typeof phraseCompleteResultSchema>;

package/dist/recipes/phrase-complete/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const phraseCompleteVerdictSchema = z.enum(['complete', 'open']);
+export const phraseCompleteInputSchema = z.object({
+    recentNotes: nonEmptyText,
+    meter: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const phraseCompleteResultSchema = gateResultSchema.extend({
+    verdict: phraseCompleteVerdictSchema,
+});

package/dist/recipes/pii-presence/demo.json

@@ -0,0 +1,11 @@
+{
+  "input": {
+    "text": "Hi, this is Dana Whitfield. My account number is 44-9921 and you can reach me at 555-0142 about the refund.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.96 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/pii-presence/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PiiPresenceInput, PiiPresenceResult } from './schema.js';
+export declare function piiPresence(input: PiiPresenceInput, options?: RecipeOptions): Promise<PiiPresenceResult>;
+export { piiPresenceInputSchema, piiPresenceResultSchema, piiPresenceVerdictSchema, } from './schema.js';
+export type { PiiPresenceInput, PiiPresenceResult, PiiPresenceVerdict } from './schema.js';

package/dist/recipes/pii-presence/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { piiPresenceInputSchema, piiPresenceResultSchema } from './schema.js';
+export async function piiPresence(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = piiPresenceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does text contain personal information that identifies, or could reasonably identify, a specific private individual? Count names combined with contact details, home addresses, government or account identifiers, precise locations, and health or financial details tied to a person. Do not count public organizations, generic roles, or obvious placeholders.', {
+        true: 'The text contains information identifying a specific private individual.',
+        false: 'The text contains no information identifying a specific private individual.',
+    }, options);
+    return piiPresenceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'present' : 'absent',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { piiPresenceInputSchema, piiPresenceResultSchema, piiPresenceVerdictSchema, } from './schema.js';

package/dist/recipes/pii-presence/schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const piiPresenceVerdictSchema: z.ZodEnum<{
+    present: "present";
+    absent: "absent";
+}>;
+export declare const piiPresenceInputSchema: z.ZodObject<{
+    text: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const piiPresenceResultSchema: 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<{
+        present: "present";
+        absent: "absent";
+    }>;
+}, z.core.$strip>;
+export type PiiPresenceVerdict = z.infer<typeof piiPresenceVerdictSchema>;
+export type PiiPresenceInput = z.infer<typeof piiPresenceInputSchema>;
+export type PiiPresenceResult = z.infer<typeof piiPresenceResultSchema>;

package/dist/recipes/pii-presence/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const piiPresenceVerdictSchema = z.enum(['present', 'absent']);
+export const piiPresenceInputSchema = z.object({
+    text: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const piiPresenceResultSchema = gateResultSchema.extend({
+    verdict: piiPresenceVerdictSchema,
+});

package/dist/recipes/plan-completeness/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "task": "Add an Export as CSV button to the reports page. The export must respect the filters currently applied and must work for guest accounts as well as members.",
+    "plan": "1. Add an Export as CSV button beside the existing PDF export control. 2. Create a /reports/export.csv endpoint that serializes the current report query. 3. Pass the active filter parameters from the page to the new endpoint. 4. Add an integration test that exports a filtered report and checks the rows match the filtered view.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 2.06,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.01, "1": 0.05, "2": 0.82, "3": 0.11, "4": 0.01 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/plan-completeness/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PlanCompletenessInput, PlanCompletenessResult } from './schema.js';
+export declare function planCompleteness(input: PlanCompletenessInput, options?: RecipeOptions): Promise<PlanCompletenessResult>;
+export { planCompletenessInputSchema, planCompletenessResultSchema, planCompletenessVerdictSchema, } from './schema.js';
+export type { PlanCompletenessInput, PlanCompletenessResult, PlanCompletenessVerdict, } from './schema.js';

package/dist/recipes/plan-completeness/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { planCompletenessInputSchema, planCompletenessResultSchema, planCompletenessVerdictSchema, } from './schema.js';
+export async function planCompleteness(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = planCompletenessInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How completely does plan cover what task requires? Identify every requirement that task states or clearly implies, then check whether plan contains a step addressing each one and whether it includes a way to verify the outcome. Judge coverage of requirements, not the writing quality or the ordering of steps.', [
+        'The plan addresses none of the requirements in the task, or it targets a different task altogether.',
+        'The plan addresses a minority of the requirements and leaves most of the task unplanned.',
+        'The plan addresses most of the requirements but leaves notable gaps that would leave the task unfinished if it were followed as written.',
+        'The plan addresses every requirement with only minor gaps in detail, but it does not describe how the outcome will be verified.',
+        'The plan addresses every requirement and includes a step that verifies the task has been done.',
+    ], options);
+    return planCompletenessResultSchema.parse({
+        ...decision,
+        completeness: planCompletenessVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { planCompletenessInputSchema, planCompletenessResultSchema, planCompletenessVerdictSchema, } from './schema.js';

package/dist/recipes/plan-completeness/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const planCompletenessVerdictSchema: z.ZodEnum<{
+    none: "none";
+    complete: "complete";
+    partial: "partial";
+    mostly: "mostly";
+    nearly: "nearly";
+}>;
+export declare const planCompletenessInputSchema: z.ZodObject<{
+    task: z.ZodString;
+    plan: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const planCompletenessResultSchema: 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>;
+    completeness: z.ZodEnum<{
+        none: "none";
+        complete: "complete";
+        partial: "partial";
+        mostly: "mostly";
+        nearly: "nearly";
+    }>;
+}, z.core.$strip>;
+export type PlanCompletenessVerdict = z.infer<typeof planCompletenessVerdictSchema>;
+export type PlanCompletenessInput = z.infer<typeof planCompletenessInputSchema>;
+export type PlanCompletenessResult = z.infer<typeof planCompletenessResultSchema>;

package/dist/recipes/plan-completeness/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const planCompletenessVerdictSchema = z.enum([
+    'none',
+    'partial',
+    'mostly',
+    'nearly',
+    'complete',
+]);
+export const planCompletenessInputSchema = z.object({
+    task: nonEmptyText,
+    plan: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const planCompletenessResultSchema = scoreResultSchema.extend({
+    completeness: planCompletenessVerdictSchema,
+});

package/dist/recipes/policy-compliance/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "expense": "Team dinner on Thursday for 4 engineers at a steakhouse after the release. Included two bottles of wine. Total $412, paid on my personal card, receipt attached. No client was present.",
+    "policy": "Meals: Team meals are reimbursable when approved in advance by the manager and when they mark a project milestone. Alcohol is reimbursable only at client-facing events. Meals over $75 per person require a manager's written approval before submission. Receipts are required for any expense over $25.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.09 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/policy-compliance/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PolicyComplianceInput, PolicyComplianceResult } from './schema.js';
+export declare function policyCompliance(input: PolicyComplianceInput, options?: RecipeOptions): Promise<PolicyComplianceResult>;
+export { policyComplianceInputSchema, policyComplianceResultSchema, policyComplianceVerdictSchema, } from './schema.js';
+export type { PolicyComplianceInput, PolicyComplianceResult, PolicyComplianceVerdict, } from './schema.js';

package/dist/recipes/policy-compliance/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { policyComplianceInputSchema, policyComplianceResultSchema } from './schema.js';
+export async function policyCompliance(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = policyComplianceInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Read the expense description and the written policy. Decide whether the expense, as described, complies with every rule in the policy that applies to it. An expense is noncompliant when the description states a fact that a policy rule forbids or when it omits something the policy explicitly requires for that kind of expense. Judge only the described facts against the written rules; do not assume facts that are not stated and do not apply rules the policy does not contain.', {
+        true: 'Nothing in the expense description contradicts an applicable rule in the policy, and every requirement the policy states for this kind of expense is met by the description.',
+        false: 'The expense description states a fact that an applicable policy rule forbids, or omits a condition the policy explicitly requires for this kind of expense.',
+    }, options);
+    return policyComplianceResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'compliant' : 'noncompliant',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { policyComplianceInputSchema, policyComplianceResultSchema, policyComplianceVerdictSchema, } from './schema.js';

package/dist/recipes/policy-compliance/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const policyComplianceVerdictSchema: z.ZodEnum<{
+    compliant: "compliant";
+    noncompliant: "noncompliant";
+}>;
+export declare const policyComplianceInputSchema: z.ZodObject<{
+    expense: z.ZodString;
+    policy: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const policyComplianceResultSchema: 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<{
+        compliant: "compliant";
+        noncompliant: "noncompliant";
+    }>;
+}, z.core.$strip>;
+export type PolicyComplianceVerdict = z.infer<typeof policyComplianceVerdictSchema>;
+export type PolicyComplianceInput = z.infer<typeof policyComplianceInputSchema>;
+export type PolicyComplianceResult = z.infer<typeof policyComplianceResultSchema>;

package/dist/recipes/policy-compliance/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const policyComplianceVerdictSchema = z.enum(['compliant', 'noncompliant']);
+export const policyComplianceInputSchema = z.object({
+    expense: nonEmptyText,
+    policy: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const policyComplianceResultSchema = gateResultSchema.extend({
+    verdict: policyComplianceVerdictSchema,
+});

package/dist/recipes/policy-severity/demo.json

@@ -0,0 +1,19 @@
+{
+  "input": {
+    "content": "If you buy from this seller you deserve to get scammed, idiot. Everyone knows their address is 14 Elm Street, go tell them yourself.",
+    "policy": "Community posts may criticize sellers and products. Posts must not insult other members, and must not share a private individual's home address or other personal contact details.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.02,
+        "confidence": 0.82,
+        "probabilities": { "0": 0.01, "1": 0.02, "2": 0.1, "3": 0.82, "4": 0.05 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/policy-severity/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PolicySeverityInput, PolicySeverityResult } from './schema.js';
+export declare function policySeverity(input: PolicySeverityInput, options?: RecipeOptions): Promise<PolicySeverityResult>;
+export { policySeverityInputSchema, policySeverityResultSchema, policySeverityVerdictSchema, } from './schema.js';
+export type { PolicySeverityInput, PolicySeverityResult, PolicySeverityVerdict } from './schema.js';

package/dist/recipes/policy-severity/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { policySeverityInputSchema, policySeverityResultSchema, policySeverityVerdictSchema, } from './schema.js';
+export async function policySeverity(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = policySeverityInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How severely does content violate policy? Judge only against the rules stated in policy. Do not apply rules it does not state.', [
+        'The content does not violate the policy.',
+        'A borderline or technical violation with negligible potential for harm.',
+        'A clear violation with limited potential for harm.',
+        'A clear violation with substantial potential for harm to a person or group.',
+        'A flagrant violation with severe or imminent potential for harm.',
+    ], options);
+    return policySeverityResultSchema.parse({
+        ...decision,
+        severity: policySeverityVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { policySeverityInputSchema, policySeverityResultSchema, policySeverityVerdictSchema, } from './schema.js';

package/dist/recipes/policy-severity/schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const policySeverityVerdictSchema: z.ZodEnum<{
+    none: "none";
+    moderate: "moderate";
+    minor: "minor";
+    serious: "serious";
+    severe: "severe";
+}>;
+export declare const policySeverityInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    policy: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const policySeverityResultSchema: 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>;
+    severity: z.ZodEnum<{
+        none: "none";
+        moderate: "moderate";
+        minor: "minor";
+        serious: "serious";
+        severe: "severe";
+    }>;
+}, z.core.$strip>;
+export type PolicySeverityVerdict = z.infer<typeof policySeverityVerdictSchema>;
+export type PolicySeverityInput = z.infer<typeof policySeverityInputSchema>;
+export type PolicySeverityResult = z.infer<typeof policySeverityResultSchema>;

package/dist/recipes/policy-severity/schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const policySeverityVerdictSchema = z.enum([
+    'none',
+    'minor',
+    'moderate',
+    'serious',
+    'severe',
+]);
+export const policySeverityInputSchema = z.object({
+    content: nonEmptyText,
+    policy: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const policySeverityResultSchema = scoreResultSchema.extend({
+    severity: policySeverityVerdictSchema,
+});

package/dist/recipes/politeness-level/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "message": "Hi Priya, thanks for turning this around so quickly. When you have a moment, could you also attach the updated invoice? No rush at all.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.13,
+        "confidence": 0.81,
+        "probabilities": { "0": 0.0, "1": 0.0, "2": 0.03, "3": 0.81, "4": 0.16 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/politeness-level/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { PolitenessLevelInput, PolitenessLevelResult } from './schema.js';
+export declare function politenessLevel(input: PolitenessLevelInput, options?: RecipeOptions): Promise<PolitenessLevelResult>;
+export { politenessLevelInputSchema, politenessLevelResultSchema, politenessLevelVerdictSchema, } from './schema.js';
+export type { PolitenessLevelInput, PolitenessLevelResult, PolitenessLevelVerdict, } from './schema.js';