get_avatar_parameters

Instructions

Implementation Reference

• packages/mcp-server/src/server.ts:427-446 (registration)

  MCP server.tool registration for 'get_avatar_parameters' tool, including the thin handler that delegates to avatarTools.getParameterNames()

  server.tool(
    'get_avatar_parameters',
    'Get a list of parameters available on the current avatar.',
    {},
    async (_, extra) => {
      try {
        const ctx = createToolContext(extra);
        const parameters = await avatarTools.getParameterNames(ctx);
        return { content: [{ type: 'text', text: JSON.stringify(parameters) }] };
      } catch (error) {
        return { 
          content: [{ 
            type: 'text', 
            text: `Error getting parameters: ${error instanceof Error ? error.message : String(error)}` 
          }],
          isError: true
        };
      }
    }
  );

• packages/mcp-server/src/tools/avatarTools.ts:163-238 (handler)

  AvatarTools.getParameterNames(): Main handler logic for retrieving avatar parameters, including retries, logging, validation, and fallback handling. Delegates to wsClient.getAvatarParameters()

  public async getParameterNames(ctx?: ToolContext): Promise<string[]> {
    if (ctx) {
      await ctx.info('Getting avatar parameters');
    }
    
    try {
      // Multiple retry attempts
      let attempts = 0;
      const maxAttempts = 3;
      let lastError: Error | null = null;
      
      while (attempts < maxAttempts) {
        attempts++;
        logger.info(`Getting avatar parameters (attempt ${attempts}/${maxAttempts})`);
        
        try {
          // Get the parameters with increased timeout
          const parameters = await this.wsClient.getAvatarParameters();
          
          // Validate the response
          if (!Array.isArray(parameters)) {
            throw new Error('Invalid parameter response: not an array');
          }
          
          // Return the list
          logger.info(`Found ${parameters.length} avatar parameters`);
          
          if (parameters.length > 0) {
            logger.debug(`Parameters: ${parameters.join(', ')}`);
          } else {
            logger.warn('No parameters found for current avatar');
          }
          
          if (ctx) {
            await ctx.info(`Found ${parameters.length} avatar parameters`);
            if (parameters.length <= 10 && parameters.length > 0) {
              await ctx.info(`Parameters: ${parameters.join(', ')}`);
            }
          }
          
          return parameters;
        } catch (error) {
          lastError = error instanceof Error ? error : new Error(String(error));
          logger.warn(`Attempt ${attempts} failed: ${lastError.message}`);
          
          // Wait before retry
          if (attempts < maxAttempts) {
            const delay = 500 * attempts; // Increasing delay for each retry
            logger.info(`Retrying in ${delay}ms...`);
            await new Promise(resolve => setTimeout(resolve, delay));
          }
        }
      }
      
      // All attempts failed
      if (lastError) {
        throw lastError;
      } else {
        throw new Error('Failed to get avatar parameters after multiple attempts');
      }
    } catch (error) {
      logger.error(`Failed to get avatar parameters: ${error instanceof Error ? error.message : String(error)}`);
      
      // Try to get parameters from the loaded config if we have it
      const fallbackParams = this.getFallbackParameters();
      
      if (ctx) {
        await ctx.warning(`Could not get avatar parameters: ${error instanceof Error ? error.message : String(error)}`);
        if (fallbackParams.length > 0) {
          await ctx.info(`Using ${fallbackParams.length} parameters from cached config`);
        }
      }
      
      return fallbackParams;
    }
  }

• packages/mcp-server/src/ws-client.ts:496-525 (helper)

  WebSocketClient.getAvatarParameters(): Low-level implementation that sends WebSocket request 'avatar/getParameters' to the relay server and processes the response into a string array.

  public async getAvatarParameters(): Promise<string[]> {
    try {
      // デバッグ用にリクエスト送信をログ
      this.logger.debug(`Requesting avatar parameters...`);
      
      const response = await this.sendRequest<{ parameters: string[] | Record<string, unknown> }>('avatar/getParameters');
      this.logger.debug(`Avatar parameters response: ${JSON.stringify(response)}`);
      
      // パラメータが配列の場合はそのまま返す
      if (Array.isArray(response?.parameters)) {
        this.logger.debug(`Avatar parameters: ${JSON.stringify(response.parameters)}`);
        return response.parameters;
      }
      
      // パラメータがオブジェクトの場合はキーの配列に変換
      if (response?.parameters && typeof response.parameters === 'object') {
        const parameterNames = Object.keys(response.parameters);
        this.logger.debug(`Avatar parameters (converted from object): ${JSON.stringify(parameterNames)}`);
        return parameterNames;
      }
      
      // パラメータが存在しないか無効な場合
      this.logger.warn('Invalid or missing parameters in response');
      return [];
    } catch (error) {
      this.logger.error(`Error getting avatar parameters: ${error instanceof Error ? error.message : String(error)}`);
      // Return empty array rather than throwing
      return [];
    }
  }