@mcp-z/mcp-drive 1.0.0

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

@@ -0,0 +1,760 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _oauthgoogle = require("@mcp-z/oauth-google");
+var _server = require("@mcp-z/server");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _googleapis = require("googleapis");
+var _zod = require("zod");
+var _querybuilder = require("../../lib/query-builder.js");
+var _index = require("../../schemas/index.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var AuthRequiredBranchSchema = _oauthgoogle.schemas.AuthRequiredBranchSchema;
+var inputSchema = _zod.z.object(_object_spread_props(_object_spread({
+    query: _index.DriveQuerySchema.optional().describe('Drive query object with structured search fields. See DriveQuerySchema for detailed query syntax and examples.'),
+    fields: (0, _server.createFieldsSchema)({
+        availableFields: _to_consumable_array(_index.DRIVE_FILE_FIELDS).concat([
+            'path'
+        ]),
+        fieldDescriptions: _object_spread_props(_object_spread({}, _index.DRIVE_FILE_FIELD_DESCRIPTIONS), {
+            path: 'Full folder path like /Work/Projects (requires resolvePaths=true)'
+        }),
+        commonPatterns: _index.DRIVE_FILE_COMMON_PATTERNS,
+        resourceName: 'Drive folder'
+    }),
+    resolvePaths: _zod.z.boolean().optional().describe('Resolve full folder paths like /Work/Projects/2024 (requires additional API calls per result)')
+}, (0, _server.createPaginationSchema)({
+    defaultPageSize: 50,
+    maxPageSize: 1000,
+    provider: 'drive'
+}).shape), {
+    shape: (0, _server.createShapeSchema)()
+}));
+// Success branch schemas for different shapes
+var successObjectsBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    shape: _zod.z.literal('objects'),
+    items: _zod.z.array(_index.DriveFileSchema.extend({
+        path: _zod.z.string().optional().describe('Full folder path (if resolvePaths=true)')
+    })).describe('Matching Drive folders'),
+    count: _zod.z.number().describe('Number of folders in this page'),
+    nextPageToken: _zod.z.string().optional().describe('Token for fetching next page of results')
+});
+var successArraysBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    shape: _zod.z.literal('arrays'),
+    columns: _zod.z.array(_zod.z.string()).describe('Column names in canonical order'),
+    rows: _zod.z.array(_zod.z.array(_zod.z.unknown())).describe('Row data matching column order'),
+    count: _zod.z.number().describe('Number of folders in this page'),
+    nextPageToken: _zod.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
+var outputSchema = _zod.z.union([
+    successObjectsBranchSchema,
+    successArraysBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    title: 'Search Folders',
+    description: 'Search Google Drive folders with flexible field selection and optional path resolution.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.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
+ */ function resolveFolderPath(drive, folderId, folderCache, logger) {
+    return _async_to_generator(function() {
+        var pathParts, currentId, visited, cachedName, response, parents, _e, response1, folderName, parents1, e;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (folderId === 'root') return [
+                        2,
+                        '/'
+                    ];
+                    pathParts = [];
+                    currentId = folderId;
+                    visited = new Set();
+                    _state.label = 1;
+                case 1:
+                    if (!(currentId && currentId !== 'root')) return [
+                        3,
+                        10
+                    ];
+                    // Prevent infinite loops
+                    if (visited.has(currentId)) {
+                        logger.info('Circular folder reference detected', {
+                            folderId: currentId
+                        });
+                        return [
+                            3,
+                            10
+                        ];
+                    }
+                    visited.add(currentId);
+                    if (!folderCache.has(currentId)) return [
+                        3,
+                        6
+                    ];
+                    cachedName = folderCache.get(currentId);
+                    if (cachedName) {
+                        pathParts.unshift(cachedName);
+                    }
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        drive.files.get({
+                            fileId: currentId,
+                            fields: 'parents'
+                        })
+                    ];
+                case 3:
+                    response = _state.sent();
+                    parents = response.data.parents;
+                    currentId = (parents && parents.length > 0 ? parents[0] : '') || '';
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    _e = _state.sent();
+                    logger.info('Failed to get parent for cached folder', {
+                        folderId: currentId
+                    });
+                    return [
+                        3,
+                        10
+                    ];
+                case 5:
+                    return [
+                        3,
+                        9
+                    ];
+                case 6:
+                    _state.trys.push([
+                        6,
+                        8,
+                        ,
+                        9
+                    ]);
+                    return [
+                        4,
+                        drive.files.get({
+                            fileId: currentId,
+                            fields: 'name,parents'
+                        })
+                    ];
+                case 7:
+                    response1 = _state.sent();
+                    folderName = response1.data.name;
+                    parents1 = response1.data.parents;
+                    if (folderName) {
+                        folderCache.set(currentId, folderName);
+                        pathParts.unshift(folderName);
+                    }
+                    currentId = (parents1 && parents1.length > 0 ? parents1[0] : '') || '';
+                    return [
+                        3,
+                        9
+                    ];
+                case 8:
+                    e = _state.sent();
+                    logger.info('Failed to resolve folder path', {
+                        folderId: currentId,
+                        error: e
+                    });
+                    return [
+                        3,
+                        10
+                    ];
+                case 9:
+                    return [
+                        3,
+                        1
+                    ];
+                case 10:
+                    return [
+                        2,
+                        "/".concat(pathParts.join('/'))
+                    ];
+            }
+        });
+    })();
+}
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var query, _param_resolvePaths, resolvePaths, _param_pageSize, pageSize, pageToken, fields, _param_shape, shape, logger, requestedFields, validPageSize, drive, folderMimeType, qStr, q, listOptions, response, res, folders, parentIds, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, f, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, parentId, parentNameMap, parentFetches, folderCache, items, filteredItems, nextPageToken, result, error, message, isDriveValidationError, result1;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    query = param.query, _param_resolvePaths = param.resolvePaths, resolvePaths = _param_resolvePaths === void 0 ? false : _param_resolvePaths, _param_pageSize = param.pageSize, pageSize = _param_pageSize === void 0 ? 50 : _param_pageSize, pageToken = param.pageToken, fields = param.fields, _param_shape = param.shape, shape = _param_shape === void 0 ? 'arrays' : _param_shape;
+                    logger = extra.logger;
+                    requestedFields = (0, _server.parseFields)(fields, _to_consumable_array(_index.DRIVE_FILE_FIELDS).concat([
+                        'path'
+                    ]));
+                    // Validate and clamp pageSize to Google Drive API limits (1-1000)
+                    validPageSize = Math.max(1, Math.min(1000, Math.floor(pageSize || 50)));
+                    logger.info('drive.folder.search called', {
+                        query: query,
+                        resolvePaths: resolvePaths,
+                        pageSize: validPageSize,
+                        pageToken: pageToken ? '[provided]' : undefined,
+                        fields: fields || 'all'
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        ,
+                        7
+                    ]);
+                    drive = _googleapis.google.drive({
+                        version: 'v3',
+                        auth: extra.authContext.auth
+                    });
+                    folderMimeType = 'application/vnd.google-apps.folder';
+                    if (typeof query === 'string') {
+                        // String query - treat as raw Drive query
+                        qStr = "(".concat(query, ") and mimeType='").concat(folderMimeType, "' and trashed = false");
+                    } else if (query && (typeof query === "undefined" ? "undefined" : _type_of(query)) === 'object' && 'rawDriveQuery' in query && query.rawDriveQuery) {
+                        // Object with rawDriveQuery field - use it directly
+                        qStr = "(".concat(query.rawDriveQuery, ") and mimeType='").concat(folderMimeType, "' and trashed = false");
+                    } else if (query) {
+                        // Structured query object - convert to Drive query string
+                        q = (0, _querybuilder.toDriveQuery)(query).q;
+                        qStr = q ? "(".concat(q, ") and mimeType='").concat(folderMimeType, "' and trashed = false") : "mimeType='".concat(folderMimeType, "' and trashed = false");
+                    } else {
+                        // No query - return all folders
+                        qStr = "mimeType='".concat(folderMimeType, "' and trashed = false");
+                    }
+                    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;
+                    }
+                    return [
+                        4,
+                        drive.files.list(listOptions)
+                    ];
+                case 2:
+                    response = _state.sent();
+                    res = response.data;
+                    folders = Array.isArray(res === null || res === void 0 ? void 0 : res.files) ? res.files : [];
+                    parentIds = new Set();
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = folders[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            f = _step.value;
+                            if ((f === null || f === void 0 ? void 0 : f.parents) && f.parents.length > 0) {
+                                _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                try {
+                                    for(_iterator1 = f.parents[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                        parentId = _step1.value;
+                                        if (parentId && parentId !== 'root') {
+                                            parentIds.add(parentId);
+                                        }
+                                    }
+                                } catch (err) {
+                                    _didIteratorError1 = true;
+                                    _iteratorError1 = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                            _iterator1.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError1) {
+                                            throw _iteratorError1;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    parentNameMap = new Map();
+                    if (!(parentIds.size > 0)) return [
+                        3,
+                        4
+                    ];
+                    logger.info('Fetching parent names', {
+                        count: parentIds.size
+                    });
+                    parentFetches = Array.from(parentIds).map(function(parentId) {
+                        return _async_to_generator(function() {
+                            var parentRes, parentName, e;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        _state.trys.push([
+                                            0,
+                                            2,
+                                            ,
+                                            3
+                                        ]);
+                                        return [
+                                            4,
+                                            drive.files.get({
+                                                fileId: parentId,
+                                                fields: 'id,name'
+                                            })
+                                        ];
+                                    case 1:
+                                        parentRes = _state.sent();
+                                        parentName = parentRes.data.name || parentId;
+                                        parentNameMap.set(parentId, parentName);
+                                        return [
+                                            3,
+                                            3
+                                        ];
+                                    case 2:
+                                        e = _state.sent();
+                                        logger.info('Failed to fetch parent name', {
+                                            parentId: parentId,
+                                            error: e
+                                        });
+                                        parentNameMap.set(parentId, parentId); // Fallback to ID
+                                        return [
+                                            3,
+                                            3
+                                        ];
+                                    case 3:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        })();
+                    });
+                    return [
+                        4,
+                        Promise.all(parentFetches)
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    // Cache for folder names to reduce API calls during path resolution
+                    folderCache = new Map();
+                    return [
+                        4,
+                        Promise.all(folders.map(function(f) {
+                            return _async_to_generator(function() {
+                                var id, name, result;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            id = (f === null || f === void 0 ? void 0 : f.id) ? String(f.id) : 'unknown';
+                                            name = (f === null || f === void 0 ? void 0 : f.name) || id;
+                                            result = {
+                                                id: id,
+                                                name: 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(function(parentId) {
+                                                    if (parentId === 'root') {
+                                                        return {
+                                                            id: 'root',
+                                                            name: 'My Drive'
+                                                        };
+                                                    }
+                                                    var 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(function(o) {
+                                                    var 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;
+                                                });
+                                            }
+                                            if (!(resolvePaths && id !== 'unknown')) return [
+                                                3,
+                                                2
+                                            ];
+                                            return [
+                                                4,
+                                                resolveFolderPath(drive, id, folderCache, logger)
+                                            ];
+                                        case 1:
+                                            result.path = _state.sent();
+                                            _state.label = 2;
+                                        case 2:
+                                            return [
+                                                2,
+                                                result
+                                            ];
+                                    }
+                                });
+                            })();
+                        }))
+                    ];
+                case 5:
+                    items = _state.sent();
+                    filteredItems = items.map(function(item) {
+                        return (0, _server.filterFields)(item, requestedFields);
+                    });
+                    logger.info('drive.folder.search returning', {
+                        query: query,
+                        pageSize: pageSize,
+                        resultCount: filteredItems.length,
+                        resolvePaths: resolvePaths,
+                        fields: fields || 'all'
+                    });
+                    nextPageToken = res.nextPageToken && res.nextPageToken.trim().length > 0 ? res.nextPageToken : undefined;
+                    // Build result based on shape
+                    result = shape === 'arrays' ? _object_spread(_object_spread_props(_object_spread({
+                        type: 'success',
+                        shape: 'arrays'
+                    }, (0, _server.toColumnarFormat)(filteredItems, requestedFields, _to_consumable_array(_index.DRIVE_FILE_FIELDS).concat([
+                        'path'
+                    ]))), {
+                        count: filteredItems.length
+                    }), nextPageToken && {
+                        nextPageToken: nextPageToken
+                    }) : _object_spread({
+                        type: 'success',
+                        shape: 'objects',
+                        items: filteredItems,
+                        count: filteredItems.length
+                    }, nextPageToken && {
+                        nextPageToken: nextPageToken
+                    });
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 6:
+                    error = _state.sent();
+                    message = _instanceof(error, 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
+                    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
+                        result1 = shape === 'arrays' ? {
+                            type: 'success',
+                            shape: 'arrays',
+                            columns: [],
+                            rows: [],
+                            count: 0
+                        } : {
+                            type: 'success',
+                            shape: 'objects',
+                            items: [],
+                            count: 0
+                        };
+                        return [
+                            2,
+                            {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: JSON.stringify(result1)
+                                    }
+                                ],
+                                structuredContent: {
+                                    result: result1
+                                }
+                            }
+                        ];
+                    }
+                    // Throw McpError for other errors
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error searching folders: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 7:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'folder-search',
+        config: config,
+        handler: handler
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }