@doist/todoist-ai 5.2.0 → 6.0.0

package/dist/utils/output-schemas.d.ts

@@ -7,56 +7,25 @@ declare const TaskSchema: z.ZodObject<{
     content: z.ZodString;
     description: z.ZodString;
     dueDate: z.ZodOptional<z.ZodString>;
-    recurring: z.ZodUnion<[z.ZodBoolean, z.ZodString]>;
+    recurring: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
     deadlineDate: z.ZodOptional<z.ZodString>;
-    priority: z.ZodEnum<["p1", "p2", "p3", "p4"]>;
+    priority: z.ZodEnum<{
+        p1: "p1";
+        p2: "p2";
+        p3: "p3";
+        p4: "p4";
+    }>;
     projectId: z.ZodString;
     sectionId: z.ZodOptional<z.ZodString>;
     parentId: z.ZodOptional<z.ZodString>;
-    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
     duration: z.ZodOptional<z.ZodString>;
     responsibleUid: z.ZodOptional<z.ZodString>;
     isUncompletable: z.ZodOptional<z.ZodBoolean>;
     assignedByUid: z.ZodOptional<z.ZodString>;
     checked: z.ZodBoolean;
     completedAt: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    content: string;
-    description: string;
-    id: string;
-    projectId: string;
-    checked: boolean;
-    priority: "p1" | "p2" | "p3" | "p4";
-    recurring: string | boolean;
-    parentId?: string | undefined;
-    sectionId?: string | undefined;
-    assignedByUid?: string | undefined;
-    responsibleUid?: string | undefined;
-    labels?: string[] | undefined;
-    duration?: string | undefined;
-    completedAt?: string | undefined;
-    isUncompletable?: boolean | undefined;
-    dueDate?: string | undefined;
-    deadlineDate?: string | undefined;
-}, {
-    content: string;
-    description: string;
-    id: string;
-    projectId: string;
-    checked: boolean;
-    priority: "p1" | "p2" | "p3" | "p4";
-    recurring: string | boolean;
-    parentId?: string | undefined;
-    sectionId?: string | undefined;
-    assignedByUid?: string | undefined;
-    responsibleUid?: string | undefined;
-    labels?: string[] | undefined;
-    duration?: string | undefined;
-    completedAt?: string | undefined;
-    isUncompletable?: boolean | undefined;
-    dueDate?: string | undefined;
-    deadlineDate?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for a mapped project object returned by tools
  */
@@ -69,38 +38,14 @@ declare const ProjectSchema: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodString>;
     inboxProject: z.ZodBoolean;
     viewStyle: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-    color: string;
-    isFavorite: boolean;
-    viewStyle: string;
-    isShared: boolean;
-    inboxProject: boolean;
-    parentId?: string | undefined;
-}, {
-    name: string;
-    id: string;
-    color: string;
-    isFavorite: boolean;
-    viewStyle: string;
-    isShared: boolean;
-    inboxProject: boolean;
-    parentId?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for a section object returned by tools
  */
 declare const SectionSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-}, {
-    name: string;
-    id: string;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for a comment object returned by tools
  */
@@ -118,82 +63,17 @@ declare const CommentSchema: z.ZodObject<{
         fileType: z.ZodOptional<z.ZodString>;
         fileUrl: z.ZodOptional<z.ZodString>;
         fileDuration: z.ZodOptional<z.ZodNumber>;
-        uploadState: z.ZodOptional<z.ZodEnum<["pending", "completed"]>>;
+        uploadState: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+        }>>;
         url: z.ZodOptional<z.ZodString>;
         title: z.ZodOptional<z.ZodString>;
         image: z.ZodOptional<z.ZodString>;
         imageWidth: z.ZodOptional<z.ZodNumber>;
         imageHeight: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        resourceType: string;
-        title?: string | undefined;
-        fileName?: string | undefined;
-        fileSize?: number | undefined;
-        fileType?: string | undefined;
-        fileUrl?: string | undefined;
-        fileDuration?: number | undefined;
-        uploadState?: "pending" | "completed" | undefined;
-        image?: string | undefined;
-        imageWidth?: number | undefined;
-        imageHeight?: number | undefined;
-        url?: string | undefined;
-    }, {
-        resourceType: string;
-        title?: string | undefined;
-        fileName?: string | undefined;
-        fileSize?: number | undefined;
-        fileType?: string | undefined;
-        fileUrl?: string | undefined;
-        fileDuration?: number | undefined;
-        uploadState?: "pending" | "completed" | undefined;
-        image?: string | undefined;
-        imageWidth?: number | undefined;
-        imageHeight?: number | undefined;
-        url?: string | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    content: string;
-    id: string;
-    postedAt: string;
-    projectId?: string | undefined;
-    fileAttachment?: {
-        resourceType: string;
-        title?: string | undefined;
-        fileName?: string | undefined;
-        fileSize?: number | undefined;
-        fileType?: string | undefined;
-        fileUrl?: string | undefined;
-        fileDuration?: number | undefined;
-        uploadState?: "pending" | "completed" | undefined;
-        image?: string | undefined;
-        imageWidth?: number | undefined;
-        imageHeight?: number | undefined;
-        url?: string | undefined;
-    } | undefined;
-    postedUid?: string | undefined;
-    taskId?: string | undefined;
-}, {
-    content: string;
-    id: string;
-    postedAt: string;
-    projectId?: string | undefined;
-    fileAttachment?: {
-        resourceType: string;
-        title?: string | undefined;
-        fileName?: string | undefined;
-        fileSize?: number | undefined;
-        fileType?: string | undefined;
-        fileUrl?: string | undefined;
-        fileDuration?: number | undefined;
-        uploadState?: "pending" | "completed" | undefined;
-        image?: string | undefined;
-        imageWidth?: number | undefined;
-        imageHeight?: number | undefined;
-        url?: string | undefined;
-    } | undefined;
-    postedUid?: string | undefined;
-    taskId?: string | undefined;
-}>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 /**
  * Schema for an activity event object returned by tools
  */
