@mcp-z/mcp-drive 1.0.0

package/dist/esm/mcp/tools/folder-path.js

@@ -0,0 +1,147 @@
+import { schemas } from '@mcp-z/oauth-google';
+const { AuthRequiredBranchSchema } = schemas;
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { google } from 'googleapis';
+import { z } from 'zod';
+const inputSchema = z.object({
+    folderId: z.string().min(1).describe('Folder ID to get path for (or "root")')
+});
+// Success branch schema - uses items: for consistency with standard vocabulary
+const successBranchSchema = z.object({
+    type: z.literal('success'),
+    path: z.string().describe('Full path from root (e.g., /Work/Projects/2024)'),
+    items: z.array(z.object({
+        id: z.string().describe('Folder ID'),
+        name: z.string().describe('Folder name')
+    })).describe('Path items from root to target folder')
+});
+// Output schema with auth_required support
+const outputSchema = z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+const config = {
+    title: 'Get Folder Path',
+    description: 'Get full path from folder to root. Returns human-readable path and items with IDs.',
+    inputSchema: inputSchema,
+    outputSchema: z.object({
+        result: outputSchema
+    })
+};
+/**
+ * Resolves the full path for a folder by walking up the parent chain.
+ * Returns both the path string and structured segments with IDs and names.
+ */ async function resolveFolderPath(drive, folderId, logger) {
+    // Handle root specially
+    if (folderId === 'root') {
+        return {
+            path: '/',
+            segments: [
+                {
+                    id: 'root',
+                    name: 'My Drive'
+                }
+            ]
+        };
+    }
+    const segments = [];
+    let currentId = folderId;
+    const visited = new Set();
+    // Walk up the parent chain
+    while(currentId && currentId !== 'root'){
+        // Prevent infinite loops
+        if (visited.has(currentId)) {
+            logger.info('Circular folder reference detected', {
+                folderId: currentId
+            });
+            break;
+        }
+        visited.add(currentId);
+        // Fetch folder metadata
+        try {
+            const response = await drive.files.get({
+                fileId: currentId,
+                fields: 'id,name,parents'
+            });
+            const id = response.data.id;
+            const name = response.data.name || id;
+            const parents = response.data.parents;
+            // Add to segments at beginning (we're walking from child to root)
+            segments.unshift({
+                id,
+                name
+            });
+            // Move to parent
+            currentId = (parents && parents.length > 0 ? parents[0] : '') || '';
+        } catch (e) {
+            logger.info('Failed to resolve folder path', {
+                folderId: currentId,
+                error: e
+            });
+            break;
+        }
+    }
+    // Add root if we reached it
+    if (currentId === 'root') {
+        segments.unshift({
+            id: 'root',
+            name: 'My Drive'
+        });
+    }
+    // Build path string
+    const pathParts = segments.slice(1).map((seg)=>seg.name); // Skip root
+    const path = pathParts.length > 0 ? `/${pathParts.join('/')}` : '/';
+    return {
+        path,
+        segments
+    };
+}
+async function handler({ folderId }, extra) {
+    const logger = extra.logger;
+    logger.info('drive.folder.path called', {
+        folderId
+    });
+    try {
+        const drive = google.drive({
+            version: 'v3',
+            auth: extra.authContext.auth
+        });
+        const pathResult = await resolveFolderPath(drive, folderId, logger);
+        logger.info('drive.folder.path returning', {
+            path: pathResult.path,
+            segmentCount: pathResult.segments.length
+        });
+        const result = {
+            type: 'success',
+            path: pathResult.path,
+            items: pathResult.segments
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result)
+                }
+            ],
+            structuredContent: {
+                result
+            }
+        };
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error('drive.folder.path error', {
+            error: message
+        });
+        // Throw McpError
+        throw new McpError(ErrorCode.InternalError, `Error getting folder path: ${message}`, {
+            stack: error instanceof Error ? error.stack : undefined
+        });
+    }
+}
+export default function createTool() {
+    return {
+        name: 'folder-path',
+        config,
+        handler
+    };
+}

