Efficient AI Agent Authentication with MCP

// Step 1: Agent calls tool to list available providers (800 tokens)
const providers = await listAuthProviders(); // Returns full config for 10+ providers

// Step 2: Agent selects provider and initiates auth (1,200 tokens)
const authUrl = await getAuthUrl({
  provider: 'google',
  scopes: ['email', 'profile'],
  redirectUri: 'https://example.com/callback'
});

// Step 3: After OAuth callback, agent exchanges code (2,500 tokens)
const result = await exchangeAuthCode({
  provider: 'google',
  code: 'abc123',
  state: 'xyz789'
}); // Returns full user profile + token + refresh token + provider metadata

// Step 4: Agent uses token to fetch additional data (1,500 tokens)
const userData = await fetchUserData({
  token: result.accessToken
}); // Returns complete user object with all fields

// Total: ~6,000+ tokens consumed, sensitive data exposed in context

// Virtual filesystem structure visible to agents
servers/
├── warpy-auth/
│   ├── agentLogin.ts        // Creates short-lived agent tokens
│   ├── getSession.ts        // Verifies tokens and retrieves session info
│   ├── revokeToken.ts       // Invalidates tokens immediately
│   └── types.ts             // Shared type definitions

// Agent code can import and use these modules directly
import * as auth from './servers/warpy-auth';

// Efficient, isolated authentication
const { token } = await auth.agentLogin({
  userId: 'user-123',
  scopes: ['debug', 'read'],
  expiresIn: '15m'
});

// Token stays in execution environment, never passed to model
const profile = await fetchWithAuth(token);
console.log('Authentication successful'); // Only confirmation goes to model

// Traditional: All providers loaded upfront (10,000+ tokens)
const allProviders = await listProviders(); // Full config for 10+ providers

// Code Execution: Load providers on-demand (500 tokens)
import { searchAuthTools } from './servers/warpy-auth';

// Agent only discovers tools it needs
if (taskRequiresGoogleAuth) {
  const googleTools = await searchAuthTools({ provider: 'google' });
  // Only Google-specific functions loaded
}

import * as auth from './servers/warpy-auth';

// Agent code runs in isolated environment
const { token } = await auth.agentLogin({
  userId: 'user-123',
  scopes: ['debug', 'read']
});

// Fetch user profile with token (token never leaves execution env)
const profile = await fetch('/api/user/profile', {
  headers: { 'Authorization': `Bearer ${token}` }
}).then(res => res.json());

// Automatic masking applied before returning to model
console.log(`Profile loaded for ${profile.email}`);
// Model sees: "Profile loaded for [EMAIL_1]"

// Real data available in execution environment for API calls
// Masked references available in model context for tracking

```mermaid
graph TD
    subgraph Traditional MCP
        A1[Agent Context] -->|Full provider configs| B1[Tool: agent_login]
        B1 -->|Full token + user data| A1
        A1 -->|Token in context| C1[Tool: get_session]
        C1 -->|Complete profile| A1
        A1 -->|All data visible| D1[Task Execution]
    end

    subgraph Code Execution with MCP
        A2[Agent Context] -->|Import statement only| B2[Execution Env]
        B2 -->|agentLogin function| C2[Auth Logic]
        C2 -->|Token stays local| B2
        B2 -->|Masked result only| A2
        B2 -->|Direct API calls| D2[Task Execution]
    end
```

**Token Usage:**
- Traditional: ~6,000 tokens per auth flow
- Code Execution: ~300 tokens per auth flow (95% reduction)

import * as auth from './servers/warpy-auth';
import { maskPII } from './servers/warpy-auth/privacy';

// Authenticate and fetch user data
const { token } = await auth.agentLogin({
  userId: 'user-123',
  scopes: ['read:profile', 'read:orders']
});

const user = await fetchUserProfile(token);
const orders = await fetchUserOrders(token);

// Mask PII automatically before logging
const maskedUser = maskPII(user, {
  email: '[EMAIL_1]',
  phone: '[PHONE_1]',
  address: '[ADDRESS_1]'
});

console.log(`Loaded profile for ${maskedUser.email}`);
console.log(`Found ${orders.length} orders`);

// Model Context Sees:
// "Loaded profile for [EMAIL_1]"
// "Found 5 orders"

// Execution Environment Has:
// Full access to real email, phone, address for API operations
// Can make authenticated API calls with real data
// Model never sees unmasked PII

import * as auth from './servers/warpy-auth';
import { readFile, writeFile } from 'fs/promises';

