diff --git a/server/mcp-core/auth-context-store.ts b/server/mcp-core/auth-context-store.ts
index 4cead12..c871d16 100644
--- a/server/mcp-core/auth-context-store.ts
+++ b/server/mcp-core/auth-context-store.ts
@@ -28,6 +28,7 @@ export interface AuthContext {
   // Multi-provider tokens (nested structure per Q21, Q22)
   atlassian?: ProviderAuthInfo;
   figma?: ProviderAuthInfo;
+  google?: ProviderAuthInfo;
   // JWT metadata (preserved for compatibility)
   iss?: string;
   aud?: string;
@@ -68,6 +69,7 @@ function getTokenLogInfo(token?: string, prefix: string = 'Token'): Record<strin
 export function setAuthContext(transportId: string, authInfo: AuthContext): void {
   const atlassianToken = authInfo?.atlassian?.access_token;
   const figmaToken = authInfo?.figma?.access_token;
+  const googleToken = authInfo?.google?.access_token;
   const now = Math.floor(Date.now() / 1000);
   
   // Calculate expiry for Atlassian tokens
@@ -92,6 +94,11 @@ export function setAuthContext(transportId: string, authInfo: AuthContext): void
         hasRefreshToken: !!authInfo.figma.refresh_token,
         scope: authInfo.figma.scope,
       } : null,
+      google: authInfo?.google ? {
+        ...getTokenLogInfo(googleToken, 'googleToken'),
+        hasRefreshToken: !!authInfo.google.refresh_token,
+        scope: authInfo.google.scope,
+      } : null,
     },
     issuer: authInfo?.iss,
     audience: authInfo?.aud,