package/dist/esm/mcp/tools/folder-path.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-drive/src/mcp/tools/folder-path.ts"],"sourcesContent":["import type { EnrichedExtra } from '@mcp-z/oauth-google';\nimport { schemas } from '@mcp-z/oauth-google';\n\nconst { AuthRequiredBranchSchema } = schemas;\n\nimport { type CallToolResult, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';\nimport type { drive_v3 } from 'googleapis';\nimport { google } from 'googleapis';\nimport { z } from 'zod';\nimport type { Logger } from '../../types.js';\n\nconst inputSchema = z.object({\n  folderId: z.string().min(1).describe('Folder ID to get path for (or \"root\")'),\n});\n\n// Success branch schema - uses items: for consistency with standard vocabulary\nconst successBranchSchema = z.object({\n  type: z.literal('success'),\n  path: z.string().describe('Full path from root (e.g., /Work/Projects/2024)'),\n  items: z\n    .array(\n      z.object({\n        id: z.string().describe('Folder ID'),\n        name: z.string().describe('Folder name'),\n      })\n    )\n    .describe('Path items from root to target folder'),\n});\n\n// Output schema with auth_required support\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  title: 'Get Folder Path',\n  description: 'Get full path from folder to root. Returns human-readable path and items with IDs.',\n  inputSchema: inputSchema,\n  outputSchema: z.object({\n    result: outputSchema,\n  }),\n} as const;\n\nexport type Input = z.infer<typeof inputSchema>;\nexport type Output = z.infer<typeof outputSchema>;\n\n/**\n * Resolves the full path for a folder by walking up the parent chain.\n * Returns both the path string and structured segments with IDs and names.\n */\nasync function resolveFolderPath(drive: drive_v3.Drive, folderId: string, logger: Logger): Promise<{ path: string; segments: Array<{ id: string; name: string }> }> {\n  // Handle root specially\n  if (folderId === 'root') {\n    return {\n      path: '/',\n      segments: [{ id: 'root', name: 'My Drive' }],\n    };\n  }\n\n  const segments: Array<{ id: string; name: string }> = [];\n  let currentId = folderId;\n  const visited = new Set<string>();\n\n  // Walk up the parent chain\n  while (currentId && currentId !== 'root') {\n    // Prevent infinite loops\n    if (visited.has(currentId)) {\n      logger.info('Circular folder reference detected', {\n        folderId: currentId,\n      });\n      break;\n    }\n    visited.add(currentId);\n\n    // Fetch folder metadata\n    try {\n      const response = await drive.files.get({\n        fileId: currentId,\n        fields: 'id,name,parents',\n      });\n\n      const id = response.data.id as string;\n      const name = (response.data.name as string) || id;\n      const parents = response.data.parents as string[] | undefined;\n\n      // Add to segments at beginning (we're walking from child to root)\n      segments.unshift({ id, name });\n\n      // Move to parent\n      currentId = (parents && parents.length > 0 ? parents[0] : '') || '';\n    } catch (e) {\n      logger.info('Failed to resolve folder path', {\n        folderId: currentId,\n        error: e,\n      });\n      break;\n    }\n  }\n\n  // Add root if we reached it\n  if (currentId === 'root') {\n    segments.unshift({ id: 'root', name: 'My Drive' });\n  }\n\n  // Build path string\n  const pathParts = segments.slice(1).map((seg) => seg.name); // Skip root\n  const path = pathParts.length > 0 ? `/${pathParts.join('/')}` : '/';\n\n  return { path, segments };\n}\n\nasync function handler({ folderId }: Input, extra: EnrichedExtra): Promise<CallToolResult> {\n  const logger = extra.logger;\n  logger.info('drive.folder.path called', { folderId });\n\n  try {\n    const drive = google.drive({ version: 'v3', auth: extra.authContext.auth });\n\n    const pathResult = await resolveFolderPath(drive, folderId, logger);\n\n    logger.info('drive.folder.path returning', {\n      path: pathResult.path,\n      segmentCount: pathResult.segments.length,\n    });\n\n    const result: Output = {\n      type: 'success' as const,\n      path: pathResult.path,\n      items: pathResult.segments,\n    };\n\n    return {\n      content: [\n        {\n          type: 'text' as const,\n          text: JSON.stringify(result),\n        },\n      ],\n      structuredContent: { result },\n    };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    logger.error('drive.folder.path error', { error: message });\n\n    // Throw McpError\n    throw new McpError(ErrorCode.InternalError, `Error getting folder path: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'folder-path' as const,\n    config,\n    handler,\n  };\n}\n"],"names":["schemas","AuthRequiredBranchSchema","ErrorCode","McpError","google","z","inputSchema","object","folderId","string","min","describe","successBranchSchema","type","literal","path","items","array","id","name","outputSchema","discriminatedUnion","config","title","description","result","resolveFolderPath","drive","logger","segments","currentId","visited","Set","has","info","add","response","files","get","fileId","fields","data","parents","unshift","length","e","error","pathParts","slice","map","seg","join","handler","extra","version","auth","authContext","pathResult","segmentCount","content","text","JSON","stringify","structuredContent","message","Error","String","InternalError","stack","undefined","createTool"],"mappings":"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"}

