@task-mcp/shared 1.0.6 → 1.0.8

package/dist/schemas/response-schema.d.ts

@@ -0,0 +1,307 @@
+import { z } from "zod";
+/**
+ * Response Schema
+ *
+ * Standardized formats for AI agents to ask questions, make suggestions,
+ * or request confirmation from users.
+ */
+export declare const ResponseType: z.ZodEnum<["question", "suggestion", "confirmation"]>;
+export type ResponseType = z.infer<typeof ResponseType>;
+export declare const ResponsePriority: z.ZodEnum<["low", "medium", "high", "critical"]>;
+export type ResponsePriority = z.infer<typeof ResponsePriority>;
+export declare const ResponseOption: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    value: string;
+    description?: string | undefined;
+}, {
+    label: string;
+    value: string;
+    description?: string | undefined;
+}>;
+export type ResponseOption = z.infer<typeof ResponseOption>;
+export declare const QuestionResponse: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"question">;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }>, "many">>;
+    defaultOption: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "question";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    defaultOption?: string | undefined;
+}, {
+    message: string;
+    type: "question";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    defaultOption?: string | undefined;
+}>;
+export type QuestionResponse = z.infer<typeof QuestionResponse>;
+export declare const SuggestionResponse: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"suggestion">;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }>, "many">;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    options: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[];
+    type: "suggestion";
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    reasoning?: string | undefined;
+}, {
+    message: string;
+    options: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[];
+    type: "suggestion";
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    reasoning?: string | undefined;
+}>;
+export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
+export declare const ConfirmationResponse: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"confirmation">;
+    action: z.ZodString;
+    consequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    defaultConfirm: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "confirmation";
+    action: string;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}, {
+    message: string;
+    type: "confirmation";
+    action: string;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}>;
+export type ConfirmationResponse = z.infer<typeof ConfirmationResponse>;
+export declare const AgentResponse: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"question">;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }>, "many">>;
+    defaultOption: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "question";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    defaultOption?: string | undefined;
+}, {
+    message: string;
+    type: "question";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    defaultOption?: string | undefined;
+}>, z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"suggestion">;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }>, "many">;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    options: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[];
+    type: "suggestion";
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    reasoning?: string | undefined;
+}, {
+    message: string;
+    options: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[];
+    type: "suggestion";
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    reasoning?: string | undefined;
+}>, z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+} & {
+    type: z.ZodLiteral<"confirmation">;
+    action: z.ZodString;
+    consequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    defaultConfirm: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "confirmation";
+    action: string;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}, {
+    message: string;
+    type: "confirmation";
+    action: string;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}>]>;
+export type AgentResponse = z.infer<typeof AgentResponse>;
+export declare const GenerateResponseInput: z.ZodObject<{
+    type: z.ZodEnum<["question", "suggestion", "confirmation"]>;
+    message: z.ZodString;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }>, "many">>;
+    context: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>>;
+    action: z.ZodOptional<z.ZodString>;
+    consequences: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    defaultOption: z.ZodOptional<z.ZodString>;
+    defaultConfirm: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    type: "question" | "suggestion" | "confirmation";
+    priority: "low" | "medium" | "high" | "critical";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    defaultOption?: string | undefined;
+    reasoning?: string | undefined;
+    action?: string | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}, {
+    message: string;
+    type: "question" | "suggestion" | "confirmation";
+    options?: {
+        label: string;
+        value: string;
+        description?: string | undefined;
+    }[] | undefined;
+    context?: string | undefined;
+    priority?: "low" | "medium" | "high" | "critical" | undefined;
+    defaultOption?: string | undefined;
+    reasoning?: string | undefined;
+    action?: string | undefined;
+    consequences?: string[] | undefined;
+    defaultConfirm?: boolean | undefined;
+}>;
+export type GenerateResponseInput = z.infer<typeof GenerateResponseInput>;
+//# sourceMappingURL=response-schema.d.ts.map