// Check for existing session
let sessionData;
try {
  const cached = await readFile('./workspace/.auth-session', 'utf-8');
  sessionData = JSON.parse(cached);

  // Verify token is still valid
  const verification = await auth.getSession({ token: sessionData.token });
  if (!verification.success) {
    throw new Error('Session expired');
  }
} catch {
  // No valid session, create new one
  const result = await auth.agentLogin({
    userId: 'user-123',
    scopes: ['debug', 'read'],
    expiresIn: '1h'
  });

  sessionData = {
    token: result.token,
    expires: result.expires,
    userId: 'user-123'
  };

  // Persist for future tasks
  await writeFile(
    './workspace/.auth-session',
    JSON.stringify(sessionData),
    'utf-8'
  );
}

console.log('Authenticated session ready');
// Agent can now perform multiple operations without re-authenticating

import * as auth from './servers/warpy-auth';
import { appendFile } from 'fs/promises';

async function auditedLogin(userId: string, scopes: string[], reason: string) {
  const timestamp = new Date().toISOString();

  // Perform authentication
  const result = await auth.agentLogin({
    userId,
    scopes,
    agentId: 'production-agent',
    expiresIn: '15m'
  });

  // Log to secure audit file (not visible to model)
  await appendFile('./workspace/.audit-log', JSON.stringify({
    timestamp,
    action: 'agent_login',
    userId,
    scopes,
    reason,
    success: result.success,
    tokenHash: hashToken(result.token) // Never log full token
  }) + '\n');

  console.log(`Authenticated for: ${reason}`);
  return result;
}

// Model only sees high-level confirmation
// Full audit trail preserved in execution environment

import { searchAuthTools } from './servers/warpy-auth';

// Agent determines authentication needs based on task
const taskContext = analyzeTask(userRequest);

if (taskContext.requiresOAuth) {
  // Load OAuth-specific tools
  const oauthTools = await searchAuthTools({
    type: 'oauth',
    provider: taskContext.preferredProvider
  });
  // Only OAuth schemas loaded into context
}

if (taskContext.requires2FA) {
  // Load 2FA tools separately
  const twoFATools = await searchAuthTools({ type: '2fa' });
  // 2FA schemas loaded only when needed
}

// Result: 80% reduction in unnecessary schema loading

// Agent makes direct tool call
const response = await fetch('/api/mcp', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    tool: 'agent_login',
    args: {
      userId: 'user-123',
      scopes: ['debug', 'read'],
      agentId: 'claude-assistant',
      expiresIn: '15m'
    }
  })
});

const result = await response.json();
// Full response visible in agent context
// Token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
// Expires: "2024-11-06T15:30:00Z"
// Message: "Agent claude-assistant logged in..."

// Use token for authenticated requests
const userData = await fetch('/api/user/profile', {
  headers: { 'Authorization': `Bearer ${result.token}` }
});

const profile = await userData.json();
// Full user profile in context
// { email: "user@example.com", name: "John Doe", ... }

// Token Usage: ~1,500 tokens for auth + response

// File: servers/warpy-auth/agentLogin.ts
import { callMCPTool } from '../../../client.js';

export interface AgentLoginInput {
  userId: string;
  scopes: string[];
  agentId?: string;
  expiresIn?: string;
}

export interface AgentLoginResponse {
  success: boolean;
  token?: string;
  expires?: string;
  error?: string;
}

export async function agentLogin(
  input: AgentLoginInput
): Promise<AgentLoginResponse> {
  return callMCPTool<AgentLoginResponse>('warpy_auth__agent_login', {
    userId: input.userId,
    scopes: input.scopes,
    agentId: input.agentId || 'default-agent',
    expiresIn: input.expiresIn || '15m'
  });
}

// File: servers/warpy-auth/getSession.ts
export interface GetSessionInput {
  token: string;
}

export interface SessionInfo {
  userId: string;
  email?: string;
  scopes: string[];
  agentId?: string;
}

export async function getSession(
  input: GetSessionInput
): Promise<{ success: boolean; session?: SessionInfo; error?: string }> {
  return callMCPTool('warpy_auth__get_session', input);
}

// File: servers/warpy-auth/revokeToken.ts
export async function revokeToken(
  token: string
): Promise<{ success: boolean; error?: string }> {
  return callMCPTool('warpy_auth__revoke_token', { token });
}

import * as auth from './servers/warpy-auth';

// Authenticate (token stays in execution environment)
const { success, token, error } = await auth.agentLogin({
  userId: 'user-123',
  scopes: ['debug', 'read'],
  expiresIn: '15m'
});

