@Plugin

import { Plugin, Provider } from '@frontmcp/sdk';

// Provider for the plugin
@Provider({ name: 'CacheService' })
export class CacheService {
  private cache = new Map<string, string>();

  async get(key: string) {
    return this.cache.get(key);
  }

  async set(key: string, value: string) {
    this.cache.set(key, value);
  }
}

// Plugin definition
@Plugin({
  name: 'cache',
  description: 'In-memory caching for tools',
  providers: [CacheService],
  exports: [CacheService],
})
export class CachePlugin {}

function Plugin(providedMetadata: PluginMetadata): ClassDecorator

import { Plugin, Provider, type Token } from '@frontmcp/sdk';

// 1. Define the accessor
@Provider({ name: 'MemoryAccessor' })
export class MemoryAccessor {
  private readonly values = new Map<string, string>();

  async get(key: string): Promise<string | undefined> {
    return this.values.get(key);
  }

  async set(key: string, value: string): Promise<void> {
    this.values.set(key, value);
  }
}

// 2. Define a token for it: a Symbol typed with Token<T>
export const MemoryAccessorToken: Token<MemoryAccessor> = Symbol('MemoryAccessor');

const memoryAccessorProvider = {
  name: 'MemoryAccessorToken',
  provide: MemoryAccessorToken,
  inject: () => [MemoryAccessor] as const,
  useFactory: (accessor: MemoryAccessor) => accessor,
};

// 3. Augment the context types (here or in a separate file the project compiles)
declare module '@frontmcp/sdk' {
  interface ExecutionContextBase {
    readonly memory: MemoryAccessor;
  }
}

// 4. Define the plugin with the context extension
@Plugin({
  name: 'memory',
  description: 'In-memory key-value store shared by tools',
  providers: [MemoryAccessor, memoryAccessorProvider],
  exports: [memoryAccessorProvider],
  contextExtensions: [
    {
      property: 'memory',
      token: MemoryAccessorToken,
      errorMessage: 'Memory plugin not installed',
    },
  ],
})
export class MemoryPlugin {}

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

@Tool({ name: 'my_tool', inputSchema: {} })
class MyTool extends ToolContext {
  async execute() {
    // Access extended property
    await this.memory.set('lastRun', new Date().toISOString());
    const lastRun = await this.memory.get('lastRun');
    return { lastRun };
  }
}

@Plugin({
  name: 'app-plugin',
  scope: 'app', // Default
})
class AppPlugin {}

@Plugin({
  name: 'server-plugin',
  scope: 'server',
})
class ServerPlugin {}

@Plugin({
  name: 'analytics',
  plugins: [MetricsPlugin, LoggingPlugin],
  providers: [AnalyticsService],
})
class AnalyticsPlugin {}

@App({
  name: 'my-app',
  plugins: [CachePlugin, RememberPlugin],
  tools: [MyTool],
})
class MyApp {}

@FrontMcp({
  info: { name: 'Server', version: '1.0.0' },
  apps: [MyApp],
  plugins: [GlobalLoggingPlugin], // Server-level plugins
})
class Server {}

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

@Tool({
  name: 'send_elicitation_result',
  description: 'Send user response to pending elicitation',
  inputSchema: {
    elicitId: z.string(),
    response: z.record(z.string(), z.unknown()),
  },
})
class SendElicitationResultTool extends ToolContext {
  async execute(input: { elicitId: string; response: Record<string, unknown> }) {
    // Plugin-provided tool implementation
    const elicitation = this.get(ElicitationService);
    await elicitation.resolve(input.elicitId, input.response);
    return { delivered: true };
  }
}

@Plugin({
  name: 'elicitation',
  tools: [SendElicitationResultTool],
  providers: [ElicitationService],
})
export class ElicitationPlugin {}

import { Plugin, Provider, Tool, ToolContext, App, FrontMcp } from '@frontmcp/sdk';
import { z } from '@frontmcp/sdk';

// Services
@Provider({ name: 'ApprovalService' })
class ApprovalService {
  private approvals = new Map<string, boolean>();

  approve(toolName: string) {
    this.approvals.set(toolName, true);
  }

  isApproved(toolName: string): boolean {
    return this.approvals.get(toolName) === true;
  }

  revoke(toolName: string) {
    this.approvals.delete(toolName);
  }
}

@Provider({ name: 'ApprovalAccessor' })
class ApprovalAccessor {
  constructor(private service: ApprovalService) {}

  async isApproved(toolName: string): Promise<boolean> {
    return this.service.isApproved(toolName);
  }

  async approve(toolName: string): Promise<void> {
    this.service.approve(toolName);
  }
}

// Module augmentation
declare module '@frontmcp/sdk' {
  interface ExecutionContextBase {
    readonly toolApproval: ApprovalAccessor;
  }
}

// Plugin tool
@Tool({
  name: 'approve_tool',
  description: 'Approve a tool for execution',
  inputSchema: { toolName: z.string() },
})
class ApproveToolTool extends ToolContext {
  async execute(input: { toolName: string }) {
    const accessor = this.get(ApprovalAccessor);
    await accessor.approve(input.toolName);
    return { approved: input.toolName };
  }
}

// Plugin definition
@Plugin({
  name: 'tool-approval',
  description: 'Tool approval system',
  providers: [ApprovalService, ApprovalAccessor],
  exports: [ApprovalAccessor],
  tools: [ApproveToolTool],
  contextExtensions: [
    {
      property: 'toolApproval',
      token: ApprovalAccessor,
      errorMessage: 'ToolApprovalPlugin not installed',
    },
  ],
})
export class ToolApprovalPlugin {}

// Using the plugin
@Tool({
  name: 'dangerous_operation',
  inputSchema: { data: z.string() },
})
class DangerousOperationTool extends ToolContext {
  async execute(input: { data: string }) {
    // Check approval via context extension
    const isApproved = await this.toolApproval.isApproved('dangerous_operation');

    if (!isApproved) {
      return { error: 'This tool requires approval. Please run approve_tool first.' };
    }

    // Proceed with operation
    return { result: 'Operation completed' };
  }
}

@App({
  name: 'secure-app',
  plugins: [ToolApprovalPlugin],
  tools: [DangerousOperationTool],
})
class SecureApp {}

@FrontMcp({
  info: { name: 'Secure Server', version: '1.0.0' },
  apps: [SecureApp],
})
export default class SecureServer {}