ToolContext

export abstract class ToolContext<
  InSchema extends ToolInputType = ToolInputType,
  OutSchema extends ToolOutputType = ToolOutputType,
  In = ToolInputOf<{ inputSchema: InSchema }>,
  Out = ToolOutputOf<{ outputSchema: OutSchema }>,
> extends ExecutionContextBase<Out>

abstract execute(input: In): Promise<Out>

@Tool({
  name: 'my_tool',
  inputSchema: { value: z.number() },
  outputSchema: z.object({ result: z.number() }),
})
class MyTool extends ToolContext {
  async execute(input: { value: number }) {
    return { result: input.value * 2 };
  }
}

respond(value: Out): never

async execute(input) {
  if (cached) {
    this.respond(cached); // Ends execution here
  }
  // This code won't run if cached
  return processInput(input);
}

protected notify(
  message: string | Record<string, unknown>,
  level?: 'debug' | 'info' | 'warning' | 'error'
): Promise<boolean>

await this.notify('Processing started', 'info');
await this.notify({ step: 1, status: 'validating' }, 'debug');

protected progress(
  progress: number,
  total?: number,
  message?: string
): Promise<boolean>

await this.progress(0, 100, 'Starting...');
await this.progress(50, 100, 'Halfway done');
await this.progress(100, 100, 'Complete');

protected elicit<S extends ZodType>(
  message: string,
  requestedSchema: S,
  options?: ElicitOptions
): Promise<ElicitResult<z.infer<S>>>

interface ElicitResult<T> {
  status: 'accept' | 'reject' | 'timeout';
  content?: T;
  validationErrors?: string[];
}

async execute(input) {
  const result = await this.elicit(
    'Please confirm this action',
    z.object({
      confirmed: z.boolean(),
      reason: z.string().optional(),
    }),
    { mode: 'form', ttl: 300000 }
  );

  if (result.status !== 'accept' || !result.content?.confirmed) {
    return { cancelled: true };
  }

  // Proceed with action
  return { success: true };
}

get platform(): AIPlatformType

if (this.platform === 'claude') {
  // Claude-specific formatting
}

get clientInfo(): ClientInfo | undefined

const client = this.clientInfo;
if (client) {
  console.log(client.name);    // 'claude'
  console.log(client.version); // '1.0.0'
}

type HistoryEntry<T> = {
  at: number;          // ms timestamp
  stage?: string;      // activeStage at time of change
  value: T | undefined;
  note?: string;
};

get inputHistory(): ReadonlyArray<HistoryEntry<In>>

get outputHistory(): ReadonlyArray<HistoryEntry<Out>>

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

const inputSchema = {
  action: z.enum(['create', 'update', 'delete']),
  resourceId: z.string(),
  data: z.any().optional(),
};

const outputSchema = z.object({
  success: z.boolean(),
  resourceId: z.string(),
  message: z.string(),
});

@Tool({
  name: 'manage_resource',
  description: 'Create, update, or delete a resource',
  inputSchema,
  outputSchema,
  annotations: {
    destructiveHint: true,
  },
})
class ManageResourceTool extends ToolContext {
  async execute(input) {
    // Log start
    await this.notify(`Starting ${input.action} operation`, 'info');
    await this.progress(0, 100, 'Initializing...');

    // For destructive actions, confirm with user
    if (input.action === 'delete') {
      const confirmation = await this.elicit(
        `Are you sure you want to delete resource ${input.resourceId}?`,
        z.object({ confirmed: z.boolean() }),
        { mode: 'form', ttl: 60000 }
      );

      if (confirmation.status !== 'accept' || !confirmation.content?.confirmed) {
        return {
          success: false,
          resourceId: input.resourceId,
          message: 'Delete cancelled by user',
        };
      }
    }

    await this.progress(25, 100, 'Validating...');

    // Get service
    const resourceService = this.get(ResourceServiceToken);

    // Perform action
    await this.progress(50, 100, `Executing ${input.action}...`);

    let message: string;
    switch (input.action) {
      case 'create':
        await resourceService.create(input.resourceId, input.data);
        message = 'Resource created successfully';
        break;
      case 'update':
        await resourceService.update(input.resourceId, input.data);
        message = 'Resource updated successfully';
        break;
      case 'delete':
        await resourceService.delete(input.resourceId);
        message = 'Resource deleted successfully';
        break;
    }

    await this.progress(100, 100, 'Complete');
    await this.notify({ action: input.action, resourceId: input.resourceId }, 'info');

    return {
      success: true,
      resourceId: input.resourceId,
      message,
    };
  }
}