zotero-bridge 1.1.0 → 1.1.2

package/src/index.ts

@@ -7,7 +7,7 @@
  * SQLite database for collection management, tagging, PDF reading, and more.
  * 
  * @author Combjellyshen
- * @version 1.0.0
+ * @version 1.1.0 (Consolidated tools)
  */
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -22,55 +22,24 @@ import { ZoteroDatabase } from './database.js';
 import { PDFProcessor } from './pdf.js';
 import {
   toolDefinitions,
-  listCollectionsSchema,
-  getCollectionSchema,
-  createCollectionSchema,
-  renameCollectionSchema,
-  moveCollectionSchema,
-  deleteCollectionSchema,
-  getSubcollectionsSchema,
-  listTagsSchema,
-  addTagSchema,
-  removeTagSchema,
-  getItemTagsSchema,
-  createTagSchema,
+  manageCollectionSchema,
+  manageTagsSchema,
   searchItemsSchema,
   getItemDetailsSchema,
-  addItemToCollectionSchema,
-  removeItemFromCollectionSchema,
-  getCollectionItemsSchema,
-  getItemAbstractSchema,
-  setItemAbstractSchema,
-  getItemNotesSchema,
-  addItemNoteSchema,
-  extractPDFTextSchema,
-  getPDFSummarySchema,
-  getItemPDFsSchema,
-  searchPDFSchema,
-  generateAbstractFromPDFSchema,
-  getDatabaseInfoSchema,
-  rawQuerySchema,
-  // New schemas
-  findByDOISchema,
-  findByISBNSchema,
+  manageItemContentSchema,
+  managePDFSchema,
   findByIdentifierSchema,
-  getItemAnnotationsSchema,
-  getAttachmentAnnotationsSchema,
-  getAnnotationsByTypeSchema,
-  getAnnotationsByColorSchema,
-  searchAnnotationsSchema,
+  getAnnotationsSchema,
   searchFulltextSchema,
-  getFulltextContentSchema,
-  searchFulltextWithContextSchema,
-  getRelatedItemsSchema,
-  findSimilarByTagsSchema,
-  findSimilarByCreatorsSchema,
-  findSimilarByCollectionSchema
+  findRelatedItemsSchema,
+  getDatabaseInfoSchema,
+  rawQuerySchema,
+  libraryMaintenanceSchema
 } from './tools.js';
 
 // Server configuration
 const SERVER_NAME = 'zotero-bridge';