@@ -207,27 +87,7 @@ declare const ActivityEventSchema: z.ZodObject<{
     parentItemId: z.ZodOptional<z.ZodString>;
     initiatorId: z.ZodOptional<z.ZodString>;
     extraData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    objectType: string;
-    objectId: string;
-    eventType: string;
-    eventDate: string;
-    id?: string | undefined;
-    parentProjectId?: string | undefined;
-    parentItemId?: string | undefined;
-    initiatorId?: string | undefined;
-    extraData?: Record<string, unknown> | undefined;
-}, {
-    objectType: string;
-    objectId: string;
-    eventType: string;
-    eventDate: string;
-    id?: string | undefined;
-    parentProjectId?: string | undefined;
-    parentItemId?: string | undefined;
-    initiatorId?: string | undefined;
-    extraData?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for a user/collaborator object returned by tools
  */
@@ -235,15 +95,7 @@ declare const CollaboratorSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
     email: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    id: string;
-    email: string;
-}, {
-    name: string;
-    id: string;
-    email: string;
-}>;
+}, z.core.$strip>;
 /**
  * Schema for batch operation failure
  */
@@ -251,14 +103,6 @@ declare const FailureSchema: z.ZodObject<{
     item: z.ZodString;
     error: z.ZodString;
     code: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    error: string;
-    item: string;
-    code?: string | undefined;
-}, {
-    error: string;
-    item: string;
-    code?: string | undefined;
-}>;
+}, z.core.$strip>;
 export { ActivityEventSchema, CollaboratorSchema, CommentSchema, FailureSchema, ProjectSchema, SectionSchema, TaskSchema, };
 //# sourceMappingURL=output-schemas.d.ts.map