package/dist/esm/mcp/tools/folder-search.d.ts

@@ -0,0 +1,139 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-google';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        objects: "objects";
+        arrays: "arrays";
+    }>>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<import("../../types.js").DriveQueryObject, unknown, z.core.$ZodTypeInternals<import("../../types.js").DriveQueryObject, unknown>>]>>;
+    fields: z.ZodOptional<z.ZodString>;
+    resolvePaths: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    shape: z.ZodLiteral<"objects">;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        mimeType: z.ZodOptional<z.ZodString>;
+        webViewLink: z.ZodOptional<z.ZodString>;
+        webContentLink: z.ZodOptional<z.ZodString>;
+        modifiedTime: z.ZodOptional<z.ZodString>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        size: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+        starred: z.ZodOptional<z.ZodBoolean>;
+        trashed: z.ZodOptional<z.ZodBoolean>;
+        parents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        owners: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodString>;
+            emailAddress: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodString>;
+            me: z.ZodOptional<z.ZodBoolean>;
+            permissionId: z.ZodOptional<z.ZodString>;
+            photoLink: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        permissions: z.ZodOptional<z.ZodObject<{
+            canEdit: z.ZodOptional<z.ZodBoolean>;
+            canComment: z.ZodOptional<z.ZodBoolean>;
+            canShare: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    shape: z.ZodLiteral<"arrays">;
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+    count: z.ZodNumber;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ query, resolvePaths, pageSize, pageToken, fields, shape }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: "folder-search";
+    config: {
+        readonly title: "Search Folders";
+        readonly description: "Search Google Drive folders with flexible field selection and optional path resolution.";
+        readonly inputSchema: z.ZodObject<{
+            shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                objects: "objects";
+                arrays: "arrays";
+            }>>>;
+            pageSize: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            pageToken: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<import("../../types.js").DriveQueryObject, unknown, z.core.$ZodTypeInternals<import("../../types.js").DriveQueryObject, unknown>>]>>;
+            fields: z.ZodOptional<z.ZodString>;
+            resolvePaths: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                shape: z.ZodLiteral<"objects">;
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    mimeType: z.ZodOptional<z.ZodString>;
+                    webViewLink: z.ZodOptional<z.ZodString>;
+                    webContentLink: z.ZodOptional<z.ZodString>;
+                    modifiedTime: z.ZodOptional<z.ZodString>;
+                    createdTime: z.ZodOptional<z.ZodString>;
+                    size: z.ZodOptional<z.ZodString>;
+                    version: z.ZodOptional<z.ZodString>;
+                    shared: z.ZodOptional<z.ZodBoolean>;
+                    starred: z.ZodOptional<z.ZodBoolean>;
+                    trashed: z.ZodOptional<z.ZodBoolean>;
+                    parents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                    }, z.core.$strip>>>;
+                    owners: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        displayName: z.ZodOptional<z.ZodString>;
+                        emailAddress: z.ZodOptional<z.ZodString>;
+                        kind: z.ZodOptional<z.ZodString>;
+                        me: z.ZodOptional<z.ZodBoolean>;
+                        permissionId: z.ZodOptional<z.ZodString>;
+                        photoLink: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    permissions: z.ZodOptional<z.ZodObject<{
+                        canEdit: z.ZodOptional<z.ZodBoolean>;
+                        canComment: z.ZodOptional<z.ZodBoolean>;
+                        canShare: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                count: z.ZodNumber;
+                nextPageToken: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                shape: z.ZodLiteral<"arrays">;
+                columns: z.ZodArray<z.ZodString>;
+                rows: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+                count: z.ZodNumber;
+                nextPageToken: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};

package/dist/esm/mcp/tools/folder-search.js

