zotero-bridge 1.1.0 → 1.1.2

package/dist/index.js

@@ -6,7 +6,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';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -14,12 +14,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { z } from 'zod';
 import { ZoteroDatabase } from './database.js';
 import { PDFProcessor } from './pdf.js';
-import { toolDefinitions, listCollectionsSchema, getCollectionSchema, createCollectionSchema, renameCollectionSchema, moveCollectionSchema, deleteCollectionSchema, getSubcollectionsSchema, listTagsSchema, addTagSchema, removeTagSchema, getItemTagsSchema, createTagSchema, searchItemsSchema, getItemDetailsSchema, addItemToCollectionSchema, removeItemFromCollectionSchema, getCollectionItemsSchema, getItemAbstractSchema, setItemAbstractSchema, getItemNotesSchema, addItemNoteSchema, extractPDFTextSchema, getPDFSummarySchema, getItemPDFsSchema, searchPDFSchema, generateAbstractFromPDFSchema, getDatabaseInfoSchema, rawQuerySchema, 
-// New schemas
-findByDOISchema, findByISBNSchema, findByIdentifierSchema, getItemAnnotationsSchema, getAttachmentAnnotationsSchema, getAnnotationsByTypeSchema, getAnnotationsByColorSchema, searchAnnotationsSchema, searchFulltextSchema, getFulltextContentSchema, searchFulltextWithContextSchema, getRelatedItemsSchema, findSimilarByTagsSchema, findSimilarByCreatorsSchema, findSimilarByCollectionSchema } from './tools.js';
+import { toolDefinitions, manageCollectionSchema, manageTagsSchema, searchItemsSchema, getItemDetailsSchema, manageItemContentSchema, managePDFSchema, findByIdentifierSchema, getAnnotationsSchema, searchFulltextSchema, 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() {
     const args = process.argv.slice(2);
@@ -58,7 +56,7 @@ async function main() {
     const { dbPath, readonly } = parseArgs();
     // 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
     const server = new Server({
@@ -99,84 +97,104 @@ async function main() {
             let result;
             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;
                 }
                 // ============================================
@@ -194,108 +212,195 @@ async function main() {
                     }
                     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];
+                                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);
-                    if (!content) {
-                        throw new Error('Could not extract PDF content');
-                    }
-                    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];
-                        if (attDetails?.parentItemID) {
-                            db.setItemAbstract(attDetails.parentItemID, abstract);
-                        }
+                // ============================================
+                // Related Items (Consolidated)
+                // ============================================
+                case 'find_related_items': {
+                    const params = findRelatedItemsSchema.parse(args);
+                    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}`);
                     }
-                    result = { abstract, length: abstract.length };
                     break;
                 }
                 // ============================================
@@ -314,7 +419,6 @@ 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');
                     }
@@ -322,90 +426,41 @@ async function main() {
                     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
-                // ============================================
-                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;
-                }
+                // Library Maintenance (Consolidated)
                 // ============================================
-                // 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;
                 }
                 default:
@@ -448,50 +503,63 @@ async function main() {
     console.error(`ZoteroBridge MCP Server v${SERVER_VERSION} started`);
     console.error(`Database: ${db.getPath()}`);
 }
-// Helper function to convert Zod type to JSON Schema
+// Helper function to convert Zod type to JSON Schema (Zod v4 compatible)
 function zodToJsonSchema(zodType) {
-    // Unwrap optional, default, and nullable types
-    if (zodType instanceof z.ZodOptional) {
-        return zodToJsonSchema(zodType._def.innerType);
+    // 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 {};
     }
     // Default to string