Fix "smart" elicitation

Author: chrisreddington

.vscode/mcp.json

@@ -2,7 +2,7 @@
   "servers": {
     "turn-based-games": {
       "command": "node",
-      "args": ["dist/index.js"],
+      "args": ["dist/server.js"],
       "cwd": "./mcp-server"
     },
     "playwright": {

mcp-server/src/handlers/elicitation-handlers.ts

@@ -72,30 +72,65 @@ export async function elicitGameCreationPreferences(
     }
   }
 
-  const schema = schemas[gameType as keyof typeof schemas]
-  if (!schema) {
+  const baseSchema = schemas[gameType as keyof typeof schemas]
+  if (!baseSchema) {
     throw new Error(`No elicitation schema defined for game type: ${gameType}`)
   }
 
+  // Filter out properties that are already provided
+  const filteredSchema: any = { ...baseSchema }
+  const filteredProperties: Record<string, any> = { ...baseSchema.properties }
+  const filteredRequired = [...(baseSchema.required || [])]
+
+  // Remove properties that already have values
+  if (existingArgs) {
+    Object.keys(existingArgs).forEach(key => {
+      if (existingArgs[key] !== undefined && existingArgs[key] !== null && existingArgs[key] !== '') {
+        delete filteredProperties[key]
+        // Remove from required array if present
+        const requiredIndex = filteredRequired.indexOf(key)
+        if (requiredIndex > -1) {
+          filteredRequired.splice(requiredIndex, 1)
+        }
+      }
+    })
+  }
+
+  filteredSchema.properties = filteredProperties
+  filteredSchema.required = filteredRequired
+
+  // If no properties remain to be elicited, skip elicitation
+  if (Object.keys(filteredProperties).length === 0) {
+    return {
+      action: "accept",
+      content: existingArgs || {}
+    }
+  }
+
   const message = `Let's set up your ${gameType.replace('-', ' ')} game! 🎮\n\nI'll need a few preferences to customize your experience:`
 
   try {
     const result = await server.elicitInput({
       message,
-      requestedSchema: schema
+      requestedSchema: filteredSchema
     })
 
+    // Merge the elicitation result with existing arguments
+    if (result.action === 'accept' && result.content) {
+      result.content = { ...existingArgs, ...result.content }
+    }
+
     return result
   } catch (error) {
     console.error('Elicitation failed:', error)
     // Return default preferences if elicitation fails
     return {
       action: "accept",
       content: {
-        difficulty: existingArgs?.aiDifficulty || DEFAULT_AI_DIFFICULTY,
+        difficulty: existingArgs?.difficulty || DEFAULT_AI_DIFFICULTY,
         playerName: existingArgs?.playerName || DEFAULT_PLAYER_NAME,
-        ...(gameType === 'rock-paper-scissors' && { maxRounds: 3 }),
-        ...(gameType === 'tic-tac-toe' && { playerSymbol: "X" })
+        ...(gameType === 'rock-paper-scissors' && { maxRounds: existingArgs?.maxRounds || 3 }),
+        ...(gameType === 'tic-tac-toe' && { playerSymbol: existingArgs?.playerSymbol || "X" })
       }
     }
   }
@@ -160,10 +195,10 @@ export async function elicitGameCompletionFeedback(
     gameType: string
     gameId: string
     result: 'win' | 'loss' | 'draw'
-    aiDifficulty: string
+    difficulty: string
   }
 ): Promise<ElicitationResult> {
-  const { gameType, result, aiDifficulty } = context
+  const { gameType, result, difficulty } = context
 
   const resultMessages = {
     win: "🎉 Congratulations! You won!",
@@ -179,7 +214,7 @@ export async function elicitGameCompletionFeedback(
         enum: ["too_easy", "just_right", "too_hard"],
         enumNames: ["Too Easy", "Just Right", "Too Hard"],
         title: "How was the difficulty?",
-        description: `The AI was set to ${aiDifficulty} difficulty`
+        description: `The AI was set to ${difficulty} difficulty`
       },
       playAgain: {
         type: "boolean",

mcp-server/src/handlers/game-operations.ts

@@ -38,7 +38,7 @@ export async function playGame(gameType: string, gameId: string) {
   const gameSession = await readGameResource(gameType, gameId)
 
   // Use the difficulty stored in the game session, or fall back to medium
-  const difficulty = gameSession.aiDifficulty || 'medium'
+  const difficulty = gameSession.difficulty || 'medium'
 
   // Check if it's AI's turn
   if (gameSession.gameState.currentPlayerId !== 'ai') {
@@ -319,7 +319,7 @@ export async function createGame(
   gameType: string, 
   playerName: string = DEFAULT_PLAYER_NAME, 
   gameId?: string, 
-  aiDifficulty: string = DEFAULT_AI_DIFFICULTY,
+  difficulty: string = DEFAULT_AI_DIFFICULTY,
   gameSpecificOptions?: Record<string, any>
 ) {
   // Check if game already exists (for games that support custom IDs)
@@ -343,7 +343,7 @@ export async function createGame(
   }
 
   // Create new game via API
-  const gameSession = await createGameViaAPI(gameType, playerName, gameId, aiDifficulty, gameSpecificOptions)
+  const gameSession = await createGameViaAPI(gameType, playerName, gameId, difficulty, gameSpecificOptions)
 
   const response: any = {
     gameId: gameSession.gameState.id,

mcp-server/src/handlers/resource-handlers.ts

@@ -109,7 +109,7 @@ export async function readResource(uri: string) {
                 createdAt: game.gameState?.createdAt,
                 updatedAt: game.gameState?.updatedAt,
                 playerCount: Object.keys(game.gameState?.players || {}).length,
-                aiDifficulty: game.aiDifficulty
+                difficulty: game.difficulty
               })),
               totalGames: games.length,
               timestamp: new Date().toISOString()

mcp-server/src/handlers/tool-handlers.ts

@@ -88,6 +88,26 @@ export const TOOL_DEFINITIONS = [
         gameId: {
           type: 'string',
           description: 'Optional custom game ID. If not provided, a random UUID will be generated.'
+        },
+        difficulty: {
+          type: 'string',
+          enum: DIFFICULTIES,
+          description: 'AI difficulty level (easy, medium, hard). If not provided, will be asked during setup.'
+        },
+        playerName: {
+          type: 'string',
+          description: 'Your name in the game. If not provided, will be asked during setup.'
+        },
+        playerSymbol: {
+          type: 'string',
+          enum: ['X', 'O'],
+          description: 'For tic-tac-toe: your symbol (X goes first, O goes second). If not provided, will be asked during setup.'
+        },
+        maxRounds: {
+          type: 'number',
+          minimum: 1,
+          maximum: 10,
+          description: 'For rock-paper-scissors: number of rounds to play. If not provided, will be asked during setup.'
         }
       },
       required: ['gameType']
@@ -147,7 +167,7 @@ export async function handleToolCall(name: string, args: any, server?: any) {
         if (!isSupportedGameType(genericGameType)) {
           throw new Error(`Unsupported game type: ${genericGameType}`)
         }
-        return await createGameWithElicitation(genericGameType, genericGameId, server)
+        return await createGameWithElicitation(genericGameType, genericGameId, server, args)
 
       default:
         throw new Error(`Unknown tool: ${name}`)
@@ -160,7 +180,7 @@ export async function handleToolCall(name: string, args: any, server?: any) {
 /**
  * Create game with interactive elicitation
  */
-async function createGameWithElicitation(gameType: string, gameId?: string, server?: any) {
+async function createGameWithElicitation(gameType: string, gameId?: string, server?: any, toolArgs?: any) {
   if (!server) {
     // Fallback to regular creation if no server for elicitation
     return await createGame(gameType, DEFAULT_PLAYER_NAME, gameId, DEFAULT_AI_DIFFICULTY)
@@ -170,8 +190,10 @@ async function createGameWithElicitation(gameType: string, gameId?: string, serv
     // Elicit user preferences
     const elicitationResult = await elicitGameCreationPreferences(server, gameType, {
       gameId,
-      playerName: 'Player',
-      aiDifficulty: 'medium'
+      playerName: toolArgs?.playerName,
+      difficulty: toolArgs?.difficulty,
+      playerSymbol: toolArgs?.playerSymbol,
+      maxRounds: toolArgs?.maxRounds
     })
 
     if (elicitationResult.action === 'decline' || elicitationResult.action === 'cancel') {

mcp-server/src/integration/integration.test.ts

@@ -88,7 +88,7 @@ describe('MCP Server Integration', () => {
             currentPlayerId: 'player1',
             players: { player1: 'Human', ai: 'AI' }
           },
-          aiDifficulty: 'medium'
+          difficulty: 'medium'
         }
       ])
 
@@ -154,7 +154,7 @@ describe('MCP Server Integration', () => {
           status: 'playing',
           currentPlayerId: 'ai'
         },
-        aiDifficulty: 'medium'
+        difficulty: 'medium'
       })
 
       mockSubmitMoveViaAPI.mockResolvedValue({

mcp-server/src/utils/http-client.ts

@@ -27,16 +27,16 @@ export async function createGameViaAPI(
   gameType: string, 
   playerName: string, 
   gameId?: string, 
-  aiDifficulty?: string,
+  difficulty?: string,
   gameSpecificOptions?: Record<string, any>
 ) {
   try {
     const data: any = { playerName }
     if (gameId) {
       data.gameId = gameId
     }
-    if (aiDifficulty) {
-      data.aiDifficulty = aiDifficulty
+    if (difficulty) {
+      data.difficulty = difficulty
     }
     // Merge any game-specific options
     if (gameSpecificOptions) {

shared/src/index.ts

@@ -3,5 +3,4 @@ export type * from './types/games';
 export * from './games/index';
 export * from './utils/index';
 export * from './storage/index';
-export * from './testing/index';
 export * from './constants/index';

shared/src/testing/api-test-utils.ts

@@ -87,7 +87,7 @@ export function createMockGameSession<T extends BaseGameState>(gameState: T, gam
     gameState,
     gameType,
     history: [],
-    aiDifficulty: 'medium'
+    difficulty: 'medium'
   }
 }
 

shared/src/types/game.ts

@@ -44,5 +44,5 @@ export interface GameSession<TGameState extends BaseGameState = BaseGameState> {
   gameState: TGameState;
   gameType: GameType;
   history: GameMove[];
-  aiDifficulty?: Difficulty;
+  difficulty?: Difficulty;
 }