@@ -0,0 +1,343 @@
+import { schemas } from '@mcp-z/oauth-google';
+const { AuthRequiredBranchSchema } = schemas;
+import { createFieldsSchema, createPaginationSchema, createShapeSchema, filterFields, parseFields, toColumnarFormat } from '@mcp-z/server';
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { google } from 'googleapis';
+import { z } from 'zod';
+import { toDriveQuery } from '../../lib/query-builder.js';
+import { DRIVE_FILE_COMMON_PATTERNS, DRIVE_FILE_FIELD_DESCRIPTIONS, DRIVE_FILE_FIELDS, DriveFileSchema, DriveQuerySchema } from '../../schemas/index.js';
+const inputSchema = z.object({
+    query: DriveQuerySchema.optional().describe('Drive query object with structured search fields. See DriveQuerySchema for detailed query syntax and examples.'),
+    fields: createFieldsSchema({
+        availableFields: [
+            ...DRIVE_FILE_FIELDS,
+            'path'
+        ],
+        fieldDescriptions: {
+            ...DRIVE_FILE_FIELD_DESCRIPTIONS,
+            path: 'Full folder path like /Work/Projects (requires resolvePaths=true)'
+        },
+        commonPatterns: DRIVE_FILE_COMMON_PATTERNS,
+        resourceName: 'Drive folder'
+    }),
+    resolvePaths: z.boolean().optional().describe('Resolve full folder paths like /Work/Projects/2024 (requires additional API calls per result)'),
+    ...createPaginationSchema({
+        defaultPageSize: 50,
+        maxPageSize: 1000,
+        provider: 'drive'
+    }).shape,
+    shape: createShapeSchema()
+});
+// Success branch schemas for different shapes
+const successObjectsBranchSchema = z.object({
+    type: z.literal('success'),
+    shape: z.literal('objects'),
+    items: z.array(DriveFileSchema.extend({
+        path: z.string().optional().describe('Full folder path (if resolvePaths=true)')
+    })).describe('Matching Drive folders'),
+    count: z.number().describe('Number of folders in this page'),
+    nextPageToken: z.string().optional().describe('Token for fetching next page of results')
+});
+const successArraysBranchSchema = z.object({
+    type: z.literal('success'),
+    shape: z.literal('arrays'),
+    columns: z.array(z.string()).describe('Column names in canonical order'),
+    rows: z.array(z.array(z.unknown())).describe('Row data matching column order'),
+    count: z.number().describe('Number of folders in this page'),
+    nextPageToken: z.string().optional().describe('Token for fetching next page of results')
+});
+// Output schema with auth_required support
+// Using z.union instead of discriminatedUnion since we have two success branches with different shapes
+const outputSchema = z.union([
+    successObjectsBranchSchema,
+    successArraysBranchSchema,
+    AuthRequiredBranchSchema
+]);
+const config = {
+    title: 'Search Folders',
+    description: 'Search Google Drive folders with flexible field selection and optional path resolution.',
+    inputSchema: inputSchema,
+    outputSchema: z.object({
+        result: outputSchema
+    })
+};
+/**
+ * Resolves the full path for a folder by walking up the parent chain
+ * Caches folder names to reduce redundant API calls
+ */ async function resolveFolderPath(drive, folderId, folderCache, logger) {
+    if (folderId === 'root') return '/';
+    const pathParts = [];
+    let currentId = folderId;
+    const visited = new Set();
+    while(currentId && currentId !== 'root'){
+        // Prevent infinite loops
+        if (visited.has(currentId)) {
+            logger.info('Circular folder reference detected', {
+                folderId: currentId
+            });
+            break;
+        }
+        visited.add(currentId);
+        // Check cache first
+        if (folderCache.has(currentId)) {
+            const cachedName = folderCache.get(currentId);
+            if (cachedName) {
+                pathParts.unshift(cachedName);
+            }
+            // Get parent of cached folder
+            try {
+                const response = await drive.files.get({
+                    fileId: currentId,
+                    fields: 'parents'
+                });
+                const parents = response.data.parents;
+                currentId = (parents && parents.length > 0 ? parents[0] : '') || '';
+            } catch (_e) {
+                logger.info('Failed to get parent for cached folder', {
+                    folderId: currentId
+                });
+                break;
+            }
+        } else {
+            // Fetch folder metadata
+            try {
+                const response = await drive.files.get({
+                    fileId: currentId,
+                    fields: 'name,parents'
+                });
+                const folderName = response.data.name;
+                const parents = response.data.parents;
+                if (folderName) {
+                    folderCache.set(currentId, folderName);
+                    pathParts.unshift(folderName);
+                }
+                currentId = (parents && parents.length > 0 ? parents[0] : '') || '';
+            } catch (e) {
+                logger.info('Failed to resolve folder path', {
+                    folderId: currentId,
+                    error: e
+                });
+                break;
+            }
+        }
+    }
+    return `/${pathParts.join('/')}`;
+}
+async function handler({ query, resolvePaths = false, pageSize = 50, pageToken, fields, shape = 'arrays' }, extra) {
+    const logger = extra.logger;
+    const requestedFields = parseFields(fields, [
+        ...DRIVE_FILE_FIELDS,
+        'path'
+    ]);
+    // Validate and clamp pageSize to Google Drive API limits (1-1000)
+    const validPageSize = Math.max(1, Math.min(1000, Math.floor(pageSize || 50)));
+    logger.info('drive.folder.search called', {
+        query,
+        resolvePaths,
+        pageSize: validPageSize,
+        pageToken: pageToken ? '[provided]' : undefined,
+        fields: fields || 'all'
+    });
+    try {
+        const drive = google.drive({
+            version: 'v3',
+            auth: extra.authContext.auth
+        });
+        const folderMimeType = 'application/vnd.google-apps.folder';
+        let qStr;
+        if (typeof query === 'string') {
+            // String query - treat as raw Drive query
+            qStr = `(${query}) and mimeType='${folderMimeType}' and trashed = false`;
+        } else if (query && typeof query === 'object' && 'rawDriveQuery' in query && query.rawDriveQuery) {
+            // Object with rawDriveQuery field - use it directly
+            qStr = `(${query.rawDriveQuery}) and mimeType='${folderMimeType}' and trashed = false`;
+        } else if (query) {
+            // Structured query object - convert to Drive query string
+            const { q } = toDriveQuery(query);
+            qStr = q ? `(${q}) and mimeType='${folderMimeType}' and trashed = false` : `mimeType='${folderMimeType}' and trashed = false`;
+        } else {
+            // No query - return all folders
+            qStr = `mimeType='${folderMimeType}' and trashed = false`;
+        }
+        const listOptions = {
+            q: qStr,
+            pageSize: validPageSize,
+            fields: 'files(id,name,mimeType,webViewLink,modifiedTime,parents,shared,starred,owners),nextPageToken',
+            orderBy: 'modifiedTime desc'
+        };
+        if (pageToken && pageToken.trim().length > 0) {
+            listOptions.pageToken = pageToken;
+        }
+        const response = await drive.files.list(listOptions);
+        const res = response.data;
+        const folders = Array.isArray(res === null || res === void 0 ? void 0 : res.files) ? res.files : [];
+        const parentIds = new Set();
+        for (const f of folders){
+            if ((f === null || f === void 0 ? void 0 : f.parents) && f.parents.length > 0) {
+                for (const parentId of f.parents){
+                    if (parentId && parentId !== 'root') {
+                        parentIds.add(parentId);
+                    }
+                }
+            }
+        }
+        const parentNameMap = new Map();
+        if (parentIds.size > 0) {
+            logger.info('Fetching parent names', {
+                count: parentIds.size
+            });
+            const parentFetches = Array.from(parentIds).map(async (parentId)=>{
+                try {
+                    const parentRes = await drive.files.get({
+                        fileId: parentId,
+                        fields: 'id,name'
+                    });
+                    const parentName = parentRes.data.name || parentId;
+                    parentNameMap.set(parentId, parentName);
+                } catch (e) {
+                    logger.info('Failed to fetch parent name', {
+                        parentId,
+                        error: e
+                    });
+                    parentNameMap.set(parentId, parentId); // Fallback to ID
+                }
+            });
+            await Promise.all(parentFetches);
+        }
+        // Cache for folder names to reduce API calls during path resolution
+        const folderCache = new Map();
+        const items = await Promise.all(folders.map(async (f)=>{
+            const id = (f === null || f === void 0 ? void 0 : f.id) ? String(f.id) : 'unknown';
+            const name = (f === null || f === void 0 ? void 0 : f.name) || id;
+            const result = {
+                id,
+                name
+            };
+            // Only include properties that have actual values
+            if (f === null || f === void 0 ? void 0 : f.mimeType) result.mimeType = f.mimeType;
+            if (f === null || f === void 0 ? void 0 : f.webViewLink) result.webViewLink = f.webViewLink;
+            if (f === null || f === void 0 ? void 0 : f.modifiedTime) result.modifiedTime = f.modifiedTime;
+            // Build parent objects with names
+            if ((f === null || f === void 0 ? void 0 : f.parents) && f.parents.length > 0) {
+                result.parents = f.parents.map((parentId)=>{
+                    if (parentId === 'root') {
+                        return {
+                            id: 'root',
+                            name: 'My Drive'
+                        };
+                    }
+                    const parentName = parentNameMap.get(parentId) || parentId;
+                    return {
+                        id: parentId,
+                        name: parentName
+                    };
+                });
+            }
+            if ((f === null || f === void 0 ? void 0 : f.shared) !== undefined) result.shared = f.shared;
+            if ((f === null || f === void 0 ? void 0 : f.starred) !== undefined) result.starred = f.starred;
+            if ((f === null || f === void 0 ? void 0 : f.owners) && f.owners.length > 0) {
+                result.owners = f.owners.map((o)=>{
+                    const owner = {};
+                    if (o === null || o === void 0 ? void 0 : o.displayName) owner.displayName = o.displayName;
+                    if (o === null || o === void 0 ? void 0 : o.emailAddress) owner.emailAddress = o.emailAddress;
+                    if (o === null || o === void 0 ? void 0 : o.kind) owner.kind = o.kind;
+                    if ((o === null || o === void 0 ? void 0 : o.me) !== undefined) owner.me = o.me;
+                    if (o === null || o === void 0 ? void 0 : o.permissionId) owner.permissionId = o.permissionId;
+                    if (o === null || o === void 0 ? void 0 : o.photoLink) owner.photoLink = o.photoLink;
+                    return owner;
+                });
+            }
+            // Resolve path if requested
+            if (resolvePaths && id !== 'unknown') {
+                result.path = await resolveFolderPath(drive, id, folderCache, logger);
+            }
+            return result;
+        }));
+        const filteredItems = items.map((item)=>filterFields(item, requestedFields));
+        logger.info('drive.folder.search returning', {
+            query,
+            pageSize,
+            resultCount: filteredItems.length,
+            resolvePaths,
+            fields: fields || 'all'
+        });
+        const nextPageToken = res.nextPageToken && res.nextPageToken.trim().length > 0 ? res.nextPageToken : undefined;
+        // Build result based on shape
+        const result = shape === 'arrays' ? {
+            type: 'success',
+            shape: 'arrays',
+            ...toColumnarFormat(filteredItems, requestedFields, [
+                ...DRIVE_FILE_FIELDS,
+                'path'
+            ]),
+            count: filteredItems.length,
+            ...nextPageToken && {
+                nextPageToken
+            }
+        } : {
+            type: 'success',
+            shape: 'objects',
+            items: filteredItems,
+            count: filteredItems.length,
+            ...nextPageToken && {
+                nextPageToken
+            }
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result)
+                }
+            ],
+            structuredContent: {
+                result
+            }
+        };
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error('drive.folder.search error', {
+            error: message
+        });
+        // Check if this is a Drive API validation error (invalid query, invalid pageToken, etc.)
+        // These should return empty results rather than throw
+        const isDriveValidationError = message.includes('Invalid Value') || message.includes('Invalid value') || message.includes('File not found') || message.includes('Bad Request');
+        if (isDriveValidationError) {
+            // Return empty result set for validation errors
+            const result = shape === 'arrays' ? {
+                type: 'success',
+                shape: 'arrays',
+                columns: [],
+                rows: [],
+                count: 0
+            } : {
+                type: 'success',
+                shape: 'objects',
+                items: [],
+                count: 0
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result)
+                    }
+                ],
+                structuredContent: {
+                    result
+                }
+            };
+        }
+        // Throw McpError for other errors
+        throw new McpError(ErrorCode.InternalError, `Error searching folders: ${message}`, {
+            stack: error instanceof Error ? error.stack : undefined
+        });
+    }
+}
+export default function createTool() {
+    return {
+        name: 'folder-search',
+        config,
+        handler
+    };
+}