get_file_content

Instructions

Implementation Reference

• src/mcp/tools/get-file-content.ts:25-51 (handler)

  The handler function of the get_file_content tool. It validates the fileId parameter, fetches the file content using googleDriveService, and returns both text and structured content.

  handler: async (params: { fileId: string; driveId?: string }) => {
    const { fileId, driveId } = params;
  
    if (!fileId) {
      throw new Error("fileId is required");
    }
  
    const fileContent = await googleDriveService.getFileContent(
      fileId,
      driveId
    );
  
    return {
      content: [
        {
          type: "text" as const,
          text: JSON.stringify(fileContent, null, 2),
        },
      ],
      structuredContent: {
        fileId: fileContent.fileId,
        name: fileContent.fileName,
        mimeType: fileContent.mimeType,
        content: fileContent.content,
      },
    };
  },

• src/mcp/tools/get-file-content.ts:11-24 (schema)

  Input and output schemas defined using Zod for the get_file_content tool.

  config: {
    title: "Get File Content",
    description: "Get content from a Google Drive file (Docs, Sheets, TXT, MD)",
    inputSchema: {
      fileId: z.string().describe("ID of the file to read"),
      driveId: z.string().optional().describe("Drive ID (if specified)"),
    },
    outputSchema: {
      fileId: z.string(),
      name: z.string(),
      mimeType: z.string(),
      content: z.string(),
    },
  },

• src/mcp/server.ts:26-32 (registration)

  Dynamic registration of all exported tools (including get_file_content) to the MCP server using registerTool.

  // Registro automático de todas las tools
  const toolList = Object.values(tools);
  toolList.forEach((tool) => {
    server.registerTool(tool.name, tool.config as any, tool.handler as any);
  });
  
  logger.info(`MCP Server initialized with ${toolList.length} tools`);

• src/services/drive-service.ts:153-221 (helper)

  Helper service method that performs the actual Google Drive API calls to retrieve and export file content based on file type.

  async getFileContent(fileId: string, driveId?: string): Promise<FileContent> {
    const targetDriveId =
      driveId || Object.keys(drivesConfigLoader.getConfig().drives)[0];
    const drive = await this.getDriveClient(targetDriveId);
  
    try {
      // Obtener metadatos del archivo
      const metadata = await drive.files.get({
        fileId,
        fields: "id, name, mimeType",
      });
  
      const file = metadata.data;
      const mimeType = file.mimeType!;
      let content = "";
  
      // Google Docs: exportar como texto plano
      if (mimeType === SUPPORTED_MIME_TYPES.GOOGLE_DOC) {
        const response = await drive.files.export({
          fileId,
          mimeType: SUPPORTED_MIME_TYPES.EXPORT_TEXT,
        });
        content = response.data as string;
      }
      // Google Sheets: exportar como CSV
      else if (mimeType === SUPPORTED_MIME_TYPES.GOOGLE_SHEET) {
        const response = await drive.files.export({
          fileId,
          mimeType: SUPPORTED_MIME_TYPES.EXPORT_CSV,
        });
        content = response.data as string;
      }
      // Archivos de texto plano: descarga directa
      else if (
        mimeType === SUPPORTED_MIME_TYPES.TEXT_PLAIN ||
        mimeType === SUPPORTED_MIME_TYPES.TEXT_MARKDOWN ||
        mimeType === "text/markdown" ||
        file.name?.endsWith(".txt") ||
        file.name?.endsWith(".md")
      ) {
        const response = await drive.files.get(
          { fileId, alt: "media" },
          { responseType: "text" }
        );
        content = response.data as string;
      }
      // Tipo de archivo no soportado
      else {
        throw new Error(`Unsupported file type: ${mimeType}`);
      }
  
      logger.info(`Retrieved content for file: ${file.name} (${mimeType})`);
  
      return {
        fileId: file.id!,
        fileName: file.name!,
        mimeType,
        content,
        extractedAt: new Date().toISOString(),
      };
    } catch (error) {
      logger.error("Error getting file content", {
        fileId,
        driveId: targetDriveId,
        error,
      });
      throw error;
    }
  }

• src/config/types.ts:121-124 (schema)

  TypeScript interface defining the parameters for getFileContent.

  export interface GetFileContentParams {
    fileId: string;
    driveId?: string;
  }

• src/config/types.ts:92-98 (schema)

  TypeScript interface for the file content returned by the service.

  export interface FileContent {
    fileId: string;
    fileName: string;
    mimeType: string;
    content: string;
    extractedAt: string;
  }