package/dist/utils/output-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-schemas.d.ts","sourceRoot":"","sources":["../../src/utils/output-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Bd,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;EAGjB,CAAA;AA0BF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYvB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;EAItB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;EAIjB,CAAA;AAEF,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,UAAU,GACb,CAAA"}
+{"version":3,"file":"output-schemas.d.ts","sourceRoot":"","sources":["../../src/utils/output-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;GAEG;AACH,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;iBA+Bd,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;iBASjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;iBAGjB,CAAA;AA0BF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;iBAQjB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;iBAYvB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;;iBAItB,CAAA;AAEF;;GAEG;AACH,QAAA,MAAM,aAAa;;;;iBAIjB,CAAA;AAEF,OAAO,EACH,mBAAmB,EACnB,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,UAAU,GACb,CAAA"}

package/dist/utils/priorities.d.ts

@@ -1,7 +1,12 @@
 import { z } from 'zod';
 declare const PRIORITY_VALUES: readonly ["p1", "p2", "p3", "p4"];
 export type Priority = (typeof PRIORITY_VALUES)[number];
-export declare const PrioritySchema: z.ZodEnum<["p1", "p2", "p3", "p4"]>;
+export declare const PrioritySchema: z.ZodEnum<{
+    p1: "p1";
+    p2: "p2";
+    p3: "p3";
+    p4: "p4";
+}>;
 export declare function convertPriorityToNumber(priority: Priority): number;
 export declare function convertNumberToPriority(priority: number): Priority | undefined;
 export {};

package/dist/utils/priorities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"priorities.d.ts","sourceRoot":"","sources":["../../src/utils/priorities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,QAAA,MAAM,eAAe,mCAAoC,CAAA;AACzD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,cAAc,qCAEzB,CAAA;AAEF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAIlE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAI9E"}
+{"version":3,"file":"priorities.d.ts","sourceRoot":"","sources":["../../src/utils/priorities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,QAAA,MAAM,eAAe,mCAAoC,CAAA;AACzD,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvD,eAAO,MAAM,cAAc;;;;;EAE8D,CAAA;AAEzF,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAIlE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAI9E"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "5.2.0",
+    "version": "6.0.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -48,26 +48,26 @@
         "prepare": "husky"
     },
     "dependencies": {
-        "@doist/todoist-api-typescript": "6.2.0",
-        "@modelcontextprotocol/sdk": "1.22.0",
+        "@doist/todoist-api-typescript": "6.2.1",
+        "@modelcontextprotocol/sdk": "1.24.3",
         "date-fns": "4.1.0",
         "dotenv": "17.2.3",
-        "zod": "3.25.76"
+        "zod": "4.1.13"
     },
     "devDependencies": {
-        "@biomejs/biome": "2.3.5",
-        "@types/express": "5.0.5",
+        "@biomejs/biome": "2.3.8",
+        "@types/express": "5.0.6",
         "@types/morgan": "1.9.10",
-        "@types/node": "22.19.1",
+        "@types/node": "22.19.2",
         "concurrently": "9.2.1",
-        "express": "5.1.0",
+        "express": "5.2.1",
         "husky": "9.1.7",
-        "lint-staged": "16.2.6",
+        "lint-staged": "16.2.7",
         "morgan": "1.10.1",
         "nodemon": "3.1.11",
-        "rimraf": "6.1.0",
+        "rimraf": "6.1.2",
         "typescript": "5.9.3",
-        "vite": "7.2.2",
+        "vite": "7.2.7",
         "vite-plugin-dts": "4.5.4",
         "vitest": "3.2.4"
     },

package/scripts/validate-schemas.ts

@@ -17,37 +17,37 @@
 
 import { z } from 'zod'
 
-interface ValidationIssue {
+type ValidationIssue = {
     toolName: string
     parameterPath: string
     issue: string
     suggestion: string
 }
 
-interface ValidationResult {
+type ValidationResult = {
     success: boolean
     issues: ValidationIssue[]
     toolsChecked: number
     parametersChecked: number
 }
 
+type AnyZodSchema = z.ZodTypeAny | { _zod: { def: unknown } }
+
 /**
  * Recursively walk a Zod schema and detect problematic patterns
  */
 function walkZodSchema(
-    schema: z.ZodTypeAny,
+    schema: AnyZodSchema,
     path: string,
     issues: ValidationIssue[],
     toolName: string,
 ): void {
-    const typeName = schema._def.typeName
-
     // Check for ZodOptional containing a ZodNullable ZodString
-    if (typeName === 'ZodOptional') {
-        const innerSchema = schema._def.innerType
-        if (innerSchema._def.typeName === 'ZodNullable') {
-            const nullableInner = innerSchema._def.innerType
-            if (nullableInner._def.typeName === 'ZodString') {
+    if (schema instanceof z.ZodOptional) {
+        const innerSchema = schema.unwrap()
+        if (innerSchema instanceof z.ZodNullable) {
+            const nullableInner = innerSchema.unwrap()
+            if (nullableInner instanceof z.ZodString) {
                 issues.push({
                     toolName,
                     parameterPath: path,
@@ -60,11 +60,11 @@ function walkZodSchema(
     }
 
     // Check for ZodNullable containing a ZodOptional ZodString
-    if (typeName === 'ZodNullable') {
-        const innerSchema = schema._def.innerType
-        if (innerSchema._def.typeName === 'ZodOptional') {
-            const optionalInner = innerSchema._def.innerType
-            if (optionalInner._def.typeName === 'ZodString') {
+    if (schema instanceof z.ZodNullable) {
+        const innerSchema = schema.unwrap()
+        if (innerSchema instanceof z.ZodOptional) {
+            const optionalInner = innerSchema.unwrap()
+            if (optionalInner instanceof z.ZodString) {
                 issues.push({
                     toolName,
                     parameterPath: path,
@@ -77,61 +77,60 @@ function walkZodSchema(
     }
 
     // Recursively check nested schemas
-    switch (typeName) {
-        case 'ZodObject': {
-            const shape = schema._def.shape()
-            for (const [key, value] of Object.entries(shape)) {
-                const newPath = path ? `${path}.${key}` : key
-                walkZodSchema(value as z.ZodTypeAny, newPath, issues, toolName)
-            }
-            break
-        }
-        case 'ZodArray':
-            walkZodSchema(schema._def.type, `${path}[]`, issues, toolName)
-            break
-
-        case 'ZodOptional':
-        case 'ZodNullable':
-        case 'ZodDefault':
-            walkZodSchema(schema._def.innerType, path, issues, toolName)
-            break
-
-        case 'ZodUnion':
-        case 'ZodDiscriminatedUnion': {
-            const options = schema._def.options || schema._def.discriminatedUnion
-            if (Array.isArray(options)) {
-                options.forEach((option: z.ZodTypeAny, index: number) => {
-                    walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
-                })
-            }
-            break
+    if (schema instanceof z.ZodObject) {
+        const shape = schema.shape
+        for (const [key, value] of Object.entries(shape)) {
+            const newPath = path ? `${path}.${key}` : key
+            walkZodSchema(value as AnyZodSchema, newPath, issues, toolName)
         }
-        case 'ZodIntersection':
-            walkZodSchema(schema._def.left, `${path}[left]`, issues, toolName)
-            walkZodSchema(schema._def.right, `${path}[right]`, issues, toolName)
-            break
-
-        case 'ZodRecord':
-            if (schema._def.valueType) {
-                walkZodSchema(schema._def.valueType, `${path}[value]`, issues, toolName)
-            }
-            break
-
-        case 'ZodTuple':
-            if (schema._def.items) {
-                schema._def.items.forEach((item: z.ZodTypeAny, index: number) => {
-                    walkZodSchema(item, `${path}[${index}]`, issues, toolName)
-                })
-            }
-            break
+    } else if (schema instanceof z.ZodArray) {
+        const element = (schema as unknown as { _zod: { def: { element: AnyZodSchema } } })._zod.def
+            .element
+        walkZodSchema(element, `${path}[]`, issues, toolName)
+    } else if (
+        schema instanceof z.ZodOptional ||
+        schema instanceof z.ZodNullable ||
+        schema instanceof z.ZodDefault
+    ) {
+        walkZodSchema(schema.unwrap() as AnyZodSchema, path, issues, toolName)
+    } else if (schema instanceof z.ZodUnion) {
+        const options = (schema as unknown as { _zod: { def: { options: AnyZodSchema[] } } })._zod
+            .def.options
+        options.forEach((option: AnyZodSchema, index: number) => {
+            walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
+        })
+    } else if (schema instanceof z.ZodDiscriminatedUnion) {
+        const options = (schema as unknown as { _zod: { def: { options: AnyZodSchema[] } } })._zod
+            .def.options
+        options.forEach((option: AnyZodSchema, index: number) => {
+            walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
+        })
+    } else if (schema instanceof z.ZodIntersection) {
+        const left = (schema as unknown as { _zod: { def: { left: AnyZodSchema } } })._zod.def.left
+        const right = (schema as unknown as { _zod: { def: { right: AnyZodSchema } } })._zod.def
+            .right
+        walkZodSchema(left, `${path}[left]`, issues, toolName)
+        walkZodSchema(right, `${path}[right]`, issues, toolName)
+    } else if (schema instanceof z.ZodRecord) {
+        const valueType = (schema as unknown as { _zod: { def: { valueType: AnyZodSchema } } })._zod
+            .def.valueType
+        walkZodSchema(valueType, `${path}[value]`, issues, toolName)
+    } else if (schema instanceof z.ZodTuple) {
+        const items = (schema as unknown as { _zod: { def: { items: AnyZodSchema[] } } })._zod.def
+            .items
+        items.forEach((item: AnyZodSchema, index: number) => {
+            walkZodSchema(item, `${path}[${index}]`, issues, toolName)
+        })
     }
 }
 
 /**
  * Validate a single tool's parameter schema
  */
-// biome-ignore lint/suspicious/noExplicitAny: this is a tooling script
-function validateToolSchema(tool: any): ValidationIssue[] {
+function validateToolSchema(tool: {
+    name?: string
+    parameters?: Record<string, z.ZodTypeAny>
+}): ValidationIssue[] {
     const issues: ValidationIssue[] = []
     const toolName = tool.name || 'unknown'
 
@@ -174,8 +173,10 @@ async function validateAllSchemas(verbose: boolean = false): Promise<ValidationR
             if (tool.parameters) {
                 try {
                     const schema = z.object(tool.parameters)
-                    const shape = schema._def.shape()
-                    totalParameters += Object.keys(shape).length
+                    const shape = schema.shape
+                    if (shape) {
+                        totalParameters += Object.keys(shape).length
+                    }
                 } catch {
                     // Skip counting if schema is invalid
                 }