-const SERVER_VERSION = '1.0.0';
+const SERVER_VERSION = '1.1.0';
 
 // Parse command line arguments
 function parseArgs(): { dbPath?: string; readonly: boolean } {
@@ -112,7 +81,7 @@ async function main() {
 
   // Initialize database
   const db = new ZoteroDatabase(dbPath, readonly);
-  await db.connect(); // Connect to database
+  await db.connect();
   const pdf = new PDFProcessor(db);
 
   // Create MCP server
@@ -163,97 +132,93 @@ async function main() {
 
       switch (name) {
         // ============================================
-        // Collection Tools
+        // Collection Management (Consolidated)
         // ============================================
-        case 'list_collections': {
-          const params = listCollectionsSchema.parse(args);
-          result = db.getCollections(params.libraryID);
-          break;
-        }
-
-        case 'get_collection': {
-          const params = getCollectionSchema.parse(args);
-          if (params.collectionID) {
-            result = db.getCollectionById(params.collectionID);
-          } else if (params.name) {
-            result = db.getCollectionByName(params.name, params.libraryID);
-          } else {
-            throw new Error('Either collectionID or name is required');
+        case 'manage_collection': {
+          const params = manageCollectionSchema.parse(args);
+          
+          switch (params.action) {
+            case 'list':
+              result = db.getCollections(params.libraryID);
+              break;
+            case 'get':
+              if (params.collectionID) {
+                result = db.getCollectionById(params.collectionID);
+              } else if (params.name) {
+                result = db.getCollectionByName(params.name, params.libraryID);
+              } else {
+                throw new Error('Either collectionID or name is required for get action');
+              }
+              break;
+            case 'create':
+              if (!params.name) throw new Error('Name is required for create action');
+              const collectionID = db.createCollection(params.name, params.parentCollectionID || null, params.libraryID);
+              result = { success: true, collectionID };
+              break;
+            case 'rename':
+              if (!params.collectionID || !params.newName) throw new Error('collectionID and newName are required');
+              result = { success: db.renameCollection(params.collectionID, params.newName) };
+              break;
+            case 'move':
+              if (!params.collectionID) throw new Error('collectionID is required');
+              result = { success: db.moveCollection(params.collectionID, params.parentCollectionID ?? null) };
+              break;
+            case 'delete':
+              if (!params.collectionID) throw new Error('collectionID is required');
+              result = { success: db.deleteCollection(params.collectionID) };
+              break;
+            case 'get_subcollections':
+              if (!params.collectionID) throw new Error('collectionID is required');
+              result = db.getSubcollections(params.collectionID);
+              break;
+            case 'add_item':
+              if (!params.itemID || !params.collectionID) throw new Error('itemID and collectionID are required');
+              result = { success: db.addItemToCollection(params.itemID, params.collectionID) };
+              break;
+            case 'remove_item':
+              if (!params.itemID || !params.collectionID) throw new Error('itemID and collectionID are required');
+              result = { success: db.removeItemFromCollection(params.itemID, params.collectionID) };
+              break;
+            case 'get_items':
+              if (!params.collectionID) throw new Error('collectionID is required');
+              result = db.getCollectionItems(params.collectionID);
+              break;
+            default:
+              throw new Error(`Unknown action: ${params.action}`);
           }
           break;
         }
 
-        case 'create_collection': {
-          const params = createCollectionSchema.parse(args);
-          const collectionID = db.createCollection(
-            params.name,
-            params.parentCollectionID || null,
-            params.libraryID
-          );
-          result = { success: true, collectionID };
-          break;
-        }
-
-        case 'rename_collection': {
-          const params = renameCollectionSchema.parse(args);
-          const success = db.renameCollection(params.collectionID, params.newName);
-          result = { success };
-          break;
-        }
-
-        case 'move_collection': {
-          const params = moveCollectionSchema.parse(args);
-          const success = db.moveCollection(params.collectionID, params.newParentID);
-          result = { success };
-          break;
-        }
-
-        case 'delete_collection': {
-          const params = deleteCollectionSchema.parse(args);
-          const success = db.deleteCollection(params.collectionID);
-          result = { success };
-          break;
-        }
-
-        case 'get_subcollections': {
-          const params = getSubcollectionsSchema.parse(args);
-          result = db.getSubcollections(params.parentCollectionID);
-          break;
-        }
-
         // ============================================
-        // Tag Tools
+        // Tag Management (Consolidated)
         // ============================================
-        case 'list_tags': {
-          listTagsSchema.parse(args);
-          result = db.getTags();
-          break;
-        }
-
-        case 'add_tag': {
-          const params = addTagSchema.parse(args);
-          const success = db.addTagToItem(params.itemID, params.tagName, params.type);
-          result = { success };
-          break;
-        }
-
-        case 'remove_tag': {
-          const params = removeTagSchema.parse(args);
-          const success = db.removeTagFromItem(params.itemID, params.tagName);
-          result = { success };
-          break;
-        }
-
-        case 'get_item_tags': {
-          const params = getItemTagsSchema.parse(args);
-          result = db.getItemTags(params.itemID);
-          break;
-        }
-
-        case 'create_tag': {
-          const params = createTagSchema.parse(args);
-          const tagID = db.createTag(params.name, params.type);
-          result = { success: true, tagID };
+        case 'manage_tags': {
+          const params = manageTagsSchema.parse(args);
+          
+          switch (params.action) {
+            case 'list':
+              result = db.getTags();
+              break;
+            case 'get_item_tags':
+              if (!params.itemID) throw new Error('itemID is required');
+              result = db.getItemTags(params.itemID);
+              break;
+            case 'add':
+              if (!params.itemID || !params.tagName) throw new Error('itemID and tagName are required');
+              result = { success: db.addTagToItem(params.itemID, params.tagName, params.type) };
+              break;
+            case 'remove':
+              if (!params.itemID || !params.tagName) throw new Error('itemID and tagName are required');
+              result = { success: db.removeTagFromItem(params.itemID, params.tagName) };
+              break;
+            case 'create':
+              if (!params.tagName) throw new Error('tagName is required');
+              const tagID = db.createTag(params.tagName, params.type);
+              result = { success: true, tagID };
+              break;
+            default:
+              throw new Error(`Unknown action: ${params.action}`);
+          }
           break;
         }
 
@@ -272,125 +237,190 @@ async function main() {
             result = db.getItemDetails(params.itemID);
           } else if (params.itemKey) {
             const item = db.getItemByKey(params.itemKey);
-            if (item) {
-              result = db.getItemDetails(item.itemID);
-            } else {
-              result = null;
-            }
+            result = item ? db.getItemDetails(item.itemID) : null;
           } else {
             throw new Error('Either itemID or itemKey is required');
           }
           break;
         }
 
-        case 'add_item_to_collection': {
-          const params = addItemToCollectionSchema.parse(args);
-          const success = db.addItemToCollection(params.itemID, params.collectionID);
-          result = { success };
-          break;
-        }
-
-        case 'remove_item_from_collection': {
-          const params = removeItemFromCollectionSchema.parse(args);
-          const success = db.removeItemFromCollection(params.itemID, params.collectionID);
-          result = { success };
-          break;
-        }
-
-        case 'get_collection_items': {
-          const params = getCollectionItemsSchema.parse(args);
-          result = db.getCollectionItems(params.collectionID);
-          break;
-        }
-
         // ============================================
-        // Abstract/Note Tools
+        // Abstract/Note Management (Consolidated)
         // ============================================
-        case 'get_item_abstract': {
-          const params = getItemAbstractSchema.parse(args);
-          result = { abstract: db.getItemAbstract(params.itemID) };
-          break;
-        }
-
-        case 'set_item_abstract': {
-          const params = setItemAbstractSchema.parse(args);
-          const success = db.setItemAbstract(params.itemID, params.abstract);
-          result = { success };
-          break;
-        }
-
-        case 'get_item_notes': {
-          const params = getItemNotesSchema.parse(args);
-          result = db.getItemNotes(params.itemID);
-          break;
-        }
-
-        case 'add_item_note': {
-          const params = addItemNoteSchema.parse(args);
-          const noteID = db.addItemNote(params.itemID, params.content, params.title);
-          result = { success: true, noteID };
+        case 'manage_item_content': {
+          const params = manageItemContentSchema.parse(args);
+          
+          switch (params.action) {
+            case 'get_abstract':
+              result = { abstract: db.getItemAbstract(params.itemID) };
+              break;
+            case 'set_abstract':
+              if (!params.abstract) throw new Error('abstract is required');
+              result = { success: db.setItemAbstract(params.itemID, params.abstract) };
+              break;
+            case 'get_notes':
+              result = db.getItemNotes(params.itemID);
+              break;
+            case 'add_note':
+              if (!params.noteContent) throw new Error('noteContent is required');
+              const noteID = db.addItemNote(params.itemID, params.noteContent, params.noteTitle);
+              result = { success: true, noteID };
+              break;
+            default:
+              throw new Error(`Unknown action: ${params.action}`);
+          }
           break;
         }
 
         // ============================================
-        // PDF Tools
+        // PDF Management (Consolidated)
         // ============================================
-        case 'extract_pdf_text': {
-          const params = extractPDFTextSchema.parse(args);
-          result = await pdf.extractTextFromAttachment(params.attachmentItemID);
+        case 'manage_pdf': {
+          const params = managePDFSchema.parse(args);
+          
+          switch (params.action) {
+            case 'extract_text':
+              if (!params.attachmentItemID) throw new Error('attachmentItemID is required');
+              result = await pdf.extractTextFromAttachment(params.attachmentItemID);
+              break;
+            case 'get_summary':
+              if (!params.attachmentItemID) throw new Error('attachmentItemID is required');
+              result = await pdf.getPDFSummary(params.attachmentItemID);
+              break;
+            case 'list':
+              if (!params.parentItemID) throw new Error('parentItemID is required');
+              const attachments = db.getPDFAttachments(params.parentItemID);
+              result = attachments.map(att => ({
+                ...att,
+                fullPath: db.getAttachmentPath(att.itemID)
+              }));
+              break;
+            case 'search':
+              if (!params.attachmentItemID || !params.query) throw new Error('attachmentItemID and query are required');
+              const content = await pdf.extractTextFromAttachment(params.attachmentItemID);
+              result = content ? pdf.searchInPDF(content, params.query, params.caseSensitive) : [];
+              break;
+            case 'generate_abstract':
+              if (!params.attachmentItemID) throw new Error('attachmentItemID is required');
+              const pdfContent = await pdf.extractTextFromAttachment(params.attachmentItemID);
+              if (!pdfContent) throw new Error('Could not extract PDF content');
+              const abstract = pdf.generateSimpleSummary(pdfContent, params.maxLength);
+              if (params.saveToItem) {
+                const attDetails = db.query(
+                  'SELECT parentItemID FROM itemAttachments WHERE itemID = ?',
+                  [params.attachmentItemID]
+                )[0] as { parentItemID: number } | undefined;
+                if (attDetails?.parentItemID) {
+                  db.setItemAbstract(attDetails.parentItemID, abstract);
+                }
+              }
+              result = { abstract, length: abstract.length };
+              break;
+            default:
+              throw new Error(`Unknown action: ${params.action}`);
+          }
           break;
         }
 
-        case 'get_pdf_summary': {
-          const params = getPDFSummarySchema.parse(args);
-          result = await pdf.getPDFSummary(params.attachmentItemID);
+        // ============================================
+        // Identifier Lookup (Consolidated)
+        // ============================================
+        case 'find_by_identifier': {
+          const params = findByIdentifierSchema.parse(args);
+          const identifier = params.identifier.trim();
+          let type = params.type;
+          
+          // Auto-detect type
+          if (type === 'auto') {
+            if (/^10\.\d+\//.test(identifier) || /doi\.org/i.test(identifier)) {
+              type = 'doi';
+            } else if (/^(97[89])?\d{9}[\dXx]$/.test(identifier.replace(/[-\s]/g, ''))) {
+              type = 'isbn';
+            } else if (/^\d+$/.test(identifier) || /pubmed|pmid/i.test(identifier)) {
+              type = 'pmid';
+            } else if (/arxiv/i.test(identifier) || /^\d{4}\.\d{4,5}/.test(identifier)) {
+              type = 'arxiv';
+            } else if (/^https?:\/\//.test(identifier)) {
+              type = 'url';
+            } else {
+              type = 'doi'; // Default
+            }
+          }
+          
+          result = db.findItemByIdentifier(identifier, type);
           break;
         }
 
-        case 'get_item_pdfs': {
-          const params = getItemPDFsSchema.parse(args);
-          const attachments = db.getPDFAttachments(params.parentItemID);
-          result = attachments.map(att => ({
-            ...att,
-            fullPath: db.getAttachmentPath(att.itemID)
-          }));
+        // ============================================
+        // Annotations (Consolidated)
+        // ============================================
+        case 'get_annotations': {
+          const params = getAnnotationsSchema.parse(args);
+          
+          if (params.searchQuery) {
+            result = db.searchAnnotations(params.searchQuery, params.itemID);
+          } else if (params.types && params.itemID) {
+            result = db.getAnnotationsByType(params.itemID, params.types);
+          } else if (params.colors && params.itemID) {
+            result = db.getAnnotationsByColor(params.itemID, params.colors);
+          } else if (params.attachmentID) {
+            result = db.getAttachmentAnnotations(params.attachmentID);
+          } else if (params.itemID) {
+            result = db.getItemAnnotations(params.itemID);
+          } else {
+            throw new Error('At least itemID, attachmentID, or searchQuery is required');
+          }
           break;
         }
 
-        case 'search_pdf': {
-          const params = searchPDFSchema.parse(args);
-          const content = await pdf.extractTextFromAttachment(params.attachmentItemID);
-          if (content) {
-            result = pdf.searchInPDF(content, params.query, params.caseSensitive);
+        // ============================================
+        // Fulltext Search (Consolidated)
+        // ============================================
+        case 'search_fulltext': {
+          const params = searchFulltextSchema.parse(args);
+          
+          if (params.attachmentID && !params.query) {
+            // Get fulltext content
+            result = { content: db.getFulltextContent(params.attachmentID) };
+          } else if (params.query) {
+            // Search with context
+            result = db.searchFulltextWithContext(params.query, params.contextLength, params.libraryID);
           } else {
-            result = [];
+            throw new Error('Either query or attachmentID is required');
           }
           break;
         }
 
-        case 'generate_abstract_from_pdf': {
-          const params = generateAbstractFromPDFSchema.parse(args);
-          const content = await pdf.extractTextFromAttachment(params.attachmentItemID);
+        // ============================================
+        // Related Items (Consolidated)
+        // ============================================
+        case 'find_related_items': {
+          const params = findRelatedItemsSchema.parse(args);
           
-          if (!content) {
-            throw new Error('Could not extract PDF content');
+          switch (params.method) {
+            case 'manual':
+              result = db.getRelatedItems(params.itemID);
+              break;
+            case 'tags':
+              result = db.findSimilarByTags(params.itemID, params.minSharedTags);
+              break;
+            case 'creators':
+              result = db.findSimilarByCreators(params.itemID);
+              break;
+            case 'collection':
+              result = db.findSimilarByCollection(params.itemID);
+              break;
+            case 'all':
+              result = {
+                manual: db.getRelatedItems(params.itemID),
+                byTags: db.findSimilarByTags(params.itemID, params.minSharedTags),
+                byCreators: db.findSimilarByCreators(params.itemID),
+                byCollection: db.findSimilarByCollection(params.itemID)
+              };
+              break;
+            default:
+              throw new Error(`Unknown method: ${params.method}`);
           }
-          
-          const abstract = pdf.generateSimpleSummary(content, params.maxLength);
-          
-          if (params.saveToItem) {
-            // Get parent item ID from attachment
-            const attDetails = db.query(
-              'SELECT parentItemID FROM itemAttachments WHERE itemID = ?',
-              [params.attachmentItemID]
-            )[0] as { parentItemID: number } | undefined;
-            
-            if (attDetails?.parentItemID) {
-              db.setItemAbstract(attDetails.parentItemID, abstract);
-            }
-          }
-          
-          result = { abstract, length: abstract.length };
           break;
         }
 
@@ -411,115 +441,49 @@ async function main() {
 
         case 'raw_query': {
           const params = rawQuerySchema.parse(args);
-          
-          // Security check - only allow SELECT queries
           if (!params.sql.trim().toUpperCase().startsWith('SELECT')) {
             throw new Error('Only SELECT queries are allowed');
           }
-          
           result = db.query(params.sql, params.params);
           break;
         }
 
         // ============================================
-        // Identifier Tools (DOI/ISBN)
-        // ============================================
-        case 'find_by_doi': {
-          const params = findByDOISchema.parse(args);
-          result = db.findItemByDOI(params.doi);
-          break;
-        }
-
-        case 'find_by_isbn': {
-          const params = findByISBNSchema.parse(args);
-          result = db.findItemByISBN(params.isbn);
-          break;
-        }
-
-        case 'find_by_identifier': {
-          const params = findByIdentifierSchema.parse(args);
-          result = db.findItemByIdentifier(params.identifier, params.type);
-          break;
-        }
-
-        // ============================================
-        // Annotation Tools
+        // Library Maintenance (Consolidated)
         // ============================================
-        case 'get_item_annotations': {
-          const params = getItemAnnotationsSchema.parse(args);
-          result = db.getItemAnnotations(params.itemID);
-          break;
-        }
-
-        case 'get_attachment_annotations': {
-          const params = getAttachmentAnnotationsSchema.parse(args);
-          result = db.getAttachmentAnnotations(params.attachmentID);
-          break;
-        }
-
-        case 'get_annotations_by_type': {
-          const params = getAnnotationsByTypeSchema.parse(args);
-          result = db.getAnnotationsByType(params.itemID, params.types);
-          break;
-        }
-
-        case 'get_annotations_by_color': {
-          const params = getAnnotationsByColorSchema.parse(args);
-          result = db.getAnnotationsByColor(params.itemID, params.colors);
-          break;
-        }
-
-        case 'search_annotations': {
-          const params = searchAnnotationsSchema.parse(args);
-          result = db.searchAnnotations(params.query, params.itemID);
-          break;
-        }
-
-        // ============================================
-        // Fulltext Search Tools
-        // ============================================
-        case 'search_fulltext': {
-          const params = searchFulltextSchema.parse(args);
-          result = db.searchFulltext(params.query, params.libraryID);
-          break;
-        }
-
-        case 'get_fulltext_content': {
-          const params = getFulltextContentSchema.parse(args);
-          result = { content: db.getFulltextContent(params.attachmentID) };
-          break;
-        }
-
-        case 'search_fulltext_with_context': {
-          const params = searchFulltextWithContextSchema.parse(args);
-          result = db.searchFulltextWithContext(params.query, params.contextLength, params.libraryID);
-          break;
-        }
-
-        // ============================================
-        // Related/Similar Items Tools
-        // ============================================
-        case 'get_related_items': {
-          const params = getRelatedItemsSchema.parse(args);
-          result = db.getRelatedItems(params.itemID);
-          break;
-        }
-
-        case 'find_similar_by_tags': {
-          const params = findSimilarByTagsSchema.parse(args);
-          result = db.findSimilarByTags(params.itemID, params.minSharedTags);
-          break;
-        }
-
-        case 'find_similar_by_creators': {
-          const params = findSimilarByCreatorsSchema.parse(args);
-          result = db.findSimilarByCreators(params.itemID);
-          break;
-        }
-
-        case 'find_similar_by_collection': {
-          const params = findSimilarByCollectionSchema.parse(args);
-          result = db.findSimilarByCollection(params.itemID);
+        case 'library_maintenance': {
+          const params = libraryMaintenanceSchema.parse(args);
+          
+          switch (params.action) {
+            case 'find_duplicates':
+              result = db.findDuplicates(params.duplicateField, params.libraryID);
+              break;
+            case 'validate_attachments':
+              result = db.validateAttachments(params.itemID, params.checkAll);
+              break;
+            case 'get_valid_attachment':
+              if (!params.parentItemID) throw new Error('parentItemID is required');
+              result = db.getValidAttachment(params.parentItemID, params.contentType);
+              break;
+            case 'find_with_valid_pdf':
+              result = db.findItemsWithValidPDF({
+                title: params.title,
+                doi: params.doi,
+                requireValidPDF: params.requireValidPDF
+              });
+              break;
+            case 'cleanup_orphans':
+              result = db.deleteOrphanAttachments(params.dryRun);
+              break;
+            case 'merge_items':
+              if (!params.targetItemID || !params.sourceItemIDs) {
+                throw new Error('targetItemID and sourceItemIDs are required');
+              }
+              result = db.mergeItems(params.targetItemID, params.sourceItemIDs);
+              break;
+            default:
+              throw new Error(`Unknown action: ${params.action}`);
+          }
           break;
         }
 
@@ -569,54 +533,68 @@ async function main() {
   console.error(`Database: ${db.getPath()}`);
 }
 
-// Helper function to convert Zod type to JSON Schema
-function zodToJsonSchema(zodType: z.ZodTypeAny): Record<string, any> {
-  // Unwrap optional, default, and nullable types
-  if (zodType instanceof z.ZodOptional) {
-    return zodToJsonSchema(zodType._def.innerType);
+// Helper function to convert Zod type to JSON Schema (Zod v4 compatible)
+function zodToJsonSchema(zodType: any): Record<string, any> {
+  // Get the type name from _zod property or check type directly
+  const typeName = zodType?._zod?.def?.type || zodType?.constructor?.name || '';
+  
+  // Unwrap optional types
+  if (typeName === 'optional' || zodType instanceof z.ZodOptional) {
+    const inner = zodType._zod?.def?.innerType || zodType._def?.innerType;
+    if (inner) return zodToJsonSchema(inner);
   }
-  if (zodType instanceof z.ZodDefault) {
-    return zodToJsonSchema(zodType._def.innerType);
+  
+  // Unwrap default types
+  if (typeName === 'default' || zodType instanceof z.ZodDefault) {
+    const inner = zodType._zod?.def?.innerType || zodType._def?.innerType;
+    if (inner) return zodToJsonSchema(inner);
   }
-  if (zodType instanceof z.ZodNullable) {
-    return zodToJsonSchema(zodType._def.innerType);
+  
+  // Unwrap nullable types
+  if (typeName === 'nullable' || zodType instanceof z.ZodNullable) {
+    const inner = zodType._zod?.def?.innerType || zodType._def?.innerType;
+    if (inner) return zodToJsonSchema(inner);
   }
 
   // Handle basic types
-  if (zodType instanceof z.ZodString) {
+  if (typeName === 'string' || zodType instanceof z.ZodString) {
     return { type: 'string' };
   }
-  if (zodType instanceof z.ZodNumber) {
+  if (typeName === 'number' || zodType instanceof z.ZodNumber) {
     return { type: 'number' };
   }
-  if (zodType instanceof z.ZodBoolean) {
+  if (typeName === 'boolean' || zodType instanceof z.ZodBoolean) {
     return { type: 'boolean' };
   }
 
-  // Handle array types - MUST include items
-  if (zodType instanceof z.ZodArray) {
-    const elementType = zodType._def.type;
-    const itemSchema = zodToJsonSchema(elementType);
-    // If items schema is empty (from ZodAny), use a more explicit schema
-    if (Object.keys(itemSchema).length === 0) {
-      return {
-        type: 'array',
-        items: { type: 'string' } // Default to string for any type to ensure valid JSON Schema
-      };
+  // Handle enum types (Zod v4 uses 'entries' instead of 'values')
+  if (typeName === 'enum' || zodType instanceof z.ZodEnum) {
+    const enumValues = zodType._zod?.def?.entries 
+      || zodType._def?.values 
+      || Object.keys(zodType._zod?.def?.entries || {});
+    return { type: 'string', enum: Array.isArray(enumValues) ? enumValues : Object.keys(enumValues) };
+  }
+
+  // Handle array types
+  if (typeName === 'array' || zodType instanceof z.ZodArray) {
+    const elementType = zodType._zod?.def?.element || zodType._def?.type;
+    if (elementType) {
+      const itemSchema = zodToJsonSchema(elementType);
+      if (Object.keys(itemSchema).length === 0) {
+        return { type: 'array', items: { type: 'string' } };
+      }
+      return { type: 'array', items: itemSchema };
     }
-    return {
-      type: 'array',
-      items: itemSchema
-    };
+    return { type: 'array', items: { type: 'string' } };
   }
 
   // Handle object types
-  if (zodType instanceof z.ZodObject) {
+  if (typeName === 'object' || zodType instanceof z.ZodObject) {
     return { type: 'object' };
   }
 
-  // Handle ZodAny - return empty object (accepts any value)
-  if (zodType instanceof z.ZodAny) {
+  // Handle ZodAny
+  if (typeName === 'any' || zodType instanceof z.ZodAny) {
     return {};
   }