package/dist/schemas/response-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-schema.d.ts","sourceRoot":"","sources":["../../src/schemas/response-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AAGH,eAAO,MAAM,YAAY,uDAAqD,CAAC;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAGxD,eAAO,MAAM,gBAAgB,kDAAgD,CAAC;AAC9E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGhE,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAW5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGhE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGpE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAGxE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAG1D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/response-schema.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+/**
+ * Response Schema
+ *
+ * Standardized formats for AI agents to ask questions, make suggestions,
+ * or request confirmation from users.
+ */
+// Response types
+export const ResponseType = z.enum(["question", "suggestion", "confirmation"]);
+// Priority level for responses
+export const ResponsePriority = z.enum(["low", "medium", "high", "critical"]);
+// Option for multiple choice responses
+export const ResponseOption = z.object({
+    label: z.string().describe("Display text for the option"),
+    value: z.string().describe("Value to return when selected"),
+    description: z.string().optional().describe("Additional explanation"),
+});
+// Base response schema
+const BaseResponse = z.object({
+    type: ResponseType.describe("Type of response: question, suggestion, or confirmation"),
+    message: z.string().describe("Main message to display to user"),
+    context: z.string().optional().describe("Additional context or explanation"),
+    priority: ResponsePriority.optional().describe("Urgency/importance of response (default: medium)"),
+});
+// Question response - for clarification
+export const QuestionResponse = BaseResponse.extend({
+    type: z.literal("question"),
+    options: z.array(ResponseOption).optional()
+        .describe("Multiple choice options (omit for free-form answer)"),
+    defaultOption: z.string().optional()
+        .describe("Default option value if user provides no input"),
+});
+// Suggestion response - for recommendations
+export const SuggestionResponse = BaseResponse.extend({
+    type: z.literal("suggestion"),
+    options: z.array(ResponseOption).min(1)
+        .describe("Suggested options for user to choose from"),
+    reasoning: z.string().optional()
+        .describe("Explanation of why these suggestions were made"),
+});
+// Confirmation response - for explicit approval
+export const ConfirmationResponse = BaseResponse.extend({
+    type: z.literal("confirmation"),
+    action: z.string().describe("Action that will be taken if confirmed"),
+    consequences: z.array(z.string()).optional()
+        .describe("List of effects or changes that will occur"),
+    defaultConfirm: z.boolean().optional()
+        .describe("Default choice if user provides no input (default: false)"),
+});
+// Union type for all response types
+export const AgentResponse = z.discriminatedUnion("type", [
+    QuestionResponse,
+    SuggestionResponse,
+    ConfirmationResponse,
+]);
+// Input schema for generating responses
+export const GenerateResponseInput = z.object({
+    type: ResponseType.describe("Type of response to generate"),
+    message: z.string().describe("Main message"),
+    options: z.array(ResponseOption).optional()
+        .describe("Options for question/suggestion types"),
+    context: z.string().optional(),
+    priority: ResponsePriority.optional().default("medium"),
+    action: z.string().optional()
+        .describe("Action description (for confirmation type)"),
+    consequences: z.array(z.string()).optional()
+        .describe("Consequences list (for confirmation type)"),
+    reasoning: z.string().optional()
+        .describe("Reasoning explanation (for suggestion type)"),
+    defaultOption: z.string().optional()
+        .describe("Default option value (for question type)"),
+    defaultConfirm: z.boolean().optional()
+        .describe("Default confirmation choice (for confirmation type)"),
+});
+//# sourceMappingURL=response-schema.js.map

package/dist/schemas/response-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-schema.js","sourceRoot":"","sources":["../../src/schemas/response-schema.ts"],"names":[],"mappings":"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"}

package/dist/schemas/response-schema.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=response-schema.test.d.ts.map

package/dist/schemas/response-schema.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-schema.test.d.ts","sourceRoot":"","sources":["../../src/schemas/response-schema.test.ts"],"names":[],"mappings":""}

package/dist/schemas/response-schema.test.js

