Server Prompts API

server.registerPrompt<Args extends PromptArgsRawShape>(
  name: string,
  config: {
    title?: string;
    description?: string;
    argsSchema?: Args;
    icons?: Icons;
    _meta?: Record<string, unknown>;
  },
  callback: (args: z.infer<ZodObject<Args>>) => GetPromptResult | Promise<GetPromptResult>
): RegisteredPrompt;

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

const server = new McpServer({ name: 'prompts-server', version: '1.0.0' });

// Simple prompt without arguments
server.registerPrompt('code-review', {
  title: 'Code Review',
  description: 'Review code for best practices'
}, () => ({
  messages: [{
    role: 'user',
    content: { type: 'text', text: 'Please review my code for best practices and potential issues.' }
  }]
}));

// Prompt with arguments
server.registerPrompt('analyze-file', {
  title: 'Analyze File',
  description: 'Analyze a specific file',
  argsSchema: {
    filePath: z.string().describe('Path to the file'),
    analysisType: z.enum(['security', 'performance', 'style']).describe('Type of analysis to perform')
  }
}, ({ filePath, analysisType }) => ({
  description: `Analyze ${filePath} for ${analysisType}`,
  messages: [{
    role: 'user',
    content: { type: 'text', text: `Please analyze ${filePath} focusing on ${analysisType} aspects.` }
  }]
}));

// Prompt with embedded resources
server.registerPrompt('review-code-with-context', {
  title: 'Code Review with Context',
  description: 'Review code with full context',
  argsSchema: {
    code: z.string().describe('Code to review')
  }
}, ({ code }) => ({
  messages: [
    { role: 'user', content: { type: 'text', text: 'Please review this code:' } },
    { role: 'user', content: { type: 'resource', resource: { uri: 'inline://code', mimeType: 'text/plain', text: code } } }
  ]
}));

// Multi-turn conversation
server.registerPrompt('interactive-review', {
  title: 'Interactive Code Review',
  description: 'Start an interactive code review session'
}, () => ({
  description: 'Interactive code review',
  messages: [
    { role: 'user', content: { type: 'text', text: 'I need help reviewing some code' } },
    { role: 'assistant', content: { type: 'text', text: 'I\'d be happy to help! Please share the code you\'d like me to review.' } }
  ]
}));

import { completable } from '@modelcontextprotocol/sdk/server/completable.js';

// completable<T>(schema: ZodType<T>, completeCallback: CompleteCallback<T>): Completable<T>
type CompleteCallback<T> = (value: string, context?: { arguments?: Record<string, unknown> }) => Promise<string[]> | string[];

server.registerPrompt('team-greeting', {
  title: 'Team Greeting',
  description: 'Generate a greeting for team members',
  argsSchema: {
    department: completable(z.string(), (value) => {
      return ['engineering', 'sales', 'marketing', 'support'].filter(d => d.startsWith(value));
    }),
    name: completable(z.string(), (value, context) => {
      // Provide name suggestions based on selected department
      const department = context?.arguments?.['department'];
      if (department === 'engineering') {
        return ['Alice', 'Bob', 'Charlie'].filter(n => n.startsWith(value));
      } else if (department === 'sales') {
        return ['David', 'Eve', 'Frank'].filter(n => n.startsWith(value));
      }
      return ['Guest'].filter(n => n.startsWith(value));
    })
  }
}, ({ department, name }) => ({
  messages: [{
    role: 'assistant',
    content: { type: 'text', text: `Hello ${name}, welcome to the ${department} team!` }
  }]
}));

interface GetPromptResult {
  description?: string;
  messages: PromptMessage[];
  _meta?: Record<string, unknown>;
}

interface PromptMessage {
  role: 'user' | 'assistant';
  content: ContentBlock;  // TextContent | ImageContent | AudioContent | EmbeddedResource
}

// Simple text prompt
return {
  messages: [{ role: 'user', content: { type: 'text', text: 'Analyze this data for trends' } }]
};

// Prompt with image
return {
  messages: [{ role: 'user', content: { type: 'image', data: base64ImageData, mimeType: 'image/png' } }]
};

// Prompt with embedded resource
return {
  messages: [{
    role: 'user',
    content: {
      type: 'resource',
      resource: { uri: 'file:///project/README.md', mimeType: 'text/markdown', text: readmeContent }
    }
  }]
};

interface RegisteredPrompt {
  enable(): void;
  disable(): void;
  update(config: Partial<{ title?: string; description?: string; argsSchema?: PromptArgsRawShape; }>): void;
  remove(): void;
}

server.sendPromptListChanged(): Promise<void>;

interface Prompt {
  name: string;
  title?: string;
  description?: string;
  arguments?: PromptArgument[];
  icons?: Icons;
  _meta?: Record<string, unknown>;
}

interface PromptArgument {
  name: string;
  description?: string;
  required?: boolean;
}

interface ListPromptsResult {
  prompts: Prompt[];
  nextCursor?: string;
}

type PromptArgsRawShape = Record<string, ZodTypeAny>;

server.prompt(name: string, callback: PromptCallback): RegisteredPrompt;
server.prompt(name: string, description: string, callback: PromptCallback): RegisteredPrompt;
server.prompt<Args extends PromptArgsRawShape>(name: string, argsSchema: Args, callback: PromptCallback<Args>): RegisteredPrompt;
server.prompt<Args extends PromptArgsRawShape>(name: string, description: string, argsSchema: Args, callback: PromptCallback<Args>): RegisteredPrompt;