jev-recipes 0.5.1 → 0.5.3

package/dist/catalog/generated/metadata.js

@@ -158,6 +158,10 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to check who said a statement in a transcript or source excerpt, separately from whether it is true.',
         related: [
+            {
+                id: 'causal-attribution',
+                reason: 'Use causal-attribution to classify the kind of cause in an explanation, rather than who made it.',
+            },
             {
                 id: 'citation-match',
                 reason: 'Use citation-match to check which passages support a claim, rather than who made it.',
@@ -220,6 +224,42 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'causal-attribution',
+        title: 'Identify personal and situational explanations',
+        description: 'Label whether an explanation attributes a specified behavior to the person, circumstances, both, or gives no cause.',
+        category: 'conversation',
+        tags: [
+            'psychology',
+            'behavior',
+            'causal attribution',
+            'personal cause',
+            'situational cause',
+            'dispositional',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels the supplied explanation, not the actual cause, blame, or a psychological trait of the actor.',
+            'Personal and situational refer to the focal actor, not the speaker or whoever is named in a cause.',
+            'A personal attribution alone does not establish bias or a fundamental attribution error.',
+        ],
+        useWhen: 'You need to label whether an explanation points to the person, the situation, or both.',
+        related: [
+            {
+                id: 'attribution-match',
+                reason: 'Use attribution-match to check who made or endorsed a statement, rather than what kind of cause it gives.',
+            },
+            {
+                id: 'motivation-source',
+                reason: 'Use motivation-source to distinguish enjoyment of an activity from pursuing a separate outcome in a stated reason.',
+            },
+            {
+                id: 'verify',
+                reason: 'Use verify to assess supplied evidence for a causal claim; causal-attribution does not establish causation.',
+            },
+        ],
+    },
     {
         id: 'certainty-match',
         title: 'Check certainty wording',
@@ -353,6 +393,7 @@ export const recipeMetadata = [
         description: 'Label whether a response affirms, denies, mixes positions on, or does not address a supplied claim.',
         category: 'answer-quality',
         tags: [
+            'psychology',
             'claim',
             'stance',
             'agreement',
@@ -731,7 +772,7 @@ export const recipeMetadata = [
         title: 'Detect expressed frustration',
         description: 'Does message express frustration or dissatisfaction in its wording?',
         category: 'support',
-        tags: ['support', 'frustration', 'signal'],
+        tags: ['psychology', 'support', 'frustration', 'signal'],
         limitations: [
             'Classifies expressed language only. It does not diagnose emotions or determine customer importance or entitlement.',
         ],
@@ -743,6 +784,29 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'game-action',
+        title: 'Choose a game action from JSON',
+        description: 'Send game state, player state, and available actions as JSON; receive the original selected action with Jev confidence and probabilities.',
+        category: 'workflow',
+        tags: ['gameplay', 'game', 'agnostic', 'JSON', 'actions', 'automatic IDs', 'simulation'],
+        limitations: [
+            'Confidence and probabilities describe the Jev decision, not a measured probability of winning.',
+            'The full action list is sent in one logical request. Provider request limits still apply.',
+            'Internal action labels belong to the current call; existing game IDs remain in the returned action.',
+        ],
+        useWhen: 'Your game already supplies JSON state and actions, and you want Jev to choose an action without formatting descriptions or assigning IDs.',
+        related: [
+            {
+                id: 'choose-action',
+                reason: 'Use choose-action for text-based rules and state, caller-named actions, and confidence-based review handling.',
+            },
+            {
+                id: 'checkers-move',
+                reason: 'Use checkers-move for its American/English checkers board format and built-in checkers instructions.',
+            },
+        ],
+    },
     {
         id: 'handoff',
         title: 'Check handoff rules',
@@ -844,6 +908,40 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'issue-recurrence',
+        title: 'Check whether an issue returned',
+        description: 'Label a reported issue as new, ongoing without resolution, or returned after reported recovery.',
+        category: 'support',
+        tags: [
+            'support',
+            'issue came back',
+            'recurring issue',
+            'reopened ticket',
+            'never fixed',
+            'reported recovery',
+        ],
+        limitations: [
+            'Classifies the supplied customer reports; it does not verify system health or prove a common root cause.',
+            'Missing history does not mean new, and a ticket closure or attempted fix does not prove recovery.',
+            'Callers supply chronology and issue identity; the recipe does not fetch history or update tickets.',
+        ],
+        useWhen: 'You need to distinguish a new problem, one that never stopped, and an issue that came back after recovery.',
+        related: [
+            {
+                id: 'resolution-check',
+                reason: 'Use resolution-check to check whether the current message reports resolution.',
+            },
+            {
+                id: 'ticket-match',
+                reason: 'Use ticket-match to compare whether two reports concern the same underlying issue.',
+            },
+            {
+                id: 'repeated-attempt',
+                reason: 'Use repeated-attempt to check whether a proposed troubleshooting step repeats an earlier attempt.',
+            },
+        ],
+    },
     {
         id: 'memory-relation',
         title: 'Compare a new fact with memory',
@@ -872,12 +970,50 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to identify the narrowest supported scope of a fact or preference.',
         related: [
+            {
+                id: 'memory-subject',
+                reason: 'Use memory-subject to identify whom a candidate memory describes before assessing its scope.',
+            },
             {
                 id: 'preference-kind',
                 reason: 'Use preference-kind to distinguish ongoing preferences from temporary instructions.',
             },
         ],
     },
+    {
+        id: 'memory-subject',
+        title: 'Identify whom a memory describes',
+        description: 'Label whether one candidate memory describes the user, someone else, or a group including the user.',
+        category: 'memory',
+        tags: [
+            'memory',
+            'whose memory',
+            'someone else',
+            'subject attribution',
+            'personalization',
+            'quoted speaker',
+        ],
+        limitations: [
+            'Requires an identified user and enough speaker context to resolve references; it does not infer a user from an account or session.',
+            'Subject attribution does not establish truth, actuality, permanence, consent, or permission to store a memory.',
+            'Classifies one atomic statement; it does not extract, split, rewrite, or persist memories.',
+        ],
+        useWhen: 'You need to avoid treating a fact about someone else as a fact about the user.',
+        related: [
+            {
+                id: 'memory-scope',
+                reason: 'Use memory-scope to identify where a fact applies after identifying whom it describes.',
+            },
+            {
+                id: 'attribution-match',
+                reason: 'Use attribution-match to check who said or endorsed a statement, rather than whom the statement describes.',
+            },
+            {
+                id: 'preference-kind',
+                reason: 'Use preference-kind to distinguish a lasting preference from a temporary instruction.',
+            },
+        ],
+    },
     {
         id: 'memory-value',
         title: 'Assess a candidate memory',
@@ -892,6 +1028,78 @@ export const recipeMetadata = [
             { id: 'memory-scope', reason: 'Use memory-scope to determine where a fact applies.' },
         ],
     },
+    {
+        id: 'motivation-source',
+        title: 'Identify a stated source of motivation',
+        description: 'Label a stated reason for an activity as intrinsic enjoyment, a separate outcome, both, or not stated.',
+        category: 'conversation',
+        tags: [
+            'psychology',
+            'behavior',
+            'motivation',
+            'intrinsic',
+            'extrinsic',
+            'stated reason',
+            'self-determination',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels expressed or reported reasons, not hidden motives, sincerity, or a psychological profile.',
+            'Extrinsic reasons can be internalized and freely chosen; this label does not measure autonomy or distinguish its subtypes.',
+            'An AI response describing a motive does not establish that the model has that motive.',
+        ],
+        useWhen: 'You need to classify a stated reason for an activity as enjoyment of doing it or pursuit of a separate outcome.',
+        related: [
+            {
+                id: 'causal-attribution',
+                reason: 'Use causal-attribution to distinguish personal from situational explanations of behavior.',
+            },
+            {
+                id: 'preference-kind',
+                reason: 'Use preference-kind to distinguish preferences, facts, and temporary requests rather than reasons for an activity.',
+            },
+            {
+                id: 'claim-stance',
+                reason: 'Use claim-stance to label agreement with a specified claim instead of classifying the reason for acting.',
+            },
+        ],
+    },
+    {
+        id: 'outcome-framing',
+        title: 'Identify gain and loss framing',
+        description: 'Label whether wording presents a specified outcome through gains, losses, both, or neither.',
+        category: 'conversation',
+        tags: [
+            'psychology',
+            'behavior',
+            'gain loss',
+            'outcome framing',
+            'decision framing',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels wording about one supplied outcome; it does not calculate utility or verify equivalence between descriptions.',
+            'A frame label does not establish loss aversion, a cognitive bias, or a causal effect on choices.',
+            'A bare amount can be neutral even when the caller knows it represents an actual gain or loss.',
+        ],
+        useWhen: 'You need to label gain and loss wording in a decision prompt or research stimulus.',
+        related: [
+            {
+                id: 'question-leading',
+                reason: 'Use question-leading to assess pressure toward a supplied answer, rather than gain or loss framing.',
+            },
+            {
+                id: 'question-assumption',
+                reason: 'Use question-assumption to check whether a question takes a specified claim for granted.',
+            },
+            {
+                id: 'choose-action',
+                reason: 'Use choose-action to select among supplied eligible actions; outcome-framing only labels wording.',
+            },
+        ],
+    },
     {
         id: 'passage-duplicate',
         title: 'Compare passages for duplication',
@@ -920,6 +1128,10 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to distinguish an ongoing preference from a fact or temporary request.',
         related: [
+            {
+                id: 'motivation-source',
+                reason: 'Use motivation-source to classify a stated reason for an activity rather than the kind of statement.',
+            },
             {
                 id: 'memory-scope',
                 reason: 'Use memory-scope to identify the supported scope of that preference.',
@@ -977,12 +1189,46 @@ export const recipeMetadata = [
             },
         ],
     },
+    {
+        id: 'question-assumption',
+        title: 'Check what a question takes for granted',
+        description: 'Label whether a question takes a supplied claim for granted or leaves that claim open.',
+        category: 'conversation',
+        tags: [
+            'psychology',
+            'presupposition',
+            'loaded question',
+            'takes for granted',
+            'question assumption',
+            'prompt wording',
+            'annotation',
+            'alignment-research',
+        ],
+        limitations: [
+            'Labels wording relative to one supplied claim; it does not determine truth or author intent.',
+            'Not assumed does not establish that a question is neutral or free of other assumptions.',
+            'Effects on respondents or models require controlled comparisons; these labels alone are not causal evidence.',
+        ],
+        useWhen: 'You need to identify a specific assumption in a question before using it in a conversation, survey, or evaluation.',
+        related: [
+            {
+                id: 'question-leading',
+                reason: 'Use question-leading to check pressure toward or away from an answer, which is different from assuming a claim.',
+            },
+            {
+                id: 'claim-stance',
+                reason: 'Use claim-stance to label affirmation or denial of a claim in a response.',
+            },
+            { id: 'verify', reason: 'Use verify to assess evidential support for the claim itself.' },
+        ],
+    },
     {
         id: 'question-leading',
         title: 'Check whether a question steers an answer',
         description: "Label whether a question's wording favors, disfavors, or stays neutral toward a proposed answer.",
         category: 'conversation',
         tags: [
+            'psychology',
             'leading question',
             'wording',
             'answer pressure',
@@ -998,6 +1244,14 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to check leading questions or answer pressure in a survey, interview, or evaluation prompt.',
         related: [
+            {
+                id: 'outcome-framing',
+                reason: 'Use outcome-framing to label gains and losses in wording about a specified outcome.',
+            },
+            {
+                id: 'question-assumption',
+                reason: 'Use question-assumption to check whether a question takes a specific claim for granted.',
+            },
             {
                 id: 'query-specificity',
                 reason: 'Use query-specificity to check whether an information need is focused and unambiguous.',
@@ -1122,6 +1376,10 @@ export const recipeMetadata = [
         ],
         useWhen: 'You need to know whether the customer reports that an issue is resolved.',
         related: [
+            {
+                id: 'issue-recurrence',
+                reason: 'Use issue-recurrence to distinguish a first occurrence, an ongoing issue, and a return after reported recovery.',
+            },
             {
                 id: 'step-complete',
                 reason: 'Use step-complete to assess evidence against a supplied completion condition.',
@@ -1512,6 +1770,7 @@ export const recipeMetadata = [
         description: 'Label categorical, qualified, or unresolved wording about a supplied claim without inferring internal confidence.',
         category: 'answer-quality',
         tags: [
+            'psychology',
             'uncertainty',
             'certainty',
             'hedging',

package/dist/catalog/generated/names.d.ts

@@ -1 +1 @@
-export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "cache-match", "cancellation-check", "certainty-match", "change-meaning", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "handoff", "incident-match", "instruction-conflict", "instruction-fit", "intent-change", "issue-impact", "memory-relation", "memory-scope", "memory-value", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "question-leading", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "take-turn", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];
+export declare const recipeNames: readonly ["action-scope", "answer-consistency", "answer-coverage", "answer-invalidation", "answer-relevance", "answerability", "argument-fit", "attempted-step", "attribution-match", "audience-fit", "cache-match", "cancellation-check", "causal-attribution", "certainty-match", "change-meaning", "checkers-move", "choose-action", "citation-match", "citation-needed", "claim-stance", "clarify", "confirmation-match", "constraint-strength", "context-role", "correction-target", "document-role", "draft-compare", "evaluation-mention", "evidence-conflict", "evidence-independence", "evidence-novelty", "fact-stability", "failure-kind", "feedback-kind", "field-select", "followup-link", "freshness-needed", "frustration-signal", "game-action", "handoff", "incident-match", "instruction-conflict", "instruction-fit", "intent-change", "issue-impact", "issue-recurrence", "memory-relation", "memory-scope", "memory-subject", "memory-value", "motivation-source", "outcome-framing", "passage-duplicate", "preference-kind", "promise-check", "query-equivalence", "query-specificity", "question-assumption", "question-leading", "reference-resolve", "repeated-attempt", "reply-template-match", "requirement-testability", "rerank", "resolution-check", "response-needed", "response-refusal", "result-outcome", "result-usefulness", "retrieval-needed", "route", "source-applicability", "step-complete", "step-progress", "summary-coverage", "take-turn", "task-dependency", "task-duplicate", "ticket-match", "tone-check", "tool-fit", "topic-shift", "troubleshooting-fit", "turn-intent", "uncertainty-expression", "urgency-signal", "verify", "workaround-fit"];

package/dist/catalog/generated/names.js

@@ -12,6 +12,7 @@ export const recipeNames = [
     'audience-fit',
     'cache-match',
     'cancellation-check',
+    'causal-attribution',
     'certainty-match',
     'change-meaning',
     'checkers-move',
@@ -37,20 +38,26 @@ export const recipeNames = [
     'followup-link',
     'freshness-needed',
     'frustration-signal',
+    'game-action',
     'handoff',
     'incident-match',
     'instruction-conflict',
     'instruction-fit',
     'intent-change',
     'issue-impact',
+    'issue-recurrence',
     'memory-relation',
     'memory-scope',
+    'memory-subject',
     'memory-value',
+    'motivation-source',
+    'outcome-framing',
     'passage-duplicate',
     'preference-kind',
     'promise-check',
     'query-equivalence',
     'query-specificity',
+    'question-assumption',
     'question-leading',
     'reference-resolve',
     'repeated-attempt',

package/dist/catalog/schema.d.ts

@@ -12,6 +12,7 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "audience-fit": "audience-fit";
     "cache-match": "cache-match";
     "cancellation-check": "cancellation-check";
+    "causal-attribution": "causal-attribution";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
     "checkers-move": "checkers-move";
@@ -37,20 +38,26 @@ export declare const recipeNameSchema: z.ZodEnum<{
     "followup-link": "followup-link";
     "freshness-needed": "freshness-needed";
     "frustration-signal": "frustration-signal";
+    "game-action": "game-action";
     handoff: "handoff";
     "incident-match": "incident-match";
     "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
+    "issue-recurrence": "issue-recurrence";
     "memory-relation": "memory-relation";
     "memory-scope": "memory-scope";
+    "memory-subject": "memory-subject";
     "memory-value": "memory-value";
+    "motivation-source": "motivation-source";
+    "outcome-framing": "outcome-framing";
     "passage-duplicate": "passage-duplicate";
     "preference-kind": "preference-kind";
     "promise-check": "promise-check";
     "query-equivalence": "query-equivalence";
     "query-specificity": "query-specificity";
+    "question-assumption": "question-assumption";
     "question-leading": "question-leading";
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";

package/dist/cli/schema.d.ts

@@ -15,6 +15,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "audience-fit": "audience-fit";
     "cache-match": "cache-match";
     "cancellation-check": "cancellation-check";
+    "causal-attribution": "causal-attribution";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
     "checkers-move": "checkers-move";
@@ -40,20 +41,26 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "followup-link": "followup-link";
     "freshness-needed": "freshness-needed";
     "frustration-signal": "frustration-signal";
+    "game-action": "game-action";
     handoff: "handoff";
     "incident-match": "incident-match";
     "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
+    "issue-recurrence": "issue-recurrence";
     "memory-relation": "memory-relation";
     "memory-scope": "memory-scope";
+    "memory-subject": "memory-subject";
     "memory-value": "memory-value";
+    "motivation-source": "motivation-source";
+    "outcome-framing": "outcome-framing";
     "passage-duplicate": "passage-duplicate";
     "preference-kind": "preference-kind";
     "promise-check": "promise-check";
     "query-equivalence": "query-equivalence";
     "query-specificity": "query-specificity";
+    "question-assumption": "question-assumption";
     "question-leading": "question-leading";
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
@@ -100,6 +107,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "audience-fit": "audience-fit";
     "cache-match": "cache-match";
     "cancellation-check": "cancellation-check";
+    "causal-attribution": "causal-attribution";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
     "checkers-move": "checkers-move";
@@ -125,20 +133,26 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "followup-link": "followup-link";
     "freshness-needed": "freshness-needed";
     "frustration-signal": "frustration-signal";
+    "game-action": "game-action";
     handoff: "handoff";
     "incident-match": "incident-match";
     "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
+    "issue-recurrence": "issue-recurrence";
     "memory-relation": "memory-relation";
     "memory-scope": "memory-scope";
+    "memory-subject": "memory-subject";
     "memory-value": "memory-value";
+    "motivation-source": "motivation-source";
+    "outcome-framing": "outcome-framing";
     "passage-duplicate": "passage-duplicate";
     "preference-kind": "preference-kind";
     "promise-check": "promise-check";
     "query-equivalence": "query-equivalence";
     "query-specificity": "query-specificity";
+    "question-assumption": "question-assumption";
     "question-leading": "question-leading";
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";
@@ -182,6 +196,7 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "audience-fit": "audience-fit";
     "cache-match": "cache-match";
     "cancellation-check": "cancellation-check";
+    "causal-attribution": "causal-attribution";
     "certainty-match": "certainty-match";
     "change-meaning": "change-meaning";
     "checkers-move": "checkers-move";
@@ -207,20 +222,26 @@ export declare const commandArgumentsSchema: z.ZodUnion<readonly [z.ZodTuple<[z.
     "followup-link": "followup-link";
     "freshness-needed": "freshness-needed";
     "frustration-signal": "frustration-signal";
+    "game-action": "game-action";
     handoff: "handoff";
     "incident-match": "incident-match";
     "instruction-conflict": "instruction-conflict";
     "instruction-fit": "instruction-fit";
     "intent-change": "intent-change";
     "issue-impact": "issue-impact";
+    "issue-recurrence": "issue-recurrence";
     "memory-relation": "memory-relation";
     "memory-scope": "memory-scope";
+    "memory-subject": "memory-subject";
     "memory-value": "memory-value";
+    "motivation-source": "motivation-source";
+    "outcome-framing": "outcome-framing";
     "passage-duplicate": "passage-duplicate";
     "preference-kind": "preference-kind";
     "promise-check": "promise-check";
     "query-equivalence": "query-equivalence";
     "query-specificity": "query-specificity";
+    "question-assumption": "question-assumption";
     "question-leading": "question-leading";
     "reference-resolve": "reference-resolve";
     "repeated-attempt": "repeated-attempt";

package/dist/recipes/causal-attribution/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "behavior": "Alex arrived late to the meeting.",
+    "explanation": "Alex arrived late because the train was cancelled."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "situational",
+        "confidence": 0.96,
+        "probabilities": {
+          "personal": 0.01,
+          "situational": 0.96,
+          "mixed": 0.01,
+          "none": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/causal-attribution/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { CausalAttributionInput, CausalAttributionResult } from './schema.js';
+export declare function causalAttribution(input: CausalAttributionInput, options?: RecipeOptions): Promise<CausalAttributionResult>;
+export { causalAttributionInputSchema, causalAttributionResultSchema, causalAttributionVerdictSchema, } from './schema.js';
+export type { CausalAttributionInput, CausalAttributionResult, CausalAttributionVerdict, } from './schema.js';

package/dist/recipes/causal-attribution/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { causalAttributionInputSchema, causalAttributionResultSchema } from './schema.js';
+export async function causalAttribution(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = causalAttributionInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'How does explanation account for the specified behavior of the focal actor? Classify causes presented in the explanation, not the true cause or whether the explanation is justified. Personal attribution assigns the behavior to the focal actor\'s traits, abilities, effort, choices, motives, or internal state. Situational attribution assigns it to circumstances outside that actor, such as resources, instructions, task difficulty, chance, or other people\'s actions. Internal causes need not be permanent or controllable; external causes need not be beyond anyone\'s control. For Alex arriving late, "Alex made little effort to leave on time" is personal and "The train was cancelled" is situational. Choose mixed only when both types are offered as contributing causes. An unresolved alternative such as "either Alex forgot or the train failed" is unclear, not mixed. Do not count a negated, rejected, or merely asked-about cause as an offered explanation; classify any remaining offered cause. A quoted explanation can be classified as the attribution made by the quoted source without treating the reporter as endorsing it. Choose none when the focal behavior is identified but no cause is offered, including a description only, an admission of not knowing, or only rejected causes. Choose unclear for missing focal behavior, unresolved actors or references, incompatible claims without correction, or no separable attribution. Context resolves references but must not supply a cause absent from explanation. Do not infer blame, fault, intent, a stable personality trait, or an attribution error from the label.', {
+        personal: 'The explanation attributes the behavior to properties, choices, effort, motives, or internal states of the focal actor.',
+        situational: 'The explanation attributes the behavior to circumstances outside the focal actor.',
+        mixed: 'Both personal and situational factors are offered as contributing causes.',
+        none: 'The focal behavior is clear but the text offers no cause for it.',
+        unclear: 'Missing references, unresolved alternatives, contradictory attribution, or ambiguous scope prevents classification.',
+    }, options);
+    return causalAttributionResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { causalAttributionInputSchema, causalAttributionResultSchema, causalAttributionVerdictSchema, } from './schema.js';

package/dist/recipes/causal-attribution/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const causalAttributionVerdictSchema: z.ZodEnum<{
+    none: "none";
+    unclear: "unclear";
+    personal: "personal";
+    situational: "situational";
+    mixed: "mixed";
+}>;
+export declare const causalAttributionInputSchema: z.ZodObject<{
+    behavior: z.ZodString;
+    explanation: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const causalAttributionResultSchema: 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";
+        personal: "personal";
+        situational: "situational";
+        mixed: "mixed";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        none: "none";
+        unclear: "unclear";
+        personal: "personal";
+        situational: "situational";
+        mixed: "mixed";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type CausalAttributionInput = z.infer<typeof causalAttributionInputSchema>;
+export type CausalAttributionResult = z.infer<typeof causalAttributionResultSchema>;
+export type CausalAttributionVerdict = z.infer<typeof causalAttributionVerdictSchema>;