if (!success) {
  console.log(`Auth failed: ${error}`);
  throw new Error('Authentication failed');
}

console.log('Authentication successful');
// Model sees: "Authentication successful" (8 tokens)
// Token never enters model context

// Use token for API calls
const profile = await fetch('/api/user/profile', {
  headers: { 'Authorization': `Bearer ${token}` }
}).then(res => res.json());

// Mask sensitive data before logging
console.log(`Loaded profile for ${profile.email ? '[EMAIL]' : 'unknown'}`);
// Model sees: "Loaded profile for [EMAIL]" (7 tokens)

// Total token usage: ~50 tokens (vs 1,500 tokens traditional approach)
// 97% reduction in authentication token consumption

import * as auth from './servers/warpy-auth';

class AuthenticatedSession {
  private token: string | null = null;
  private expiresAt: Date | null = null;
  private userId: string;
  private scopes: string[];

  constructor(userId: string, scopes: string[]) {
    this.userId = userId;
    this.scopes = scopes;
  }

  async ensureValid(): Promise<string> {
    // Check if token exists and hasn't expired
    if (this.token && this.expiresAt && this.expiresAt > new Date()) {
      return this.token;
    }

    // Token expired or doesn't exist, refresh
    console.log('Refreshing authentication...');
    const result = await auth.agentLogin({
      userId: this.userId,
      scopes: this.scopes,
      expiresIn: '15m'
    });

    if (!result.success || !result.token) {
      throw new Error('Failed to refresh token');
    }

    this.token = result.token;
    this.expiresAt = new Date(result.expires!);
    console.log('Token refreshed successfully');

    return this.token;
  }

  async authenticatedFetch(url: string, options: RequestInit = {}) {
    const token = await this.ensureValid();
    return fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${token}`
      }
    });
  }
}

// Usage in long-running task
const session = new AuthenticatedSession('user-123', ['debug', 'read']);

// Agent performs multiple operations over time
for (let i = 0; i < 10; i++) {
  // Token automatically refreshed if needed
  const response = await session.authenticatedFetch('/api/data/batch/' + i);
  const data = await response.json();

  console.log(`Processed batch ${i + 1}/10`);
  await sleep(120000); // 2 minute delay between batches
}

console.log('All batches processed successfully');

// Model Context: Only sees progress updates
// Token refresh happens transparently in execution environment
// No token exposure, no context bloat from refresh operations

import * as auth from './servers/warpy-auth';

// Privacy utility (runs in execution environment)
class PrivacyGuard {
  private tokenMap = new Map<string, string>();
  private counter = 0;

  maskEmail(email: string): string {
    if (!this.tokenMap.has(email)) {
      this.tokenMap.set(email, `[EMAIL_${++this.counter}]`);
    }
    return this.tokenMap.get(email)!;
  }

  maskPhone(phone: string): string {
    if (!this.tokenMap.has(phone)) {
      this.tokenMap.set(phone, `[PHONE_${++this.counter}]`);
    }
    return this.tokenMap.get(phone)!;
  }

  maskObject<T extends Record<string, any>>(obj: T): T {
    const masked = { ...obj };
    if (masked.email) masked.email = this.maskEmail(masked.email);
    if (masked.phone) masked.phone = this.maskPhone(masked.phone);
    if (masked.address) masked.address = '[ADDRESS]';
    if (masked.ssn) masked.ssn = '[SSN]';
    return masked;
  }

  // Real data available for API calls
  getRealValue(maskedValue: string): string | undefined {
    for (const [real, masked] of this.tokenMap.entries()) {
      if (masked === maskedValue) return real;
    }
    return undefined;
  }
}

const privacy = new PrivacyGuard();

// Authenticate and fetch user data
const { token } = await auth.agentLogin({
  userId: 'user-123',
  scopes: ['read:profile', 'write:support_ticket']
});

const profile = await fetch('/api/user/profile', {
  headers: { 'Authorization': `Bearer ${token}` }
}).then(res => res.json());

// Mask before any logging
const maskedProfile = privacy.maskObject(profile);
console.log(`User profile: ${JSON.stringify(maskedProfile)}`);
// Model sees: "{ email: '[EMAIL_1]', phone: '[PHONE_1]', name: 'John' }"

// Later, if agent needs to reference the email in API call:
// Use the mask for tracking, real value for API
console.log(`Creating support ticket for ${maskedProfile.email}`);
const realEmail = privacy.getRealValue(maskedProfile.email);
await createTicket({ email: realEmail, ... });

// Privacy preserved: Model only sees masks, APIs get real data