@@ -0,0 +1,256 @@
+import { describe, expect, it } from "bun:test";
+import { ResponseType, ResponsePriority, ResponseOption, QuestionResponse, SuggestionResponse, ConfirmationResponse, GenerateResponseInput, } from "./response-schema.js";
+describe("Response Schema", () => {
+    describe("ResponseType", () => {
+        it("should accept valid response types", () => {
+            expect(() => ResponseType.parse("question")).not.toThrow();
+            expect(() => ResponseType.parse("suggestion")).not.toThrow();
+            expect(() => ResponseType.parse("confirmation")).not.toThrow();
+        });
+        it("should reject invalid response types", () => {
+            expect(() => ResponseType.parse("invalid")).toThrow();
+            expect(() => ResponseType.parse("ask")).toThrow();
+        });
+    });
+    describe("ResponsePriority", () => {
+        it("should accept valid priority levels", () => {
+            expect(() => ResponsePriority.parse("low")).not.toThrow();
+            expect(() => ResponsePriority.parse("medium")).not.toThrow();
+            expect(() => ResponsePriority.parse("high")).not.toThrow();
+            expect(() => ResponsePriority.parse("critical")).not.toThrow();
+        });
+        it("should reject invalid priority levels", () => {
+            expect(() => ResponsePriority.parse("urgent")).toThrow();
+            expect(() => ResponsePriority.parse("normal")).toThrow();
+        });
+    });
+    describe("ResponseOption", () => {
+        it("should validate option with all fields", () => {
+            const option = {
+                label: "High Priority",
+                value: "high",
+                description: "For urgent tasks",
+            };
+            expect(() => ResponseOption.parse(option)).not.toThrow();
+            const parsed = ResponseOption.parse(option);
+            expect(parsed.label).toBe("High Priority");
+            expect(parsed.value).toBe("high");
+            expect(parsed.description).toBe("For urgent tasks");
+        });
+        it("should validate option without description", () => {
+            const option = {
+                label: "Low Priority",
+                value: "low",
+            };
+            expect(() => ResponseOption.parse(option)).not.toThrow();
+            const parsed = ResponseOption.parse(option);
+            expect(parsed.label).toBe("Low Priority");
+            expect(parsed.value).toBe("low");
+            expect(parsed.description).toBeUndefined();
+        });
+        it("should reject option without required fields", () => {
+            expect(() => ResponseOption.parse({ label: "Test" })).toThrow();
+            expect(() => ResponseOption.parse({ value: "test" })).toThrow();
+            expect(() => ResponseOption.parse({})).toThrow();
+        });
+    });
+    describe("QuestionResponse", () => {
+        it("should validate question with all fields", () => {
+            const question = {
+                type: "question",
+                message: "What should we do?",
+                context: "Need clarification on approach",
+                priority: "high",
+                options: [
+                    { label: "Option A", value: "a" },
+                    { label: "Option B", value: "b" },
+                ],
+                defaultOption: "a",
+            };
+            expect(() => QuestionResponse.parse(question)).not.toThrow();
+            const parsed = QuestionResponse.parse(question);
+            expect(parsed.type).toBe("question");
+            expect(parsed.message).toBe("What should we do?");
+            expect(parsed.options).toHaveLength(2);
+            expect(parsed.defaultOption).toBe("a");
+        });
+        it("should validate question with minimal fields", () => {
+            const question = {
+                type: "question",
+                message: "Proceed?",
+            };
+            expect(() => QuestionResponse.parse(question)).not.toThrow();
+            const parsed = QuestionResponse.parse(question);
+            expect(parsed.type).toBe("question");
+            expect(parsed.message).toBe("Proceed?");
+            expect(parsed.context).toBeUndefined();
+            expect(parsed.options).toBeUndefined();
+        });
+        it("should reject question without message", () => {
+            expect(() => QuestionResponse.parse({ type: "question" })).toThrow();
+        });
+        it("should reject question with wrong type", () => {
+            expect(() => QuestionResponse.parse({
+                type: "suggestion",
+                message: "Test",
+            })).toThrow();
+        });
+    });
+    describe("SuggestionResponse", () => {
+        it("should validate suggestion with all fields", () => {
+            const suggestion = {
+                type: "suggestion",
+                message: "Consider breaking down this task",
+                context: "Task is complex",
+                priority: "medium",
+                options: [
+                    { label: "3 subtasks", value: "sub_3" },
+                    { label: "5 subtasks", value: "sub_5" },
+                ],
+                reasoning: "Based on complexity analysis",
+            };
+            expect(() => SuggestionResponse.parse(suggestion)).not.toThrow();
+            const parsed = SuggestionResponse.parse(suggestion);
+            expect(parsed.type).toBe("suggestion");
+            expect(parsed.options).toHaveLength(2);
+            expect(parsed.reasoning).toBe("Based on complexity analysis");
+        });
+        it("should validate suggestion with minimal fields", () => {
+            const suggestion = {
+                type: "suggestion",
+                message: "Try this",
+                options: [{ label: "Do it", value: "yes" }],
+            };
+            expect(() => SuggestionResponse.parse(suggestion)).not.toThrow();
+            const parsed = SuggestionResponse.parse(suggestion);
+            expect(parsed.options).toHaveLength(1);
+        });
+        it("should reject suggestion without options", () => {
+            expect(() => SuggestionResponse.parse({
+                type: "suggestion",
+                message: "Test",
+            })).toThrow();
+        });
+        it("should reject suggestion with empty options array", () => {
+            expect(() => SuggestionResponse.parse({
+                type: "suggestion",
+                message: "Test",
+                options: [],
+            })).toThrow();
+        });
+    });
+    describe("ConfirmationResponse", () => {
+        it("should validate confirmation with all fields", () => {
+            const confirmation = {
+                type: "confirmation",
+                message: "Are you sure?",
+                action: "Delete all completed tasks",
+                context: "This operation is irreversible",
+                priority: "critical",
+                consequences: ["10 tasks will be removed", "Cannot be undone"],
+                defaultConfirm: false,
+            };
+            expect(() => ConfirmationResponse.parse(confirmation)).not.toThrow();
+            const parsed = ConfirmationResponse.parse(confirmation);
+            expect(parsed.type).toBe("confirmation");
+            expect(parsed.action).toBe("Delete all completed tasks");
+            expect(parsed.consequences).toHaveLength(2);
+            expect(parsed.defaultConfirm).toBe(false);
+        });
+        it("should validate confirmation with minimal fields", () => {
+            const confirmation = {
+                type: "confirmation",
+                message: "Delete this?",
+                action: "Delete task",
+            };
+            expect(() => ConfirmationResponse.parse(confirmation)).not.toThrow();
+            const parsed = ConfirmationResponse.parse(confirmation);
+            expect(parsed.action).toBe("Delete task");
+            expect(parsed.consequences).toBeUndefined();
+        });
+        it("should reject confirmation without action", () => {
+            expect(() => ConfirmationResponse.parse({
+                type: "confirmation",
+                message: "Confirm?",
+            })).toThrow();
+        });
+        it("should reject confirmation without message", () => {
+            expect(() => ConfirmationResponse.parse({
+                type: "confirmation",
+                action: "Do something",
+            })).toThrow();
+        });
+    });
+    describe("GenerateResponseInput", () => {
+        it("should validate input for question type", () => {
+            const input = {
+                type: "question",
+                message: "What to do?",
+                options: [{ label: "Yes", value: "yes" }],
+                defaultOption: "yes",
+            };
+            expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+            const parsed = GenerateResponseInput.parse(input);
+            expect(parsed.type).toBe("question");
+        });
+        it("should validate input for suggestion type", () => {
+            const input = {
+                type: "suggestion",
+                message: "Try this",
+                options: [{ label: "Option", value: "opt" }],
+                reasoning: "Because reasons",
+            };
+            expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+        });
+        it("should validate input for confirmation type", () => {
+            const input = {
+                type: "confirmation",
+                message: "Sure?",
+                action: "Delete",
+                consequences: ["Gone forever"],
+                defaultConfirm: false,
+            };
+            expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+        });
+        it("should use default priority of medium", () => {
+            const input = {
+                type: "question",
+                message: "Test?",
+            };
+            const parsed = GenerateResponseInput.parse(input);
+            expect(parsed.priority).toBe("medium");
+        });
+        it("should allow custom priority", () => {
+            const input = {
+                type: "question",
+                message: "Test?",
+                priority: "critical",
+            };
+            const parsed = GenerateResponseInput.parse(input);
+            expect(parsed.priority).toBe("critical");
+        });
+    });
+    describe("Type discrimination", () => {
+        it("should differentiate response types at compile time", () => {
+            const question = {
+                type: "question",
+                message: "Test",
+            };
+            const suggestion = {
+                type: "suggestion",
+                message: "Test",
+                options: [{ label: "A", value: "a" }],
+            };
+            const confirmation = {
+                type: "confirmation",
+                message: "Test",
+                action: "Do it",
+            };
+            // TypeScript should allow this
+            expect(question.type).toBe("question");
+            expect(suggestion.type).toBe("suggestion");
+            expect(confirmation.type).toBe("confirmation");
+        });
+    });
+});
+//# sourceMappingURL=response-schema.test.js.map