@@ -146,7 +153,7 @@ export function getAuthContext(transportId: string): AuthContext | undefined {
  */
 export function getAuthInfo(context: any): AuthContext | null {
   // First try to get from context if it's directly available
-  if (context?.authInfo && (context.authInfo.atlassian || context.authInfo.figma)) {
+  if (context?.authInfo && (context.authInfo.atlassian || context.authInfo.figma || context.authInfo.google)) {
     return context.authInfo;
   }
 
@@ -156,7 +163,7 @@ export function getAuthInfo(context: any): AuthContext | null {
   if (sessionId) {
     const authInfo = authContextStore.get(sessionId);
     
-    if (authInfo && (authInfo.atlassian || authInfo.figma)) {
+    if (authInfo && (authInfo.atlassian || authInfo.figma || authInfo.google)) {
       return authInfo;
     }
   }
diff --git a/server/mcp-core/auth-helpers.ts b/server/mcp-core/auth-helpers.ts
index d723ddc..ae3c721 100644
--- a/server/mcp-core/auth-helpers.ts
+++ b/server/mcp-core/auth-helpers.ts
@@ -63,8 +63,11 @@ export function isTokenExpired(authInfo: AuthContext | null): boolean {
   const hasValidFigmaToken = authInfo.figma && 
     authInfo.figma.expires_at > now;
   
+  const hasValidGoogleToken = authInfo.google && 
+    authInfo.google.expires_at > now;
+  
   // If at least one provider has a valid token, not expired
-  const hasAnyValidToken = hasValidAtlassianToken || hasValidFigmaToken;
+  const hasAnyValidToken = hasValidAtlassianToken || hasValidFigmaToken || hasValidGoogleToken;
   
   return !hasAnyValidToken;
 }
diff --git a/server/mcp-core/server-factory.ts b/server/mcp-core/server-factory.ts
index 12b589d..7652937 100644
--- a/server/mcp-core/server-factory.ts
+++ b/server/mcp-core/server-factory.ts
@@ -15,6 +15,7 @@ import type { AuthContext } from './auth-context-store.ts';
 // Import provider implementations
 import { atlassianProvider } from '../providers/atlassian/index.js';
 import { figmaProvider } from '../providers/figma/index.js';
+import { googleProvider } from '../providers/google/index.js';
 import { utilityProvider } from '../providers/utility/index.js';
 import { combinedProvider } from '../providers/combined/index.js';
 
@@ -79,6 +80,12 @@ export function createMcpServer(authContext: AuthContext): McpServer {
     registeredProviders.push('figma');
   }
 
+  if (authContext.google) {
+    console.log('  Registering Google Drive tools');
+    googleProvider.registerTools(mcp, authContext);
+    registeredProviders.push('google');
+  }
+
   // Register combined tools only if BOTH providers are available
   if (authContext.atlassian && authContext.figma) {
     console.log('  Registering combined tools (atlassian + figma)');
diff --git a/server/mcp-service.ts b/server/mcp-service.ts
index 7d67fc3..35a30a6 100644
--- a/server/mcp-service.ts
+++ b/server/mcp-service.ts
@@ -327,8 +327,8 @@ function validateAndExtractJwt(token: string, req: Request, res: Response, sourc
     console.log(`Successfully parsed JWT payload from ${source}:`, JSON.stringify(sanitizeJwtPayload(payload), null, 2));
 
     // Validate that we have at least one provider's credentials (nested structure per Q21)
-    if (!payload.atlassian && !payload.figma) {
-      console.log(`JWT payload missing provider credentials (${source}) - expected 'atlassian' or 'figma' nested structure`);
+    if (!payload.atlassian && !payload.figma && !payload.google) {
+      console.log(`JWT payload missing provider credentials (${source}) - expected 'atlassian', 'figma', or 'google' nested structure`);
       sendMissingAtlassianAccessToken(res, req, source);
       return { authInfo: null, errored: true };
     }
@@ -371,7 +371,7 @@ function send401(res: Response, jsonResponse: { error: string }, includeInvalidT
 }
 
 function sendMissingAtlassianAccessToken(res: Response, req: Request, where: string = 'bearer header'): Response {
-  const message = `Authentication token missing Atlassian access token in ${where}.`;
+  const message = `Authentication token missing provider access token in ${where}.`;
   console.log(`❌🔑 ${message}`);
   return res
       .status(401)
diff --git a/server/pkce/refresh-token.ts b/server/pkce/refresh-token.ts
index c7b42af..7ddb754 100644
--- a/server/pkce/refresh-token.ts
+++ b/server/pkce/refresh-token.ts
@@ -33,6 +33,7 @@ import {
 } from './token-helpers.ts';
 import { atlassianProvider } from '../providers/atlassian/index.ts';
 import { figmaProvider } from '../providers/figma/index.ts';
+import { googleProvider } from '../providers/google/index.ts';
 import type { OAuthHandler, OAuthRequest, OAuthErrorResponse } from './types.ts';
 
 /**
@@ -107,10 +108,12 @@ export const refreshToken: OAuthHandler = async (req: Request, res: Response): P
     // Extract provider refresh tokens from nested structure
     const atlassianRefreshToken = refreshPayload.atlassian?.refresh_token;
     const figmaRefreshToken = refreshPayload.figma?.refresh_token;
+    const googleRefreshToken = refreshPayload.google?.refresh_token;
 
     // Refresh each provider using the provider interface
     let newAtlassianTokens: any = null;
     let newFigmaTokens: any = null;
+    let newGoogleTokens: any = null;
 
     try {
       // Refresh Atlassian if present
@@ -127,8 +130,15 @@ export const refreshToken: OAuthHandler = async (req: Request, res: Response): P
         });
       }
 
+      // Refresh Google if present
+      if (googleRefreshToken) {
+        newGoogleTokens = await googleProvider.refreshAccessToken!({
+          refreshToken: googleRefreshToken,
+        });
+      }
+
       // Check if we refreshed any provider
-      if (!newAtlassianTokens && !newFigmaTokens) {
+      if (!newAtlassianTokens && !newFigmaTokens && !newGoogleTokens) {
         console.error(
           '🔄 REFRESH TOKEN FLOW - ERROR: No provider refresh tokens found in JWT'
         );
@@ -165,6 +175,7 @@ export const refreshToken: OAuthHandler = async (req: Request, res: Response): P
     const multiProviderTokens: MultiProviderTokens = {};
     addProviderTokens(multiProviderTokens, 'atlassian', newAtlassianTokens);
     addProviderTokens(multiProviderTokens, 'figma', newFigmaTokens);
+    addProviderTokens(multiProviderTokens, 'google', newGoogleTokens);
 
     // Create new access token with refreshed provider tokens
     const newAccessToken = await createMultiProviderAccessToken(
@@ -204,6 +215,7 @@ export const refreshToken: OAuthHandler = async (req: Request, res: Response): P
       providers_refreshed: [
         newAtlassianTokens && 'atlassian',
         newFigmaTokens && 'figma',
+        newGoogleTokens && 'google',
       ].filter(Boolean),
       expires_in: expiresIn,
     });
diff --git a/server/pkce/token-helpers.ts b/server/pkce/token-helpers.ts
index 8a92316..bc266a0 100644
--- a/server/pkce/token-helpers.ts
+++ b/server/pkce/token-helpers.ts
@@ -46,6 +46,7 @@ export interface ProviderTokenData {
 export interface MultiProviderTokens {
   atlassian?: ProviderTokenData;
   figma?: ProviderTokenData;
+  google?: ProviderTokenData;
 }
 
 // Extended interface to handle optional refresh token expiration
@@ -58,12 +59,12 @@ export interface ExtendedAtlassianTokenResponse extends AtlassianTokenResponse {
  * Mutates the target object by adding provider token data with calculated expiration
  * 
  * @param target - The MultiProviderTokens object to mutate
- * @param providerKey - The provider key ('atlassian' or 'figma')
+ * @param providerKey - The provider key ('atlassian', 'figma', or 'google')
  * @param tokens - Provider token response containing access_token, refresh_token, expires_in, scope
  */
 export function addProviderTokens(
   target: MultiProviderTokens,
-  providerKey: 'atlassian' | 'figma',
+  providerKey: 'atlassian' | 'figma' | 'google',
   tokens: any
 ): void {
   if (tokens) {
diff --git a/server/provider-server-oauth/connection-done.ts b/server/provider-server-oauth/connection-done.ts
index cc62e2f..c1c6774 100644
--- a/server/provider-server-oauth/connection-done.ts
+++ b/server/provider-server-oauth/connection-done.ts
@@ -61,8 +61,9 @@ export async function handleConnectionDone(req: Request, res: Response): Promise
     // Build multi-provider tokens structure for JWT creation
     const atlassianTokens = providerTokens['atlassian'];
     const figmaTokens = providerTokens['figma'];
+    const googleTokens = providerTokens['google'];
     
-    if (!atlassianTokens && !figmaTokens) {
+    if (!atlassianTokens && !figmaTokens && !googleTokens) {
       throw new Error('No provider tokens found - please connect at least one service');
     }
     
@@ -93,6 +94,18 @@ export async function handleConnectionDone(req: Request, res: Response): Promise
       console.log('  Warning: Figma tokens incomplete (missing access or refresh token)');
     }
     
+    if (googleTokens && googleTokens.access_token && googleTokens.refresh_token) {
+      console.log('  Adding Google credentials to JWT');
+      multiProviderTokens.google = {
+        access_token: googleTokens.access_token,
+        refresh_token: googleTokens.refresh_token,
+        expires_at: googleTokens.expires_at,
+        scope: googleTokens.scope,
+      };
+    } else if (googleTokens) {
+      console.log('  Warning: Google tokens incomplete (missing access or refresh token)');
+    }
+    
     // Create JWT access token with nested provider structure
     const tokenOptions = {
       resource: req.session.mcpResource || process.env.VITE_AUTH_SERVER_URL,
diff --git a/server/provider-server-oauth/connection-hub.ts b/server/provider-server-oauth/connection-hub.ts
index 5eaba2d..00ca55e 100644
--- a/server/provider-server-oauth/connection-hub.ts
+++ b/server/provider-server-oauth/connection-hub.ts
@@ -23,7 +23,7 @@ import crypto from 'crypto';
 
 // All providers that must be connected for auto-redirect to /auth/done
 // If only some providers are connected, user can manually click "Done" button
-const REQUIRED_PROVIDERS = ['atlassian', 'figma'] as const;
+const REQUIRED_PROVIDERS = ['atlassian', 'figma', 'google'] as const;
 
 /**
  * Renders the connection hub UI
@@ -185,6 +185,15 @@ export function renderConnectionHub(req: Request, res: Response): void {
           }
         </div>
         
+        <div class="provider ${connectedProviders.includes('google') ? 'connected' : ''}">
+          <h2>Google Drive</h2>
+          <p>Access Google Drive files</p>
+          ${connectedProviders.includes('google') 
+            ? '<span class="status">✓ Connected</span>'
+            : '<button onclick="location.href=\'/auth/connect/google\'">Connect Google Drive</button>'
+          }
+        </div>
+        
         <div class="done-section">
           <button class="done-button" onclick="location.href='/auth/done'" ${connectedProviders.length === 0 ? 'disabled' : ''}>
             Done - Create Session
diff --git a/server/providers/google/google-api-client.ts b/server/providers/google/google-api-client.ts
new file mode 100644
index 0000000..cfb1668
--- /dev/null
+++ b/server/providers/google/google-api-client.ts
@@ -0,0 +1,66 @@
+/**
+ * Google Drive API Client Factory
+ * 
+ * Provides API client instances for OAuth authentication.
+ * Uses native fetch (no additional dependencies).
+ * 
+ * Authentication Methods:
+ * - OAuth: Uses Bearer tokens from OAuth 2.0 flow (for user delegation)
+ */
+
+import type { DriveAboutResponse } from './types.js';
+
+/**
+ * Google API client interface
+ * 
+ * Provides methods for making authenticated requests to Google APIs.
+ * All methods have the access token pre-configured via closure.
+ */
+export interface GoogleClient {
+  /**
+   * Make an authenticated fetch request to Google API
+   * @param url - The full URL to fetch
+   * @param options - Standard fetch options (method, body, etc.)
+   * @returns Promise resolving to fetch Response
+   */
+  fetch: (url: string, options?: RequestInit) => Promise<Response>;
+  
+  /**
+   * Authentication type used by this client
+   */
+  authType: 'oauth';
+}
+
+/**
+ * Create a Google API client using OAuth access token
+ * @param accessToken - OAuth 2.0 Bearer token
+ * @returns API client with Drive operations
+ * 
+ * @example
+ * ```typescript
+ * const client = createGoogleClient(token);
+ * 
+ * // Fetch with auth automatically included
+ * const response = await client.fetch(
+ *   'https://www.googleapis.com/drive/v3/about?fields=user',
+ *   { method: 'GET' }
+ * );
+ * ```
+ */
+export function createGoogleClient(accessToken: string): GoogleClient {
+  return {
+    authType: 'oauth',
+    
+    fetch: async (url: string, options: RequestInit = {}) => {
+      // Token is captured in this closure!
+      return fetch(url, {
+        ...options,
+        headers: {
+          ...options.headers,
+          'Authorization': `Bearer ${accessToken}`,
+          'Accept': 'application/json',
+        },
+      });
+    },
+  };
+}
diff --git a/server/providers/google/google-helpers.ts b/server/providers/google/google-helpers.ts
new file mode 100644
index 0000000..6d5dc2f
--- /dev/null
+++ b/server/providers/google/google-helpers.ts
@@ -0,0 +1,31 @@
+/**
+ * Google Drive API interaction helpers
+ * Reusable functions for Google Drive API calls
+ */
+
+import type { GoogleClient } from './google-api-client.js';
+import type { DriveAboutResponse } from './types.js';
+
+/**
+ * Get the authenticated user's Google Drive information
+ * @param client - Authenticated Google API client
+ * @returns Promise resolving to Drive user information
+ * @throws Error if the API request fails
+ *
+ * @example
+ * ```typescript
+ * const client = createGoogleClient(token);
+ * const userData = await getGoogleDriveUser(client);
+ * console.log(userData.user.emailAddress);
+ * ```
+ */
+export async function getGoogleDriveUser(client: GoogleClient): Promise<DriveAboutResponse> {
+  const response = await client.fetch('https://www.googleapis.com/drive/v3/about?fields=user');
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Drive API error (${response.status}): ${errorText}`);
+  }
+
+  return response.json() as Promise<DriveAboutResponse>;
+}
diff --git a/server/providers/google/index.ts b/server/providers/google/index.ts
new file mode 100644
index 0000000..ce85305
--- /dev/null
+++ b/server/providers/google/index.ts
@@ -0,0 +1,197 @@
+/**
+ * Google Drive OAuth Provider
+ * 
+ * Implements the OAuthProvider interface for Google Drive authentication.
+ * Handles Server-Side OAuth 2.0 flow with client_secret (NOT MCP PKCE).
+ * Bridge generates its own code_verifier for provider authentication.
+ */
+
+import type { McpServer } from '../../mcp-core/mcp-types.js';
+import type { 
+  OAuthProvider, 
+  AuthUrlParams, 
+  TokenExchangeParams, 
+  StandardTokenResponse, 
+  CallbackParams,
+  RefreshTokenParams,
+} from '../provider-interface.js';
+import { registerGoogleTools } from './tools/index.js';
+
+/**
+ * Google Drive Provider Object
+ * Simple object (not a class) implementing the OAuthProvider interface
+ */
+export const googleProvider: OAuthProvider = {
+  name: 'google',
+  
+  /**
+   * Create Google OAuth authorization URL
+   * NOTE: Google uses traditional OAuth 2.0 with client_secret, NOT PKCE
+   * @param params - Authorization parameters (PKCE params ignored for Google)
+   * @returns Full Google authorization URL
+   */
+  createAuthUrl(params: AuthUrlParams): string {
+    const clientId = process.env.GOOGLE_CLIENT_ID;
+    const baseUrl = process.env.VITE_AUTH_SERVER_URL!;
+    const redirectUri = params.redirectUri || `${baseUrl}/auth/callback/google`;
+    const scope = params.scope || process.env.GOOGLE_OAUTH_SCOPES!;
+    
+    // Google uses traditional OAuth 2.0 - DO NOT include PKCE parameters
+    // Request offline access to receive refresh token
+    const urlParams: Record<string, string> = {
+      client_id: clientId!,
+      response_type: params.responseType || 'code',
+      redirect_uri: redirectUri,
+      scope,
+      access_type: 'offline', // Request refresh token
+      prompt: 'consent', // Force consent screen to always get refresh token
+    };
+    
+    if (params.state) {
+      urlParams.state = params.state;
+    }
+    
+    return `https://accounts.google.com/o/oauth2/v2/auth?${new URLSearchParams(urlParams).toString()}`;
+  },
+  
+  /**
+   * Extract callback parameters from OAuth redirect
+   * @param req - Express request object
+   * @returns Extracted callback parameters
+   */
+  extractCallbackParams(req: any): CallbackParams {
+    const { code, state } = req.query;
+    
+    return {
+      code: code || '',
+      state,
+      normalizedState: state,
+    };
+  },
+  
+  /**
+   * Exchange authorization code for Google access/refresh tokens
+   * NOTE: Google uses traditional OAuth 2.0 with client_secret (NO PKCE)
+   * @param params - Token exchange parameters (codeVerifier ignored for Google)
+   * @returns Standardized token response
+   */
+  async exchangeCodeForTokens(params: TokenExchangeParams): Promise<StandardTokenResponse> {
+    const clientId = process.env.GOOGLE_CLIENT_ID;
+    const clientSecret = process.env.GOOGLE_CLIENT_SECRET;
+    const baseUrl = process.env.VITE_AUTH_SERVER_URL!;
+    const redirectUri = params.redirectUri || `${baseUrl}/auth/callback/google`;
+    
+    // Google uses traditional OAuth 2.0 - DO NOT include code_verifier
+    // Authentication is via client_id + client_secret only
+    const tokenRes = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        client_id: clientId!,
+        client_secret: clientSecret!,
+        code: params.code,
+        redirect_uri: redirectUri,
+        grant_type: 'authorization_code',
+      }).toString(),
+    });
+    
+    if (!tokenRes.ok) {
+      const errorText = await tokenRes.text();
+      throw new Error(`Google token exchange failed (${tokenRes.status}): ${errorText}`);
+    }
+    
+    const tokenData = await tokenRes.json() as any;
+    
+    if (!tokenData.access_token) {
+      throw new Error(`Google token exchange failed: ${JSON.stringify(tokenData)}`);
+    }
+    
+    return {
+      access_token: tokenData.access_token,
+      refresh_token: tokenData.refresh_token,
+      token_type: tokenData.token_type || 'Bearer',
+      expires_in: tokenData.expires_in || 3600, // Google default: 1 hour
+      scope: tokenData.scope,
+    };
+  },
+  
+  /**
+   * Get default OAuth scopes for Google Drive
+   * @returns Array of scope strings
+   */
+  getDefaultScopes(): string[] {
+    return ['https://www.googleapis.com/auth/drive'];
+  },
+  
+  /**
+   * Refresh an access token using a refresh token
+   * Google uses standard OAuth 2.0 refresh with client_secret
+   * ⚠️ NOTE: Google does NOT rotate refresh tokens - the same one remains valid
+   * @param params - Refresh parameters including the refresh token
+   * @returns New access token and the ORIGINAL refresh token
+   */
+  async refreshAccessToken(
+    params: RefreshTokenParams
+  ): Promise<StandardTokenResponse> {
+    const clientId = process.env.GOOGLE_CLIENT_ID!;
+    const clientSecret = process.env.GOOGLE_CLIENT_SECRET!;
+
+    console.log('[GOOGLE] Refreshing access token');
+    console.log('[GOOGLE]   - Refresh token length:', params.refreshToken.length);
+    console.log(
+      '[GOOGLE]   - Using endpoint: https://oauth2.googleapis.com/token'
+    );
+
+    const response = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+        refresh_token: params.refreshToken,
+        grant_type: 'refresh_token',
+      }).toString(),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('[GOOGLE] Token refresh failed:', {
+        status: response.status,
+        statusText: response.statusText,
+        error: errorText,
+      });
+      throw new Error(
+        `Google token refresh failed (${response.status}): ${errorText}`
+      );
+    }
+
+    const tokenData = (await response.json()) as any;
+    console.log('[GOOGLE] Token refresh successful:', {
+      hasAccessToken: !!tokenData.access_token,
+      hasRefreshToken: !!tokenData.refresh_token, // Should be false
+      expiresIn: tokenData.expires_in,
+    });
+
+    // Google response: { access_token, token_type, expires_in, scope } - NO refresh_token!
+    return {
+      access_token: tokenData.access_token,
+      // ⚠️ KEY: Google doesn't return a refresh token, so we return the ORIGINAL
+      // input token. This ensures the caller gets a valid refresh_token to embed
+      // in the new JWT, even though Google didn't provide one.
+      refresh_token: params.refreshToken,
+      token_type: tokenData.token_type || 'Bearer',
+      expires_in: tokenData.expires_in || 3600,
+      scope: tokenData.scope,
+    };
+  },
+
+  /**
+   * Register Google Drive-specific MCP tools
+   * Tools will be registered with 'google-' prefix
+   * @param mcp - MCP server instance
+   * @param authContext - Authentication context with Google credentials
+   */
+  registerTools(mcp: McpServer, authContext: any): void {
+    registerGoogleTools(mcp, authContext);
+  },
+};
diff --git a/server/providers/google/tools/drive-about-user.ts b/server/providers/google/tools/drive-about-user.ts
new file mode 100644
index 0000000..f79a43a
--- /dev/null
+++ b/server/providers/google/tools/drive-about-user.ts
@@ -0,0 +1,91 @@
+/**
+ * Get Google Drive User Info Tool
+ * Retrieves authenticated user's profile information from Google Drive API
+ */
+
+import { logger } from '../../../observability/logger.js';
+import { getAuthInfoSafe } from '../../../mcp-core/auth-helpers.js';
+import type { McpServer } from '../../../mcp-core/mcp-types.js';
+import { createGoogleClient } from '../google-api-client.js';
+import { getGoogleDriveUser } from '../google-helpers.js';
+
+/**
+ * Register the drive-about-user tool with the MCP server
+ * @param mcp - MCP server instance
+ */
+export function registerDriveAboutUserTool(mcp: McpServer): void {
+  mcp.registerTool(
+    'drive-about-user',
+    {
+      title: 'Get Google Drive User Info',
+      description: 'Retrieve information about the authenticated Google Drive user',
+      inputSchema: {},
+    },
+    async (_, context) => {
+      console.log('drive-about-user called');
+
+      try {
+        // Get auth info with proper error handling - uses nested access pattern
+        const authInfo = getAuthInfoSafe(context, 'drive-about-user');
+        const token = authInfo?.google?.access_token;
+
+        if (!token) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: 'Error: No Google Drive access token found in authentication context',
+              },
+            ],
+          };
+        }
+
+        console.log('  Calling Google Drive API /about endpoint...');
+
+        // Create Google client and fetch user info using helper
+        const googleClient = createGoogleClient(token);
+        const userData = await getGoogleDriveUser(googleClient);
+        const user = userData.user;
+
+        console.log(`  Google Drive user info retrieved successfully: ${user.emailAddress}`);
+        logger.info('drive-about-user completed', {
+          email: user.emailAddress,
+          displayName: user.displayName,
+          permissionId: user.permissionId,
+          authType: googleClient.authType,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(
+                {
+                  kind: user.kind,
+                  displayName: user.displayName,
+                  emailAddress: user.emailAddress,
+                  permissionId: user.permissionId,
+                  photoLink: user.photoLink,
+                  me: user.me,
+                },
+                null,
+                2,
+              ),
+            },
+          ],
+        };
+      } catch (error: any) {
+        logger.error('drive-about-user error', { error: error.message });
+        console.error('  Error in drive-about-user:', error);
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`,
+            },
+          ],
+        };
+      }
+    },
+  );
+}
diff --git a/server/providers/google/tools/index.ts b/server/providers/google/tools/index.ts
new file mode 100644
index 0000000..59afec4
--- /dev/null
+++ b/server/providers/google/tools/index.ts
@@ -0,0 +1,16 @@
+import type { McpServer } from '../../../mcp-core/mcp-types.js';
+import { registerDriveAboutUserTool } from './drive-about-user.js';
+
+/**
+ * Register all Google Drive-specific tools with the MCP server
+ * @param mcp - MCP server instance
+ * @param authContext - Authentication context (currently unused but reserved for future use)
+ */
+export function registerGoogleTools(mcp: McpServer, authContext: any): void {
+  console.log('Registering Google Drive tools...');
+
+  // User authentication test tool
+  registerDriveAboutUserTool(mcp);
+
+  console.log('  All Google Drive tools registered (1 tool)');
+}
diff --git a/server/providers/google/types.ts b/server/providers/google/types.ts
new file mode 100644
index 0000000..c18adea
--- /dev/null
+++ b/server/providers/google/types.ts
@@ -0,0 +1,37 @@
+/**
+ * Google Drive OAuth Type Definitions
+ * 
+ * TypeScript interfaces for Google OAuth 2.0 credentials and Drive API responses.
+ */
+
+/**
+ * OAuth 2.0 credentials for an authenticated Google Drive user session
+ */
+export interface GoogleOAuthCredentials {
+  access_token: string;
+  refresh_token?: string;
+  token_type: 'Bearer';
+  expires_in: number;
+  scope: string;
+  issued_at?: number;
+}
+
+/**
+ * Google Drive user profile information
+ * Source: https://www.googleapis.com/drive/v3/about?fields=user
+ */
+export interface DriveUser {
+  kind: 'drive#user';
+  displayName: string;
+  emailAddress: string;
+  permissionId: string;
+  photoLink?: string;
+  me: true;
+}
+
+/**
+ * Response from Google Drive API /about endpoint
+ */
+export interface DriveAboutResponse {
+  user: DriveUser;
+}
diff --git a/server/server.ts b/server/server.ts
index 401c320..23d1a15 100644
--- a/server/server.ts
+++ b/server/server.ts
@@ -29,6 +29,7 @@ import {
 } from './provider-server-oauth/index.js';
 import { atlassianProvider } from './providers/atlassian/index.js';
 import { figmaProvider } from './providers/figma/index.js';
+import { googleProvider } from './providers/google/index.js';
 import { logEnvironmentInfo } from './debug-helpers.js';
 import { registerRestApiRoutes } from './api/index.js';
 import { getProjectRoot } from './utils/file-paths.js';
@@ -232,6 +233,8 @@ app.get('/auth/connect/atlassian', makeAuthorize(atlassianProvider));
 app.get('/auth/callback/atlassian', makeCallback(atlassianProvider, { onSuccess: hubCallbackHandler }));
 app.get('/auth/connect/figma', makeAuthorize(figmaProvider));
 app.get('/auth/callback/figma', makeCallback(figmaProvider, { onSuccess: hubCallbackHandler }));
+app.get('/auth/connect/google', makeAuthorize(googleProvider));
+app.get('/auth/callback/google', makeCallback(googleProvider, { onSuccess: hubCallbackHandler }));
 app.get('/auth/done', handleConnectionDone);
 
 // --- MCP HTTP Endpoints ---