mcp-sunsama 0.5.2 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # mcp-sunsama
 
+## 0.6.0
+
+### Minor Changes
+
+- 7c90fef: feat: add update-task-backlog tool for moving tasks to backlog
+
+  - Add new update-task-backlog tool that moves tasks to the backlog
+  - Update updateTaskSnoozeDateSchema to require newDay parameter
+  - Add comprehensive test coverage for the new tool
+  - Update documentation in README.md and CLAUDE.md
+
 ## 0.5.2
 
 ### Patch Changes

package/CLAUDE.md

@@ -127,7 +127,7 @@ Optional:
 ### Task Operations
 Full CRUD support:
 - **Read**: `get-tasks-by-day`, `get-tasks-backlog`, `get-archived-tasks`, `get-streams`
-- **Write**: `create-task`, `update-task-complete`, `delete-task`
+- **Write**: `create-task`, `update-task-complete`, `update-task-snooze-date`, `update-task-backlog`, `delete-task`
 
 Task read operations support response trimming. `get-tasks-by-day` includes completion filtering. `get-archived-tasks` includes enhanced pagination with hasMore flag for LLM decision-making.
 

package/README.md

@@ -93,7 +93,8 @@ Add this configuration to your Claude Desktop MCP settings:
 - `get-tasks-backlog` - Get backlog tasks
 - `get-archived-tasks` - Get archived tasks with pagination (includes hasMore flag for LLM context)
 - `update-task-complete` - Mark tasks as complete
-- `update-task-snooze-date` - Reschedule tasks to different dates or move to backlog
+- `update-task-snooze-date` - Reschedule tasks to different dates
+- `update-task-backlog` - Move tasks to the backlog
 - `delete-task` - Delete tasks permanently
 
 ### User & Stream Operations

package/dist/main.js

@@ -3,7 +3,7 @@ import { FastMCP } from "fastmcp";
 import { httpStreamAuthenticator } from "./auth/http.js";
 import { initializeStdioAuth } from "./auth/stdio.js";
 import { getTransportConfig } from "./config/transport.js";
-import { createTaskSchema, deleteTaskSchema, getArchivedTasksSchema, getStreamsSchema, getTasksBacklogSchema, getTasksByDaySchema, getUserSchema, updateTaskCompleteSchema, updateTaskSnoozeDateSchema } from "./schemas.js";
+import { createTaskSchema, deleteTaskSchema, getArchivedTasksSchema, getStreamsSchema, getTasksBacklogSchema, getTasksByDaySchema, getUserSchema, updateTaskBacklogSchema, updateTaskCompleteSchema, updateTaskSnoozeDateSchema } from "./schemas.js";
 import { getSunsamaClient } from "./utils/client-resolver.js";
 import { filterTasksByCompletion } from "./utils/task-filters.js";
 import { trimTasksForResponse } from "./utils/task-trimmer.js";
