@piotr-agier/google-drive-mcp 1.1.2 → 1.2.0

package/README.md

@@ -7,6 +7,7 @@ A Model Context Protocol (MCP) server that provides secure integration with Goog
 - **Multi-format Support**: Work with Google Docs, Sheets, Slides, and regular files
 - **File Management**: Create, update, delete, rename, and move files and folders
 - **Advanced Search**: Search across your entire Google Drive
+- **Shared Drives Support**: Full access to Google Shared Drives (formerly Team Drives) in addition to My Drive
 - **Folder Navigation**: List and navigate through folder hierarchies with path support (e.g., `/Work/Projects`)
 - **MCP Resource Protocol**: Files accessible as MCP resources for reading content
 - **Secure Authentication**: OAuth 2.0 with automatic token refresh
@@ -496,6 +497,18 @@ Add the server to your Claude Desktop configuration:
   - `x`, `y`, `width`, `height`: Position/size in EMU
   - `backgroundColor`: Fill color (RGBA 0-1) (optional)
 
+### Speaker Notes
+
+- **getGoogleSlidesSpeakerNotes** - Get speaker notes from a slide
+  - `presentationId`: Presentation ID
+  - `slideIndex`: Slide index (0-based)
+  - Returns the speaker notes text or a message if no notes exist
+
+- **updateGoogleSlidesSpeakerNotes** - Update or set speaker notes for a slide
+  - `presentationId`: Presentation ID
+  - `slideIndex`: Slide index (0-based)
+  - `notes`: The speaker notes content to set
+
 ## Authentication Flow
 
 The server uses OAuth 2.0 for secure authentication:

package/dist/index.js

