@mcp-z/mcp-drive 1.0.0

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

@@ -0,0 +1,367 @@
+"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 _types = require("@modelcontextprotocol/sdk/types.js");
+var _googleapis = require("googleapis");
+var _zod = require("zod");
+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 _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+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({
+    folderId: _zod.z.string().min(1).describe('Folder ID to get path for (or "root")')
+});
+// Success branch schema - uses items: for consistency with standard vocabulary
+var successBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    path: _zod.z.string().describe('Full path from root (e.g., /Work/Projects/2024)'),
+    items: _zod.z.array(_zod.z.object({
+        id: _zod.z.string().describe('Folder ID'),
+        name: _zod.z.string().describe('Folder name')
+    })).describe('Path items from root to target folder')
+});
+// Output schema with auth_required support
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    title: 'Get Folder Path',
+    description: 'Get full path from folder to root. Returns human-readable path and items with IDs.',
+    inputSchema: inputSchema,
+    outputSchema: _zod.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.
+ */ function resolveFolderPath(drive, folderId, logger) {
+    return _async_to_generator(function() {
+        var segments, currentId, visited, response, id, name, parents, e, pathParts, path;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    // Handle root specially
+                    if (folderId === 'root') {
+                        return [
+                            2,
+                            {
+                                path: '/',
+                                segments: [
+                                    {
+                                        id: 'root',
+                                        name: 'My Drive'
+                                    }
+                                ]
+                            }
+                        ];
+                    }
+                    segments = [];
+                    currentId = folderId;
+                    visited = new Set();
+                    _state.label = 1;
+                case 1:
+                    if (!(currentId && currentId !== 'root')) return [
+                        3,
+                        6
+                    ];
+                    // Prevent infinite loops
+                    if (visited.has(currentId)) {
+                        logger.info('Circular folder reference detected', {
+                            folderId: currentId
+                        });
+                        return [
+                            3,
+                            6
+                        ];
+                    }
+                    visited.add(currentId);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        drive.files.get({
+                            fileId: currentId,
+                            fields: 'id,name,parents'
+                        })
+                    ];
+                case 3:
+                    response = _state.sent();
+                    id = response.data.id;
+                    name = response.data.name || id;
+                    parents = response.data.parents;
+                    // Add to segments at beginning (we're walking from child to root)
+                    segments.unshift({
+                        id: id,
+                        name: name
+                    });
+                    // Move to parent
+                    currentId = (parents && parents.length > 0 ? parents[0] : '') || '';
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    e = _state.sent();
+                    logger.info('Failed to resolve folder path', {
+                        folderId: currentId,
+                        error: e
+                    });
+                    return [
+                        3,
+                        6
+                    ];
+                case 5:
+                    return [
+                        3,
+                        1
+                    ];
+                case 6:
+                    // Add root if we reached it
+                    if (currentId === 'root') {
+                        segments.unshift({
+                            id: 'root',
+                            name: 'My Drive'
+                        });
+                    }
+                    // Build path string
+                    pathParts = segments.slice(1).map(function(seg) {
+                        return seg.name;
+                    }); // Skip root
+                    path = pathParts.length > 0 ? "/".concat(pathParts.join('/')) : '/';
+                    return [
+                        2,
+                        {
+                            path: path,
+                            segments: segments
+                        }
+                    ];
+            }
+        });
+    })();
+}
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var folderId, logger, drive, pathResult, result, error, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    folderId = param.folderId;
+                    logger = extra.logger;
+                    logger.info('drive.folder.path called', {
+                        folderId: folderId
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        3,
+                        ,
+                        4
+                    ]);
+                    drive = _googleapis.google.drive({
+                        version: 'v3',
+                        auth: extra.authContext.auth
+                    });
+                    return [
+                        4,
+                        resolveFolderPath(drive, folderId, logger)
+                    ];
+                case 2:
+                    pathResult = _state.sent();
+                    logger.info('drive.folder.path returning', {
+                        path: pathResult.path,
+                        segmentCount: pathResult.segments.length
+                    });
+                    result = {
+                        type: 'success',
+                        path: pathResult.path,
+                        items: pathResult.segments
+                    };
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 3:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    logger.error('drive.folder.path error', {
+                        error: message
+                    });
+                    // Throw McpError
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error getting folder path: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'folder-path',
+        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; }

package/dist/cjs/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":["createTool","AuthRequiredBranchSchema","schemas","inputSchema","z","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","response","parents","e","pathParts","Set","has","info","add","files","get","fileId","fields","data","unshift","length","error","slice","map","seg","join","handler","extra","pathResult","message","google","version","auth","authContext","segmentCount","content","text","JSON","stringify","structuredContent","Error","String","McpError","ErrorCode","InternalError","stack","undefined"],"mappings":"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"}

package/dist/cjs/mcp/tools/folder-search.d.cts

@@ -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/cjs/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 {};