jev-recipes 0.2.0 → 0.4.0

package/dist/recipes/query-equivalence/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const queryEquivalenceVerdictSchema: z.ZodEnum<{
+    related: "related";
     unclear: "unclear";
     equivalent: "equivalent";
-    related: "related";
     different: "different";
 }>;
 export declare const queryEquivalenceInputSchema: z.ZodObject<{
@@ -22,16 +22,16 @@ export declare const queryEquivalenceResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
+        related: "related";
         unclear: "unclear";
         equivalent: "equivalent";
-        related: "related";
         different: "different";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
+        related: "related";
         unclear: "unclear";
         equivalent: "equivalent";
-        related: "related";
         different: "different";
     }>, z.ZodNumber>;
 }, z.core.$strip>;

package/dist/recipes/requirement-testability/demo.json

@@ -0,0 +1,24 @@
+{
+  "input": {
+    "requirement": "The dashboard should load quickly."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "not_testable",
+        "confidence": 0.96,
+        "probabilities": {
+          "testable": 0.02,
+          "not_testable": 0.96,
+          "unclear": 0.02
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { RequirementTestabilityInput, RequirementTestabilityResult } from './schema.js';
+export declare function requirementTestability(input: RequirementTestabilityInput, options?: RecipeOptions): Promise<RequirementTestabilityResult>;
+export { requirementTestabilityInputSchema, requirementTestabilityResultSchema, requirementTestabilityVerdictSchema, } from './schema.js';
+export type { RequirementTestabilityInput, RequirementTestabilityResult, RequirementTestabilityVerdict, } from './schema.js';

package/dist/recipes/requirement-testability/index.js

@@ -0,0 +1,15 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { requirementTestabilityInputSchema, requirementTestabilityResultSchema } from './schema.js';
+export async function requirementTestability(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = requirementTestabilityInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do requirement and context define an observable way to distinguish meeting this requirement from failing it? Judge the stated acceptance criteria, not feasibility, current implementation, or whether it already passes. A criterion can be qualitative if the supplied definitions make the expected observation clear. Do not invent thresholds, measurement conditions, definitions, or a test procedure. Choose not_testable when the intended requirement is understandable but its completion criteria remain subjective or unbounded; choose unclear when the requirement itself or a reference cannot be interpreted.', {
+        testable: 'The supplied requirement and definitions establish observable conditions for distinguishing pass from fail.',
+        not_testable: 'The intended requirement is understandable, but the supplied criteria do not define an observable pass/fail boundary.',
+        unclear: 'The requirement or its references are too ambiguous to determine what would need to be observed.',
+    }, options);
+    return requirementTestabilityResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { requirementTestabilityInputSchema, requirementTestabilityResultSchema, requirementTestabilityVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+export declare const requirementTestabilityVerdictSchema: z.ZodEnum<{
+    testable: "testable";
+    unclear: "unclear";
+    not_testable: "not_testable";
+}>;
+export declare const requirementTestabilityInputSchema: z.ZodObject<{
+    requirement: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const requirementTestabilityResultSchema: 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<{
+        testable: "testable";
+        unclear: "unclear";
+        not_testable: "not_testable";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        testable: "testable";
+        unclear: "unclear";
+        not_testable: "not_testable";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type RequirementTestabilityInput = z.infer<typeof requirementTestabilityInputSchema>;
+export type RequirementTestabilityResult = z.infer<typeof requirementTestabilityResultSchema>;
+export type RequirementTestabilityVerdict = z.infer<typeof requirementTestabilityVerdictSchema>;

package/dist/recipes/requirement-testability/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const requirementTestabilityVerdictSchema = z.enum(['testable', 'not_testable', 'unclear']);
+export const requirementTestabilityInputSchema = z.object({
+    requirement: nonEmptyText.describe('One requirement whose completion criteria need review.'),
+    context: nonEmptyText
+        .describe('Supplied definitions, acceptance criteria, and observation conditions.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const requirementTestabilityResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: requirementTestabilityVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(requirementTestabilityVerdictSchema, probability),
+});

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const resultOutcomeVerdictSchema: z.ZodEnum<{
     success: "success";
+    failure: "failure";
     unclear: "unclear";
     partial_success: "partial_success";
-    failure: "failure";
 }>;
 export declare const resultOutcomeInputSchema: z.ZodObject<{
     task: z.ZodString;
@@ -22,16 +22,16 @@ export declare const resultOutcomeResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         success: "success";
+        failure: "failure";
         unclear: "unclear";
         partial_success: "partial_success";
-        failure: "failure";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         success: "success";
+        failure: "failure";
         unclear: "unclear";
         partial_success: "partial_success";
-        failure: "failure";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type ResultOutcomeInput = z.infer<typeof resultOutcomeInputSchema>;

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

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

package/dist/recipes/step-progress/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const stepProgressVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
     progress: "progress";
+    unclear: "unclear";
     no_progress: "no_progress";
     setback: "setback";
 }>;
@@ -22,15 +22,15 @@ export declare const stepProgressResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
         progress: "progress";
+        unclear: "unclear";
         no_progress: "no_progress";
         setback: "setback";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
         progress: "progress";
+        unclear: "unclear";
         no_progress: "no_progress";
         setback: "setback";
     }>, z.ZodNumber>;

package/dist/recipes/summary-coverage/schema.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const summaryCoverageVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
     partial: "partial";
     missing: "missing";
-    unclear: "unclear";
     preserved: "preserved";
 }>;
 export declare const summaryCoverageInputSchema: z.ZodObject<{
@@ -31,16 +31,16 @@ export declare const summaryCoverageResultSchema: z.ZodObject<{
             review: "review";
         }>;
         verdict: z.ZodEnum<{
+            unclear: "unclear";
             partial: "partial";
             missing: "missing";
-            unclear: "unclear";
             preserved: "preserved";
         }>;
         confidence: z.ZodNumber;
         probabilities: z.ZodRecord<z.ZodEnum<{
+            unclear: "unclear";
             partial: "partial";
             missing: "missing";
-            unclear: "unclear";
             preserved: "preserved";
         }>, z.ZodNumber>;
     }, z.core.$strip>>;

package/dist/recipes/task-dependency/demo.json

@@ -0,0 +1,28 @@
+{
+  "input": {
+    "firstTask": "Build the release archive from the source code.",
+    "secondTask": "Upload the completed release archive to the artifact store.",
+    "context": "The source code is available. No release archive exists yet, and uploading requires the completed archive."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "first_before_second",
+        "confidence": 0.96,
+        "probabilities": {
+          "first_before_second": 0.96,
+          "second_before_first": 0.01,
+          "independent": 0.01,
+          "cyclic": 0.01,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/task-dependency/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskDependencyInput, TaskDependencyResult } from './schema.js';
+export declare function taskDependency(input: TaskDependencyInput, options?: RecipeOptions): Promise<TaskDependencyResult>;
+export { taskDependencyInputSchema, taskDependencyResultSchema, taskDependencyVerdictSchema, } from './schema.js';
+export type { TaskDependencyInput, TaskDependencyResult, TaskDependencyVerdict } from './schema.js';

package/dist/recipes/task-dependency/index.js

@@ -0,0 +1,17 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { taskDependencyInputSchema, taskDependencyResultSchema } from './schema.js';
+export async function taskDependency(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskDependencyInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Does either of firstTask and secondTask require the other to finish before it can start, using only their descriptions and context? Judge necessary prerequisites, not a preferred or convenient order. Never infer a dependency from the order in which tasks are supplied. Shared subject matter or duplicate work alone does not establish a dependency. Choose independent only when the supplied facts establish that both can start without the other finishing. Missing prerequisite information is unclear, not independence.', {
+        first_before_second: 'The second task needs the first task to finish, and the first does not need the second to finish.',
+        second_before_first: 'The first task needs the second task to finish, and the second does not need the first to finish.',
+        independent: 'Neither task needs the other to finish before it can start under the supplied conditions.',
+        cyclic: 'Each task requires the other to finish before it can start.',
+        unclear: 'The supplied descriptions do not establish the prerequisite relationship.',
+    }, options);
+    return taskDependencyResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { taskDependencyInputSchema, taskDependencyResultSchema, taskDependencyVerdictSchema, } from './schema.js';

package/dist/recipes/task-dependency/schema.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const taskDependencyVerdictSchema: z.ZodEnum<{
+    unclear: "unclear";
+    first_before_second: "first_before_second";
+    second_before_first: "second_before_first";
+    independent: "independent";
+    cyclic: "cyclic";
+}>;
+export declare const taskDependencyInputSchema: z.ZodObject<{
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskDependencyResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        unclear: "unclear";
+        first_before_second: "first_before_second";
+        second_before_first: "second_before_first";
+        independent: "independent";
+        cyclic: "cyclic";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        unclear: "unclear";
+        first_before_second: "first_before_second";
+        second_before_first: "second_before_first";
+        independent: "independent";
+        cyclic: "cyclic";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TaskDependencyInput = z.infer<typeof taskDependencyInputSchema>;
+export type TaskDependencyResult = z.infer<typeof taskDependencyResultSchema>;
+export type TaskDependencyVerdict = z.infer<typeof taskDependencyVerdictSchema>;

package/dist/recipes/task-dependency/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const taskDependencyVerdictSchema = z.enum([
+    'first_before_second',
+    'second_before_first',
+    'independent',
+    'cyclic',
+    'unclear',
+]);
+export const taskDependencyInputSchema = z.object({
+    firstTask: nonEmptyText.describe('The first task, including its inputs and output when known.'),
+    secondTask: nonEmptyText.describe('The second task, including its inputs and output when known.'),
+    context: nonEmptyText
+        .describe('Known prerequisites, available inputs, and relevant workflow conditions.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const taskDependencyResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: taskDependencyVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(taskDependencyVerdictSchema, probability),
+});

package/dist/recipes/task-duplicate/demo.json

@@ -0,0 +1,27 @@
+{
+  "input": {
+    "firstTask": "Write a summary of the supplied onboarding guide for new hires.",
+    "secondTask": "Summarize the same supplied onboarding guide for new hires and translate the summary into Spanish.",
+    "context": "Both tasks require the same English summary; only the second also requires a Spanish translation."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "overlapping",
+        "confidence": 0.96,
+        "probabilities": {
+          "duplicate": 0.013333333333333334,
+          "overlapping": 0.96,
+          "distinct": 0.013333333333333334,
+          "unclear": 0.013333333333333334
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { TaskDuplicateInput, TaskDuplicateResult } from './schema.js';
+export declare function taskDuplicate(input: TaskDuplicateInput, options?: RecipeOptions): Promise<TaskDuplicateResult>;
+export { taskDuplicateInputSchema, taskDuplicateResultSchema, taskDuplicateVerdictSchema, } from './schema.js';
+export type { TaskDuplicateInput, TaskDuplicateResult, TaskDuplicateVerdict } from './schema.js';

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

@@ -0,0 +1,16 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { taskDuplicateInputSchema, taskDuplicateResultSchema } from './schema.js';
+export async function taskDuplicate(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = taskDuplicateInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'Do firstTask and secondTask request the same completed outcome under the same scope in context? Compare targets, deliverables, time periods, and constraints, not just wording or methods. Different methods can produce the same requested outcome. The same method applied to different targets is not duplicate work. Choose duplicate only when completing either task would fully satisfy the other; use overlapping when shared requested work leaves a material requirement unique to at least one task. Do not assume that matching titles identify the same task.', {
+        duplicate: 'Completing either task would fully satisfy the other under the same scope and constraints.',
+        overlapping: 'The tasks share requested work, but at least one includes material work the other does not.',
+        distinct: 'The tasks have separate requested outcomes or incompatible scopes with no shared requested work.',
+        unclear: 'Their targets, scope, or intended outcomes cannot be compared from the supplied information.',
+    }, options);
+    return taskDuplicateResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { taskDuplicateInputSchema, taskDuplicateResultSchema, taskDuplicateVerdictSchema, } from './schema.js';

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const taskDuplicateVerdictSchema: z.ZodEnum<{
+    duplicate: "duplicate";
+    unclear: "unclear";
+    overlapping: "overlapping";
+    distinct: "distinct";
+}>;
+export declare const taskDuplicateInputSchema: z.ZodObject<{
+    firstTask: z.ZodString;
+    secondTask: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const taskDuplicateResultSchema: 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<{
+        duplicate: "duplicate";
+        unclear: "unclear";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        duplicate: "duplicate";
+        unclear: "unclear";
+        overlapping: "overlapping";
+        distinct: "distinct";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type TaskDuplicateInput = z.infer<typeof taskDuplicateInputSchema>;
+export type TaskDuplicateResult = z.infer<typeof taskDuplicateResultSchema>;
+export type TaskDuplicateVerdict = z.infer<typeof taskDuplicateVerdictSchema>;

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const taskDuplicateVerdictSchema = z.enum([
+    'duplicate',
+    'overlapping',
+    'distinct',
+    'unclear',
+]);
+export const taskDuplicateInputSchema = z.object({
+    firstTask: nonEmptyText.describe('The first task and its intended outcome.'),
+    secondTask: nonEmptyText.describe('The second task and its intended outcome.'),
+    context: nonEmptyText
+        .describe('Relevant targets, scope, time periods, and constraints for the comparison.')
+        .optional(),
+    minConfidence: probability.optional(),
+});
+export const taskDuplicateResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: taskDuplicateVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(taskDuplicateVerdictSchema, probability),
+});

package/dist/recipes/ticket-match/schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ticketMatchVerdictSchema: z.ZodEnum<{
-    unclear: "unclear";
     related: "related";
+    unclear: "unclear";
     different: "different";
     same_issue: "same_issue";
 }>;
@@ -22,15 +22,15 @@ export declare const ticketMatchResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        unclear: "unclear";
         related: "related";
+        unclear: "unclear";
         different: "different";
         same_issue: "same_issue";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        unclear: "unclear";
         related: "related";
+        unclear: "unclear";
         different: "different";
         same_issue: "same_issue";
     }>, z.ZodNumber>;

package/dist/recipes/topic-shift/schema.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const topicShiftVerdictSchema: z.ZodEnum<{
     unclear: "unclear";
+    mixed: "mixed";
     same_topic: "same_topic";
     new_topic: "new_topic";
-    mixed: "mixed";
 }>;
 export declare const topicShiftInputSchema: z.ZodObject<{
     currentTopic: z.ZodString;
@@ -23,16 +23,16 @@ export declare const topicShiftResultSchema: z.ZodObject<{
     }>;
     verdict: z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         same_topic: "same_topic";
         new_topic: "new_topic";
-        mixed: "mixed";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
         unclear: "unclear";
+        mixed: "mixed";
         same_topic: "same_topic";
         new_topic: "new_topic";
-        mixed: "mixed";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type TopicShiftInput = z.infer<typeof topicShiftInputSchema>;

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

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare const turnIntentVerdictSchema: z.ZodEnum<{
-    request: "request";
-    unclear: "unclear";
     answer: "answer";
-    correction: "correction";
     cancellation: "cancellation";
-    acknowledgment: "acknowledgment";
+    correction: "correction";
+    unclear: "unclear";
+    request: "request";
     other: "other";
+    acknowledgment: "acknowledgment";
 }>;
 export declare const turnIntentInputSchema: z.ZodObject<{
     message: z.ZodString;
@@ -24,23 +24,23 @@ export declare const turnIntentResultSchema: z.ZodObject<{
         review: "review";
     }>;
     verdict: z.ZodEnum<{
-        request: "request";
-        unclear: "unclear";
         answer: "answer";
-        correction: "correction";
         cancellation: "cancellation";
-        acknowledgment: "acknowledgment";
+        correction: "correction";
+        unclear: "unclear";
+        request: "request";
         other: "other";
+        acknowledgment: "acknowledgment";
     }>;
     confidence: z.ZodNumber;
     probabilities: z.ZodRecord<z.ZodEnum<{
-        request: "request";
-        unclear: "unclear";
         answer: "answer";
-        correction: "correction";
         cancellation: "cancellation";
-        acknowledgment: "acknowledgment";
+        correction: "correction";
+        unclear: "unclear";
+        request: "request";
         other: "other";
+        acknowledgment: "acknowledgment";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 export type TurnIntentInput = z.infer<typeof turnIntentInputSchema>;