@@ -578,7 +578,7 @@ async function authenticate() {
 // src/index.ts
 import { z } from "zod";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { readFileSync } from "fs";
+import { readFileSync, createReadStream, existsSync, statSync } from "fs";
 import { join as join2, dirname as dirname3 } from "path";
 var drive = null;
 function ensureDriveService() {
@@ -619,6 +619,45 @@ var TEXT_MIME_TYPES = {
   txt: "text/plain",
   md: "text/markdown"
 };
+var BINARY_MIME_TYPES = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  opus: "audio/opus",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  avi: "video/x-msvideo",
+  mov: "video/quicktime",
+  mkv: "video/x-matroska",
+  "3gp": "video/3gpp",
+  pdf: "application/pdf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  json: "application/json",
+  xml: "application/xml",
+  csv: "text/csv",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
 var authClient = null;
 var authenticationPromise = null;
 var __filename = fileURLToPath2(import.meta.url);
@@ -647,7 +686,9 @@ async function resolvePath(pathStr) {
     let response = await drive.files.list({
       q: `'${currentFolderId}' in parents and name = '${part}' and mimeType = '${FOLDER_MIME_TYPE}' and trashed = false`,
       fields: "files(id)",
-      spaces: "drive"
+      spaces: "drive",
+      includeItemsFromAllDrives: true,
+      supportsAllDrives: true
     });
     if (!response.data.files?.length) {
       const folderMetadata = {
@@ -657,7 +698,8 @@ async function resolvePath(pathStr) {
       };
       const folder = await drive.files.create({
         requestBody: folderMetadata,
-        fields: "id"
+        fields: "id",
+        supportsAllDrives: true
       });
       if (!folder.data.id) {
         throw new Error(`Failed to create intermediate folder: ${part}`);
@@ -719,7 +761,9 @@ async function checkFileExists(name, parentFolderId = "root") {
     const res = await drive.files.list({
       q: query,
       fields: "files(id, name, mimeType)",
-      pageSize: 1
+      pageSize: 1,
+      includeItemsFromAllDrives: true,
+      supportsAllDrives: true
     });
     if (res.data.files && res.data.files.length > 0) {
       return res.data.files[0].id || null;
@@ -777,12 +821,14 @@ var UpdateGoogleDocSchema = z.object({
 var CreateGoogleSheetSchema = z.object({
   name: z.string().min(1, "Sheet name is required"),
   data: z.array(z.array(z.string())),
-  parentFolderId: z.string().optional()
+  parentFolderId: z.string().optional(),
+  valueInputOption: z.enum(["RAW", "USER_ENTERED"]).optional()
 });
 var UpdateGoogleSheetSchema = z.object({
   spreadsheetId: z.string().min(1, "Spreadsheet ID is required"),
   range: z.string().min(1, "Range is required"),
-  data: z.array(z.array(z.string()))
+  data: z.array(z.array(z.string())),
+  valueInputOption: z.enum(["RAW", "USER_ENTERED"]).optional()
 });
 var GetGoogleSheetContentSchema = z.object({
   spreadsheetId: z.string().min(1, "Spreadsheet ID is required"),
@@ -991,6 +1037,21 @@ var CreateGoogleSlidesShapeSchema = z.object({
     alpha: z.number().min(0).max(1).optional()
   }).optional()
 });
+var GetGoogleSlidesSpeakerNotesSchema = z.object({
+  presentationId: z.string().min(1, "Presentation ID is required"),
+  slideIndex: z.number().min(0, "Slide index must be non-negative")
+});
+var UpdateGoogleSlidesSpeakerNotesSchema = z.object({
+  presentationId: z.string().min(1, "Presentation ID is required"),
+  slideIndex: z.number().min(0, "Slide index must be non-negative"),
+  notes: z.string()
+});
+var UploadFileSchema = z.object({
+  localPath: z.string().min(1, "Local file path is required"),
+  name: z.string().optional(),
+  parentFolderId: z.string().optional(),
+  mimeType: z.string().optional()
+});
 var server = new Server(
   {
     name: "google-drive-mcp",
@@ -1033,7 +1094,9 @@ server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
   const params = {
     pageSize,
     fields: "nextPageToken, files(id, name, mimeType)",
-    q: `trashed = false`
+    q: `trashed = false`,
+    includeItemsFromAllDrives: true,
+    supportsAllDrives: true
   };
   if (request.params?.cursor) {
     params.pageToken = request.params.cursor;
@@ -1056,7 +1119,8 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
   const fileId = request.params.uri.replace("gdrive:///", "");
   const file = await drive.files.get({
     fileId,
-    fields: "mimeType"
+    fields: "mimeType",
+    supportsAllDrives: true
   });
   const mimeType = file.data.mimeType;
   if (!mimeType) {
@@ -1082,7 +1146,7 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         break;
     }
     const res = await drive.files.export(
-      { fileId, mimeType: exportMimeType },
+      { fileId, mimeType: exportMimeType, supportsAllDrives: true },
       { responseType: "text" }
     );
     log("Successfully read resource", { fileId, mimeType });
@@ -1097,7 +1161,7 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     };
   } else {
     const res = await drive.files.get(
-      { fileId, alt: "media" },
+      { fileId, alt: "media", supportsAllDrives: true },
       { responseType: "arraybuffer" }
     );
     const contentMime = mimeType || "application/octet-stream";
@@ -1252,7 +1316,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "createGoogleSheet",
-        description: "Create a new Google Sheet",
+        description: "Create a new Google Sheet. By default uses RAW mode which stores values as-is. Set valueInputOption to 'USER_ENTERED' only when you need formulas to be evaluated.",
         inputSchema: {
           type: "object",
           properties: {
@@ -1262,22 +1326,33 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
               description: "Data as array of arrays",
               items: { type: "array", items: { type: "string" } }
             },
-            parentFolderId: { type: "string", description: "Parent folder ID (defaults to root)", optional: true }
+            parentFolderId: { type: "string", description: "Parent folder ID (defaults to root)", optional: true },
+            valueInputOption: {
+              type: "string",
+              enum: ["RAW", "USER_ENTERED"],
+              description: "RAW (default): Values stored exactly as provided - formulas stored as text strings. Safe for untrusted data. USER_ENTERED: Values parsed like spreadsheet UI - formulas (=SUM, =IF, etc.) are evaluated. SECURITY WARNING: USER_ENTERED can execute formulas, only use with trusted data, never with user-provided input that could contain malicious formulas like =IMPORTDATA() or =IMPORTRANGE()."
+            }
           },
           required: ["name", "data"]
         }
       },
       {
         name: "updateGoogleSheet",
-        description: "Update an existing Google Sheet",
+        description: "Update an existing Google Sheet. By default uses RAW mode which stores values as-is. Set valueInputOption to 'USER_ENTERED' only when you need formulas to be evaluated.",
         inputSchema: {
           type: "object",
           properties: {
             spreadsheetId: { type: "string", description: "Sheet ID" },
-            range: { type: "string", description: "Range to update" },
+            range: { type: "string", description: "Range to update (e.g., 'Sheet1!A1:C10')" },
             data: {
               type: "array",
+              description: "2D array of values to write",
               items: { type: "array", items: { type: "string" } }
+            },
+            valueInputOption: {
+              type: "string",
+              enum: ["RAW", "USER_ENTERED"],
+              description: "RAW (default): Values stored exactly as provided - formulas stored as text strings. Safe for untrusted data. USER_ENTERED: Values parsed like spreadsheet UI - formulas (=SUM, =IF, etc.) are evaluated. SECURITY WARNING: USER_ENTERED can execute formulas, only use with trusted data, never with user-provided input that could contain malicious formulas like =IMPORTDATA() or =IMPORTRANGE()."
             }
           },
           required: ["spreadsheetId", "range", "data"]
@@ -1787,6 +1862,45 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           },
           required: ["presentationId", "pageObjectId", "shapeType", "x", "y", "width", "height"]
         }
+      },
+      {
+        name: "getGoogleSlidesSpeakerNotes",
+        description: "Get speaker notes from a specific slide in Google Slides",
+        inputSchema: {
+          type: "object",
+          properties: {
+            presentationId: { type: "string", description: "Presentation ID" },
+            slideIndex: { type: "number", description: "Slide index (0-based)" }
+          },
+          required: ["presentationId", "slideIndex"]
+        }
+      },
+      {
+        name: "updateGoogleSlidesSpeakerNotes",
+        description: "Update speaker notes for a specific slide in Google Slides",
+        inputSchema: {
+          type: "object",
+          properties: {
+            presentationId: { type: "string", description: "Presentation ID" },
+            slideIndex: { type: "number", description: "Slide index (0-based)" },
+            notes: { type: "string", description: "Speaker notes content" }
+          },
+          required: ["presentationId", "slideIndex", "notes"]
+        }
+      },
+      {
+        name: "uploadFile",
+        description: "Upload a local file (any type: image, audio, video, PDF, etc.) to Google Drive",
+        inputSchema: {
+          type: "object",
+          properties: {
+            localPath: { type: "string", description: "Absolute path to the local file to upload" },
+            name: { type: "string", description: "File name in Drive (defaults to local filename)", optional: true },
+            parentFolderId: { type: "string", description: "Parent folder ID or path (e.g., '/Work/Projects'). Creates folders if needed. Defaults to root.", optional: true },
+            mimeType: { type: "string", description: "MIME type (auto-detected from extension if omitted)", optional: true }
+          },
+          required: ["localPath"]
+        }
       }
     ]
   };
@@ -1814,9 +1928,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           q: formattedQuery,
           pageSize: Math.min(pageSize || 50, 100),
           pageToken,
-          fields: "nextPageToken, files(id, name, mimeType, modifiedTime, size)"
+          fields: "nextPageToken, files(id, name, mimeType, modifiedTime, size)",
+          includeItemsFromAllDrives: true,
+          supportsAllDrives: true
         });
-        const fileList = res.data.files?.map((f) => `${f.name} (${f.mimeType})`).join("\n") || "";
+        const fileList = res.data.files?.map((f) => `${f.name} (ID: ${f.id}, ${f.mimeType})`).join("\n") || "";
         log("Search results", { query: userQuery, resultCount: res.data.files?.length });
         let response = `Found ${res.data.files?.length ?? 0} files:
 ${fileList}`;
@@ -1860,7 +1976,8 @@ More results available. Use pageToken: ${res.data.nextPageToken}`;
           media: {
             mimeType: fileMetadata.mimeType,
             body: args.content
-          }
+          },
+          supportsAllDrives: true
         });
         log("File created successfully", { fileId: file.data?.id });
         return {
@@ -1880,7 +1997,8 @@ ID: ${file.data?.id || "unknown"}`
         const args = validation.data;
         const existingFile = await drive.files.get({
           fileId: args.fileId,
-          fields: "mimeType, name, parents"
+          fields: "mimeType, name, parents",
+          supportsAllDrives: true
         });
         const currentMimeType = existingFile.data.mimeType || "text/plain";
         if (!Object.values(TEXT_MIME_TYPES).includes(currentMimeType)) {
@@ -1899,7 +2017,8 @@ ID: ${file.data?.id || "unknown"}`
             mimeType: updateMetadata.mimeType || currentMimeType,
             body: args.content
           },
-          fields: "id, name, modifiedTime, webViewLink"
+          fields: "id, name, modifiedTime, webViewLink",
+          supportsAllDrives: true
         });
         return {
           content: [{
@@ -1930,7 +2049,8 @@ Modified: ${updatedFile.data.modifiedTime}`
         };
         const folder = await drive.files.create({
           requestBody: folderMetadata,
-          fields: "id, name, webViewLink"
+          fields: "id, name, webViewLink",
+          supportsAllDrives: true
         });
         log("Folder created successfully", { folderId: folder.data.id, name: folder.data.name });
         return {
@@ -1954,7 +2074,9 @@ ID: ${folder.data.id}`
           pageSize: Math.min(args.pageSize || 50, 100),
           pageToken: args.pageToken,
           fields: "nextPageToken, files(id, name, mimeType, modifiedTime, size)",
-          orderBy: "name"
+          orderBy: "name",
+          includeItemsFromAllDrives: true,
+          supportsAllDrives: true
         });
         const files = res.data.files || [];
         const formattedFiles = files.map((file) => {
@@ -1980,12 +2102,13 @@ More items available. Use pageToken: ${res.data.nextPageToken}`;
           return errorResponse(validation.error.errors[0].message);
         }
         const args = validation.data;
-        const item = await drive.files.get({ fileId: args.itemId, fields: "name" });
+        const item = await drive.files.get({ fileId: args.itemId, fields: "name", supportsAllDrives: true });
         await drive.files.update({
           fileId: args.itemId,
           requestBody: {
             trashed: true
-          }
+          },
+          supportsAllDrives: true
         });
         log("Item moved to trash successfully", { itemId: args.itemId, name: item.data.name });
         return {
@@ -1999,14 +2122,15 @@ More items available. Use pageToken: ${res.data.nextPageToken}`;
           return errorResponse(validation.error.errors[0].message);
         }
         const args = validation.data;
-        const item = await drive.files.get({ fileId: args.itemId, fields: "name, mimeType" });
+        const item = await drive.files.get({ fileId: args.itemId, fields: "name, mimeType", supportsAllDrives: true });
         if (Object.values(TEXT_MIME_TYPES).includes(item.data.mimeType || "")) {
           validateTextFileExtension(args.newName);
         }
         const updatedItem = await drive.files.update({
           fileId: args.itemId,
           requestBody: { name: args.newName },
-          fields: "id, name, modifiedTime"
+          fields: "id, name, modifiedTime",
+          supportsAllDrives: true
         });
         return {
           content: [{
@@ -2026,16 +2150,18 @@ More items available. Use pageToken: ${res.data.nextPageToken}`;
         if (args.destinationFolderId === args.itemId) {
           return errorResponse("Cannot move a folder into itself.");
         }
-        const item = await drive.files.get({ fileId: args.itemId, fields: "name, parents" });
+        const item = await drive.files.get({ fileId: args.itemId, fields: "name, parents", supportsAllDrives: true });
         await drive.files.update({
           fileId: args.itemId,
           addParents: destinationFolderId,
           removeParents: item.data.parents?.join(",") || "",
-          fields: "id, name, parents"
+          fields: "id, name, parents",
+          supportsAllDrives: true
         });
         const destinationFolder = await drive.files.get({
           fileId: destinationFolderId,
-          fields: "name"
+          fields: "name",
+          supportsAllDrives: true
         });
         return {
           content: [{
@@ -2079,7 +2205,8 @@ More items available. Use pageToken: ${res.data.nextPageToken}`;
               mimeType: "application/vnd.google-apps.document",
               parents: [parentFolderId]
             },
-            fields: "id, name, webViewLink"
+            fields: "id, name, webViewLink",
+            supportsAllDrives: true
           });
         } catch (createError) {
           log("Drive files.create error details:", {
@@ -2204,12 +2331,14 @@ Link: ${doc.webViewLink}` }],
         await drive.files.update({
           fileId: spreadsheet.data.spreadsheetId || "",
           addParents: parentFolderId,
-          fields: "id, name, webViewLink"
+          removeParents: "root",
+          fields: "id, name, webViewLink",
+          supportsAllDrives: true
         });
         await sheets.spreadsheets.values.update({
           spreadsheetId: spreadsheet.data.spreadsheetId,
           range: "Sheet1!A1",
-          valueInputOption: "RAW",
+          valueInputOption: args.valueInputOption || "RAW",
           requestBody: { values: args.data }
         });
         return {
@@ -2228,7 +2357,7 @@ ID: ${spreadsheet.data.spreadsheetId}` }],
         await sheets.spreadsheets.values.update({
           spreadsheetId: args.spreadsheetId,
           range: args.range,
-          valueInputOption: "RAW",
+          valueInputOption: args.valueInputOption || "RAW",
           requestBody: { values: args.data }
         });
         return {
@@ -2626,7 +2755,8 @@ ID: ${spreadsheet.data.spreadsheetId}` }],
         await drive.files.update({
           fileId: presentation.data.presentationId,
           addParents: parentFolderId,
-          removeParents: "root"
+          removeParents: "root",
+          supportsAllDrives: true
         });
         for (const slide of args.slides) {
           const slideObjectId = `slide_${uuidv4().substring(0, 8)}`;
@@ -3421,6 +3551,148 @@ Slide ${args.slideIndex ?? index} (ID: ${slide.objectId}):
           isError: false
         };
       }
+      case "getGoogleSlidesSpeakerNotes": {
+        const validation = GetGoogleSlidesSpeakerNotesSchema.safeParse(request.params.arguments);
+        if (!validation.success) {
+          return errorResponse(validation.error.errors[0].message);
+        }
+        const args = validation.data;
+        const slidesService = google.slides({ version: "v1", auth: authClient });
+        const presentation = await slidesService.presentations.get({
+          presentationId: args.presentationId
+        });
+        if (!presentation.data.slides || args.slideIndex >= presentation.data.slides.length) {
+          return errorResponse(`Slide index ${args.slideIndex} not found in presentation (has ${presentation.data.slides?.length ?? 0} slides)`);
+        }
+        const slide = presentation.data.slides[args.slideIndex];
+        const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+        if (!notesObjectId) {
+          return {
+            content: [{ type: "text", text: "No speaker notes found for this slide" }],
+            isError: false
+          };
+        }
+        const notesPageObjectId = slide.slideProperties?.notesPage?.objectId;
+        if (!notesPageObjectId) {
+          return {
+            content: [{ type: "text", text: "No speaker notes found for this slide" }],
+            isError: false
+          };
+        }
+        const notesPage = presentation.data.slides?.[args.slideIndex]?.slideProperties?.notesPage;
+        if (!notesPage || !notesPage.pageElements) {
+          return {
+            content: [{ type: "text", text: "No speaker notes found for this slide" }],
+            isError: false
+          };
+        }
+        const speakerNotesElement = notesPage.pageElements.find(
+          (element) => element.objectId === notesObjectId
+        );
+        if (!speakerNotesElement || !speakerNotesElement.shape?.text) {
+          return {
+            content: [{ type: "text", text: "No speaker notes found for this slide" }],
+            isError: false
+          };
+        }
+        let notesText = "";
+        const textElements = speakerNotesElement.shape.text.textElements || [];
+        textElements.forEach((textElement) => {
+          if (textElement.textRun?.content) {
+            notesText += textElement.textRun.content;
+          }
+        });
+        return {
+          content: [{ type: "text", text: notesText.trim() || "No speaker notes found for this slide" }],
+          isError: false
+        };
+      }
+      case "updateGoogleSlidesSpeakerNotes": {
+        const validation = UpdateGoogleSlidesSpeakerNotesSchema.safeParse(request.params.arguments);
+        if (!validation.success) {
+          return errorResponse(validation.error.errors[0].message);
+        }
+        const args = validation.data;
+        const slidesService = google.slides({ version: "v1", auth: authClient });
+        const presentation = await slidesService.presentations.get({
+          presentationId: args.presentationId
+        });
+        if (!presentation.data.slides || args.slideIndex >= presentation.data.slides.length) {
+          return errorResponse(`Slide index ${args.slideIndex} not found in presentation (has ${presentation.data.slides?.length ?? 0} slides)`);
+        }
+        const slide = presentation.data.slides[args.slideIndex];
+        const notesObjectId = slide.slideProperties?.notesPage?.notesProperties?.speakerNotesObjectId;
+        if (!notesObjectId) {
+          return errorResponse("This slide does not have a speaker notes object. Speaker notes may need to be initialized manually in Google Slides first.");
+        }
+        const requests = [
+          {
+            deleteText: {
+              objectId: notesObjectId,
+              textRange: {
+                type: "ALL"
+              }
+            }
+          },
+          {
+            insertText: {
+              objectId: notesObjectId,
+              text: args.notes,
+              insertionIndex: 0
+            }
+          }
+        ];
+        await slidesService.presentations.batchUpdate({
+          presentationId: args.presentationId,
+          requestBody: { requests }
+        });
+        return {
+          content: [{ type: "text", text: `Successfully updated speaker notes for slide ${args.slideIndex}` }],
+          isError: false
+        };
+      }
+      case "uploadFile": {
+        const validation = UploadFileSchema.safeParse(request.params.arguments);
+        if (!validation.success) {
+          return errorResponse(validation.error.errors[0].message);
+        }
+        const args = validation.data;
+        if (!existsSync(args.localPath)) {
+          return errorResponse(`File not found: ${args.localPath}`);
+        }
+        const stats = statSync(args.localPath);
+        const fileName = args.name || args.localPath.split(/[\\/]/).pop() || "upload";
+        const ext = fileName.split(".").pop()?.toLowerCase() || "";
+        const detectedMime = args.mimeType || BINARY_MIME_TYPES[ext] || "application/octet-stream";
+        const parentId = await resolveFolderId(args.parentFolderId);
+        log("Uploading file", { localPath: args.localPath, name: fileName, mimeType: detectedMime, size: stats.size });
+        const file = await drive.files.create({
+          requestBody: {
+            name: fileName,
+            parents: [parentId]
+          },
+          media: {
+            mimeType: detectedMime,
+            body: createReadStream(args.localPath)
+          },
+          fields: "id, name, size, mimeType, webViewLink",
+          supportsAllDrives: true
+        });
+        log("File uploaded successfully", { fileId: file.data?.id });
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `Uploaded: ${file.data?.name || fileName}`,
+              `ID: ${file.data?.id || "unknown"}`,
+              `Size: ${file.data?.size || stats.size} bytes`,
+              `Type: ${file.data?.mimeType || detectedMime}`,
+              file.data?.webViewLink ? `Link: ${file.data.webViewLink}` : ""
+            ].filter(Boolean).join("\n")
+          }],
+          isError: false
+        };
+      }
       default:
         return errorResponse("Tool not found");
     }