@@ -16,7 +16,7 @@ if (transportConfig.transportType === "stdio") {
 }
 const server = new FastMCP({
     name: "Sunsama API Server",
-    version: "0.5.2",
+    version: "0.6.0",
     instructions: `
 This MCP server provides access to the Sunsama API for task and project management.
 
@@ -420,6 +420,56 @@ server.addTool({
         }
     }
 });
+server.addTool({
+    name: "update-task-backlog",
+    description: "Move a task to the backlog",
+    parameters: updateTaskBacklogSchema,
+    execute: async (args, { session, log }) => {
+        try {
+            // Extract parameters
+            const { taskId, timezone, limitResponsePayload } = args;
+            log.info("Moving task to backlog", {
+                taskId: taskId,
+                timezone: timezone,
+                limitResponsePayload: limitResponsePayload
+            });
+            // Get the appropriate client based on transport type
+            const sunsamaClient = getSunsamaClient(session);
+            // Build options object
+            const options = {};
+            if (timezone)
+                options.timezone = timezone;
+            if (limitResponsePayload !== undefined)
+                options.limitResponsePayload = limitResponsePayload;
+            // Call sunsamaClient.updateTaskSnoozeDate(taskId, null, options) to move to backlog
+            const result = await sunsamaClient.updateTaskSnoozeDate(taskId, null, options);
+            log.info("Successfully moved task to backlog", {
+                taskId: taskId,
+                success: result.success
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: result.success,
+                            taskId: taskId,
+                            movedToBacklog: true,
+                            updatedFields: result.updatedFields
+                        })
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            log.error("Failed to move task to backlog", {
+                taskId: args.taskId,
+                error: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw new Error(`Failed to move task to backlog: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+});
 // Stream Operations
 server.addTool({
     name: "get-streams",

package/dist/schemas.d.ts

@@ -94,17 +94,30 @@ export declare const deleteTaskSchema: z.ZodObject<{
 }>;
 export declare const updateTaskSnoozeDateSchema: z.ZodObject<{
     taskId: z.ZodString;
-    newDay: z.ZodUnion<[z.ZodString, z.ZodNull]>;
+    newDay: z.ZodString;
+    timezone: z.ZodOptional<z.ZodString>;
+    limitResponsePayload: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    newDay: string;
+    timezone?: string | undefined;
+    limitResponsePayload?: boolean | undefined;
+}, {
+    taskId: string;
+    newDay: string;
+    timezone?: string | undefined;
+    limitResponsePayload?: boolean | undefined;
+}>;
+export declare const updateTaskBacklogSchema: z.ZodObject<{
+    taskId: z.ZodString;
     timezone: z.ZodOptional<z.ZodString>;
     limitResponsePayload: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     taskId: string;
-    newDay: string | null;
     timezone?: string | undefined;
     limitResponsePayload?: boolean | undefined;
 }, {
     taskId: string;
-    newDay: string | null;
     timezone?: string | undefined;
     limitResponsePayload?: boolean | undefined;
 }>;

package/dist/schemas.d.ts.map

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

package/dist/schemas.js

@@ -56,10 +56,13 @@ export const deleteTaskSchema = z.object({
 // Update task snooze date parameters
 export const updateTaskSnoozeDateSchema = z.object({
     taskId: z.string().min(1, "Task ID is required").describe("The ID of the task to reschedule"),
-    newDay: z.union([
-        z.string().date("Must be a valid date in YYYY-MM-DD format"),
-        z.null()
-    ]).describe("Target date in YYYY-MM-DD format, or null to move to backlog"),
+    newDay: z.string().date("Must be a valid date in YYYY-MM-DD format").describe("Target date in YYYY-MM-DD format"),
+    timezone: z.string().optional().describe("Timezone string (e.g., 'America/New_York'). If not provided, uses user's default timezone"),
+    limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
+});
+// Update task backlog parameters
+export const updateTaskBacklogSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the task to move to backlog"),
     timezone: z.string().optional().describe("Timezone string (e.g., 'America/New_York'). If not provided, uses user's default timezone"),
     limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
 });

package/dist/schemas.test.d.ts

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

package/dist/schemas.test.d.ts.map

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

package/dist/schemas.test.js

@@ -0,0 +1,486 @@
+import { describe, test, expect } from "bun:test";
+import { completionFilterSchema, getTasksByDaySchema, getTasksBacklogSchema, getArchivedTasksSchema, getUserSchema, getStreamsSchema, createTaskSchema, updateTaskCompleteSchema, deleteTaskSchema, updateTaskSnoozeDateSchema, updateTaskBacklogSchema, userProfileSchema, groupSchema, userSchema, taskSchema, streamSchema, userResponseSchema, tasksResponseSchema, streamsResponseSchema, errorResponseSchema, } from "./schemas.js";
+describe("Tool Parameter Schemas", () => {
+    describe("completionFilterSchema", () => {
+        test("should accept valid completion filter values", () => {
+            expect(() => completionFilterSchema.parse("all")).not.toThrow();
+            expect(() => completionFilterSchema.parse("incomplete")).not.toThrow();
+            expect(() => completionFilterSchema.parse("completed")).not.toThrow();
+        });
+        test("should reject invalid completion filter values", () => {
+            expect(() => completionFilterSchema.parse("invalid")).toThrow();
+            expect(() => completionFilterSchema.parse("")).toThrow();
+            expect(() => completionFilterSchema.parse(null)).toThrow();
+            expect(() => completionFilterSchema.parse(undefined)).toThrow();
+        });
+    });
+    describe("getTasksByDaySchema", () => {
+        test("should accept valid day format", () => {
+            const validInput = {
+                day: "2024-01-15",
+                timezone: "America/New_York",
+                completionFilter: "all",
+            };
+            expect(() => getTasksByDaySchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { day: "2024-01-15" };
+            expect(() => getTasksByDaySchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject invalid day formats", () => {
+            expect(() => getTasksByDaySchema.parse({ day: "2024/01/15" })).toThrow();
+            expect(() => getTasksByDaySchema.parse({ day: "01-15-2024" })).toThrow();
+            expect(() => getTasksByDaySchema.parse({ day: "2024-1-15" })).toThrow();
+            expect(() => getTasksByDaySchema.parse({ day: "2024-01-5" })).toThrow();
+            expect(() => getTasksByDaySchema.parse({ day: "" })).toThrow();
+            expect(() => getTasksByDaySchema.parse({})).toThrow();
+        });
+        test("should reject invalid completion filters", () => {
+            expect(() => getTasksByDaySchema.parse({
+                day: "2024-01-15",
+                completionFilter: "invalid",
+            })).toThrow();
+        });
+    });
+    describe("getTasksBacklogSchema", () => {
+        test("should accept empty object", () => {
+            expect(() => getTasksBacklogSchema.parse({})).not.toThrow();
+        });
+        test("should ignore extra properties", () => {
+            expect(() => getTasksBacklogSchema.parse({ extra: "property" })).not.toThrow();
+        });
+    });
+    describe("getArchivedTasksSchema", () => {
+        test("should accept valid pagination parameters", () => {
+            const validInput = { offset: 0, limit: 100 };
+            expect(() => getArchivedTasksSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept empty object", () => {
+            expect(() => getArchivedTasksSchema.parse({})).not.toThrow();
+        });
+        test("should accept valid ranges", () => {
+            expect(() => getArchivedTasksSchema.parse({ offset: 0 })).not.toThrow();
+            expect(() => getArchivedTasksSchema.parse({ limit: 1 })).not.toThrow();
+            expect(() => getArchivedTasksSchema.parse({ limit: 1000 })).not.toThrow();
+        });
+        test("should reject invalid offset values", () => {
+            expect(() => getArchivedTasksSchema.parse({ offset: -1 })).toThrow();
+            expect(() => getArchivedTasksSchema.parse({ offset: 1.5 })).toThrow();
+        });
+        test("should reject invalid limit values", () => {
+            expect(() => getArchivedTasksSchema.parse({ limit: 0 })).toThrow();
+            expect(() => getArchivedTasksSchema.parse({ limit: 1001 })).toThrow();
+            expect(() => getArchivedTasksSchema.parse({ limit: -1 })).toThrow();
+            expect(() => getArchivedTasksSchema.parse({ limit: 1.5 })).toThrow();
+        });
+    });
+    describe("getUserSchema", () => {
+        test("should accept empty object", () => {
+            expect(() => getUserSchema.parse({})).not.toThrow();
+        });
+    });
+    describe("getStreamsSchema", () => {
+        test("should accept empty object", () => {
+            expect(() => getStreamsSchema.parse({})).not.toThrow();
+        });
+    });
+    describe("createTaskSchema", () => {
+        test("should accept valid task creation input", () => {
+            const validInput = {
+                text: "Test task",
+                notes: "Task notes",
+                streamIds: ["stream1", "stream2"],
+                timeEstimate: 60,
+                dueDate: "2024-01-15T10:00:00Z",
+                snoozeUntil: "2024-01-16T09:00:00Z",
+                private: true,
+                taskId: "custom-task-id",
+            };
+            expect(() => createTaskSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { text: "Test task" };
+            expect(() => createTaskSchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject empty text", () => {
+            expect(() => createTaskSchema.parse({ text: "" })).toThrow();
+            expect(() => createTaskSchema.parse({})).toThrow();
+        });
+        test("should reject invalid time estimate", () => {
+            expect(() => createTaskSchema.parse({ text: "Test", timeEstimate: 0 })).toThrow();
+            expect(() => createTaskSchema.parse({ text: "Test", timeEstimate: -1 })).toThrow();
+            expect(() => createTaskSchema.parse({ text: "Test", timeEstimate: 1.5 })).toThrow();
+        });
+    });
+    describe("updateTaskCompleteSchema", () => {
+        test("should accept valid task completion input", () => {
+            const validInput = {
+                taskId: "task-123",
+                completeOn: "2024-01-15T10:00:00Z",
+                limitResponsePayload: true,
+            };
+            expect(() => updateTaskCompleteSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { taskId: "task-123" };
+            expect(() => updateTaskCompleteSchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject empty task ID", () => {
+            expect(() => updateTaskCompleteSchema.parse({ taskId: "" })).toThrow();
+            expect(() => updateTaskCompleteSchema.parse({})).toThrow();
+        });
+    });
+    describe("deleteTaskSchema", () => {
+        test("should accept valid task deletion input", () => {
+            const validInput = {
+                taskId: "task-123",
+                limitResponsePayload: true,
+                wasTaskMerged: false,
+            };
+            expect(() => deleteTaskSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { taskId: "task-123" };
+            expect(() => deleteTaskSchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject empty task ID", () => {
+            expect(() => deleteTaskSchema.parse({ taskId: "" })).toThrow();
+            expect(() => deleteTaskSchema.parse({})).toThrow();
+        });
+    });
+    describe("updateTaskSnoozeDateSchema", () => {
+        test("should accept valid date input", () => {
+            const validInput = {
+                taskId: "task-123",
+                newDay: "2024-01-15",
+                timezone: "America/New_York",
+                limitResponsePayload: true,
+            };
+            expect(() => updateTaskSnoozeDateSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { taskId: "task-123", newDay: "2024-01-15" };
+            expect(() => updateTaskSnoozeDateSchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject empty task ID", () => {
+            expect(() => updateTaskSnoozeDateSchema.parse({ taskId: "", newDay: "2024-01-15" })).toThrow();
+            expect(() => updateTaskSnoozeDateSchema.parse({ newDay: "2024-01-15" })).toThrow();
+        });
+        test("should reject invalid date formats", () => {
+            expect(() => updateTaskSnoozeDateSchema.parse({
+                taskId: "task-123",
+                newDay: "2024/01/15",
+            })).toThrow();
+            expect(() => updateTaskSnoozeDateSchema.parse({
+                taskId: "task-123",
+                newDay: "01-15-2024",
+            })).toThrow();
+            expect(() => updateTaskSnoozeDateSchema.parse({
+                taskId: "task-123",
+                newDay: "invalid-date",
+            })).toThrow();
+        });
+        test("should reject missing newDay", () => {
+            expect(() => updateTaskSnoozeDateSchema.parse({ taskId: "task-123" })).toThrow();
+        });
+    });
+    describe("updateTaskBacklogSchema", () => {
+        test("should accept valid task backlog input", () => {
+            const validInput = {
+                taskId: "task-123",
+                timezone: "America/New_York",
+                limitResponsePayload: true,
+            };
+            expect(() => updateTaskBacklogSchema.parse(validInput)).not.toThrow();
+        });
+        test("should accept minimal required input", () => {
+            const minimalInput = { taskId: "task-123" };
+            expect(() => updateTaskBacklogSchema.parse(minimalInput)).not.toThrow();
+        });
+        test("should reject empty task ID", () => {
+            expect(() => updateTaskBacklogSchema.parse({ taskId: "" })).toThrow();
+            expect(() => updateTaskBacklogSchema.parse({})).toThrow();
+        });
+    });
+});
+describe("Response Schemas", () => {
+    describe("userProfileSchema", () => {
+        test("should accept valid user profile", () => {
+            const validProfile = {
+                _id: "user-123",
+                email: "test@example.com",
+                firstName: "John",
+                lastName: "Doe",
+                timezone: "America/New_York",
+                avatarUrl: "https://example.com/avatar.jpg",
+            };
+            expect(() => userProfileSchema.parse(validProfile)).not.toThrow();
+        });
+        test("should accept profile without optional fields", () => {
+            const minimalProfile = {
+                _id: "user-123",
+                email: "test@example.com",
+                firstName: "John",
+                lastName: "Doe",
+                timezone: "America/New_York",
+            };
+            expect(() => userProfileSchema.parse(minimalProfile)).not.toThrow();
+        });
+        test("should reject invalid email", () => {
+            const invalidProfile = {
+                _id: "user-123",
+                email: "invalid-email",
+                firstName: "John",
+                lastName: "Doe",
+                timezone: "America/New_York",
+            };
+            expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+        });
+        test("should reject invalid avatar URL", () => {
+            const invalidProfile = {
+                _id: "user-123",
+                email: "test@example.com",
+                firstName: "John",
+                lastName: "Doe",
+                timezone: "America/New_York",
+                avatarUrl: "invalid-url",
+            };
+            expect(() => userProfileSchema.parse(invalidProfile)).toThrow();
+        });
+    });
+    describe("groupSchema", () => {
+        test("should accept valid group", () => {
+            const validGroup = {
+                groupId: "group-123",
+                name: "Test Group",
+                role: "admin",
+            };
+            expect(() => groupSchema.parse(validGroup)).not.toThrow();
+        });
+        test("should accept group without optional role", () => {
+            const minimalGroup = {
+                groupId: "group-123",
+                name: "Test Group",
+            };
+            expect(() => groupSchema.parse(minimalGroup)).not.toThrow();
+        });
+    });
+    describe("userSchema", () => {
+        test("should accept valid user", () => {
+            const validUser = {
+                _id: "user-123",
+                email: "test@example.com",
+                profile: {
+                    _id: "user-123",
+                    email: "test@example.com",
+                    firstName: "John",
+                    lastName: "Doe",
+                    timezone: "America/New_York",
+                },
+                primaryGroup: {
+                    groupId: "group-123",
+                    name: "Test Group",
+                },
+            };
+            expect(() => userSchema.parse(validUser)).not.toThrow();
+        });
+        test("should accept user without primary group", () => {
+            const userWithoutGroup = {
+                _id: "user-123",
+                email: "test@example.com",
+                profile: {
+                    _id: "user-123",
+                    email: "test@example.com",
+                    firstName: "John",
+                    lastName: "Doe",
+                    timezone: "America/New_York",
+                },
+            };
+            expect(() => userSchema.parse(userWithoutGroup)).not.toThrow();
+        });
+    });
+    describe("taskSchema", () => {
+        test("should accept valid task", () => {
+            const validTask = {
+                _id: "task-123",
+                title: "Test Task",
+                description: "Task description",
+                status: "active",
+                createdAt: "2024-01-15T10:00:00Z",
+                updatedAt: "2024-01-15T11:00:00Z",
+                scheduledDate: "2024-01-16",
+                completedAt: "2024-01-16T12:00:00Z",
+                streamId: "stream-123",
+                userId: "user-123",
+                groupId: "group-123",
+            };
+            expect(() => taskSchema.parse(validTask)).not.toThrow();
+        });
+        test("should accept task with minimal required fields", () => {
+            const minimalTask = {
+                _id: "task-123",
+                title: "Test Task",
+                status: "active",
+                createdAt: "2024-01-15T10:00:00Z",
+                updatedAt: "2024-01-15T11:00:00Z",
+                userId: "user-123",
+                groupId: "group-123",
+            };
+            expect(() => taskSchema.parse(minimalTask)).not.toThrow();
+        });
+    });
+    describe("streamSchema", () => {
+        test("should accept valid stream", () => {
+            const validStream = {
+                _id: "stream-123",
+                name: "Test Stream",
+                color: "#FF0000",
+                groupId: "group-123",
+                isActive: true,
+                createdAt: "2024-01-15T10:00:00Z",
+                updatedAt: "2024-01-15T11:00:00Z",
+            };
+            expect(() => streamSchema.parse(validStream)).not.toThrow();
+        });
+        test("should accept stream without optional color", () => {
+            const minimalStream = {
+                _id: "stream-123",
+                name: "Test Stream",
+                groupId: "group-123",
+                isActive: true,
+                createdAt: "2024-01-15T10:00:00Z",
+                updatedAt: "2024-01-15T11:00:00Z",
+            };
+            expect(() => streamSchema.parse(minimalStream)).not.toThrow();
+        });
+    });
+    describe("userResponseSchema", () => {
+        test("should accept valid user response", () => {
+            const validResponse = {
+                user: {
+                    _id: "user-123",
+                    email: "test@example.com",
+                    profile: {
+                        _id: "user-123",
+                        email: "test@example.com",
+                        firstName: "John",
+                        lastName: "Doe",
+                        timezone: "America/New_York",
+                    },
+                },
+            };
+            expect(() => userResponseSchema.parse(validResponse)).not.toThrow();
+        });
+    });
+    describe("tasksResponseSchema", () => {
+        test("should accept valid tasks response", () => {
+            const validResponse = {
+                tasks: [
+                    {
+                        _id: "task-123",
+                        title: "Test Task",
+                        status: "active",
+                        createdAt: "2024-01-15T10:00:00Z",
+                        updatedAt: "2024-01-15T11:00:00Z",
+                        userId: "user-123",
+                        groupId: "group-123",
+                    },
+                ],
+                count: 1,
+            };
+            expect(() => tasksResponseSchema.parse(validResponse)).not.toThrow();
+        });
+        test("should accept empty tasks response", () => {
+            const emptyResponse = {
+                tasks: [],
+                count: 0,
+            };
+            expect(() => tasksResponseSchema.parse(emptyResponse)).not.toThrow();
+        });
+    });
+    describe("streamsResponseSchema", () => {
+        test("should accept valid streams response", () => {
+            const validResponse = {
+                streams: [
+                    {
+                        _id: "stream-123",
+                        name: "Test Stream",
+                        groupId: "group-123",
+                        isActive: true,
+                        createdAt: "2024-01-15T10:00:00Z",
+                        updatedAt: "2024-01-15T11:00:00Z",
+                    },
+                ],
+                count: 1,
+            };
+            expect(() => streamsResponseSchema.parse(validResponse)).not.toThrow();
+        });
+    });
+    describe("errorResponseSchema", () => {
+        test("should accept valid error response", () => {
+            const validError = {
+                error: "ValidationError",
+                message: "Invalid input provided",
+                code: "400",
+            };
+            expect(() => errorResponseSchema.parse(validError)).not.toThrow();
+        });
+        test("should accept error without optional code", () => {
+            const minimalError = {
+                error: "ValidationError",
+                message: "Invalid input provided",
+            };
+            expect(() => errorResponseSchema.parse(minimalError)).not.toThrow();
+        });
+    });
+});
+describe("Edge Cases and Error Handling", () => {
+    test("should handle null values appropriately", () => {
+        // updateTaskBacklogSchema should accept all parameters as optional except taskId
+        expect(() => updateTaskBacklogSchema.parse({
+            taskId: "task-123"
+        })).not.toThrow();
+        // Other schemas should reject null where not expected
+        expect(() => getTasksByDaySchema.parse({ day: null })).toThrow();
+        expect(() => createTaskSchema.parse({ text: null })).toThrow();
+    });
+    test("should handle undefined values appropriately", () => {
+        // Optional fields should accept undefined
+        expect(() => getTasksByDaySchema.parse({
+            day: "2024-01-15",
+            timezone: undefined,
+            completionFilter: undefined,
+        })).not.toThrow();
+        // Required fields should reject undefined
+        expect(() => getTasksByDaySchema.parse({ day: undefined })).toThrow();
+        expect(() => createTaskSchema.parse({ text: undefined })).toThrow();
+    });
+    test("should handle type coercion correctly", () => {
+        // Numbers as strings should be rejected where numbers are expected
+        expect(() => getArchivedTasksSchema.parse({ offset: "0", limit: "100" })).toThrow();
+        // Boolean strings should be rejected where booleans are expected
+        expect(() => createTaskSchema.parse({ text: "Test", private: "true" })).toThrow();
+    });
+    test("should validate string formats correctly", () => {
+        // Email validation
+        expect(() => userProfileSchema.parse({
+            _id: "user-123",
+            email: "@example.com",
+            firstName: "John",
+            lastName: "Doe",
+            timezone: "America/New_York",
+        })).toThrow();
+        // URL validation
+        expect(() => userProfileSchema.parse({
+            _id: "user-123",
+            email: "test@example.com",
+            firstName: "John",
+            lastName: "Doe",
+            timezone: "America/New_York",
+            avatarUrl: "not-a-url",
+        })).toThrow();
+        // Date regex validation
+        expect(() => getTasksByDaySchema.parse({ day: "2024-13-01" })).not.toThrow(); // Regex allows invalid month/day numbers
+        expect(() => getTasksByDaySchema.parse({ day: "24-01-01" })).toThrow(); // But rejects wrong format
+    });
+});