ExecutionContextBase

export abstract class ExecutionContextBase<Out = unknown> {
  /** Unique identifier for this execution run (UUID) */
  protected readonly runId: string;
  /** Current execution stage marker (default: 'init') */
  protected activeStage: string;
  /** Scoped logger instance */
  protected readonly logger: FrontMcpLogger;
}

type ExecutionContextBaseArgs = {
  providers: ProviderRegistryInterface;
  logger: FrontMcpLogger;
  authInfo: Partial<AuthInfo>;
};

get<T>(token: Token<T>): T

const userService = this.get(UserServiceToken);
const config = this.get(ConfigService);

tryGet<T>(token: Token<T>): T | undefined

const cache = this.tryGet(CacheServiceToken);
if (cache) {
  const cached = await cache.get(key);
}

get context(): FrontMcpContext

const ctx = this.context;
const requestId = ctx.requestId;
const sessionId = ctx.sessionId;

tryGetContext(): FrontMcpContext | undefined

const ctx = this.tryGetContext();
if (ctx) {
  // We're in a request scope
}

get scope(): ScopeEntry

const tools = this.scope.tools;
const resources = this.scope.resources;
const prompts = this.scope.prompts;
const agents = this.scope.agents;
const skills = this.scope.skills;

getAuthInfo(): Partial<AuthInfo>

// Returns Partial<AuthInfo> — bearer token, scopes, expiry, etc.
const authInfo = this.getAuthInfo();
const token = authInfo.token;
const scopes = authInfo.scopes;
const sessionId = authInfo.sessionId;

// For role/permission/scope checks, prefer the typed FrontMcpAuthContext:
if (this.auth.hasRole('admin')) {
  const tenantId = this.auth.claims['tenantId'];
}

mark(stage: string): void

this.mark('validation');
await validate(input);

this.mark('processing');
const result = await process(input);

this.mark('complete');

protected fail(err: Error): never

if (!input.valid) {
  this.fail(new InvalidInputError('Input validation failed'));
}

protected get error(): Error | undefined

fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>

const response = await this.fetch('https://api.example.com/data', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ key: 'value' }),
});

if (!response.ok) {
  this.fail(new Error(`API error: ${response.status}`));
}

return response.json();

get config(): ConfigService

const apiKey = this.config.get('API_KEY');
const port = this.config.getNumber('PORT', 3000);
const debug = this.config.getBoolean('DEBUG', false);

protected get contextLogger(): FrontMcpLogger

this.contextLogger.info('Processing request', {
  input,
  requestId: this.context.requestId,
});

import { Tool, ToolContext } from '@frontmcp/sdk';
import { z } from '@frontmcp/sdk';

@Tool({
  name: 'process_data',
  inputSchema: { data: z.string() },
})
class ProcessDataTool extends ToolContext {
  async execute(input: { data: string }) {
    // Unique run ID for this execution
    this.logger.info('Starting execution', { runId: this.runId });

    // Mark stages
    this.mark('validation');
    if (!input.data) {
      this.fail(new InvalidInputError('Data is required'));
    }

    // Get dependencies
    this.mark('setup');
    const processor = this.get(ProcessorServiceToken);
    const cache = this.tryGet(CacheServiceToken);

    // Check cache
    if (cache) {
      const cached = await cache.get(input.data);
      if (cached) {
        return cached;
      }
    }

    // Process
    this.mark('processing');
    const result = await processor.process(input.data);

    // Make external call
    this.mark('external-api');
    const enriched = await this.fetch('https://api.example.com/enrich', {
      method: 'POST',
      body: JSON.stringify(result),
    }).then(r => r.json());

    // Cache result
    if (cache) {
      await cache.set(input.data, enriched);
    }

    this.mark('complete');
    return enriched;
  }
}