generateIntegerSequences

Instructions

Implementation Reference

• src/server.ts:320-337 (handler)

  MCP server handler function that calls the RandomOrgClient to generate integer sequences and formats the response as MCP content.

  private async handleGenerateIntegerSequences(args: any) {
    const result = await this.randomOrgClient.generateIntegerSequences(args);
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify({
            data: result.random.data,
            completionTime: result.random.completionTime,
            bitsUsed: result.bitsUsed,
            bitsLeft: result.bitsLeft,
            requestsLeft: result.requestsLeft,
            advisoryDelay: result.advisoryDelay,
          }, null, 2),
        },
      ],
    };
  }

• src/server.ts:77-121 (registration)

  Tool registration in the listTools handler, including name, description, and detailed input schema.

  {
    name: 'generateIntegerSequences',
    description: 'Generate sequences of true random integers',
    inputSchema: {
      type: 'object',
      properties: {
        n: {
          type: 'number',
          description: 'Number of sequences to generate (1-10,000)',
          minimum: 1,
          maximum: 10000,
        },
        length: {
          type: 'number',
          description: 'Length of each sequence (1-10,000)',
          minimum: 1,
          maximum: 10000,
        },
        min: {
          type: 'number',
          description: 'Minimum value (inclusive)',
          minimum: -1000000000,
          maximum: 1000000000,
        },
        max: {
          type: 'number',
          description: 'Maximum value (inclusive)',
          minimum: -1000000000,
          maximum: 1000000000,
        },
        replacement: {
          type: 'boolean',
          description: 'Allow replacement within each sequence',
          default: true,
        },
        base: {
          type: 'number',
          description: 'Number base (2, 8, 10, or 16)',
          enum: [2, 8, 10, 16],
          default: 10,
        },
      },
      required: ['n', 'length', 'min', 'max'],
    },
  },

• src/randomOrgClient.ts:88-91 (handler)

  Core client handler that validates input parameters and makes the HTTP request to Random.org API for generating integer sequences.

  async generateIntegerSequences(params: IntegerSequenceParams): Promise<IntegerSequenceResult> {
    this.validateIntegerSequenceParams(params);
    return this.makeRequest<IntegerSequenceResult>('generateIntegerSequences', params);
  }

• src/types.ts:121-128 (schema)

  TypeScript interface defining the input parameters for generateIntegerSequences, used for type safety.

  export interface IntegerSequenceParams {
    n: number;
    length: number;
    min: number;
    max: number;
    replacement?: boolean;
    base?: number;
  }

• src/randomOrgClient.ts:141-157 (helper)

  Validation helper function ensuring input parameters meet Random.org API constraints for integer sequences.

  private validateIntegerSequenceParams(params: IntegerSequenceParams): void {
    if (params.n < 1 || params.n > 10000) {
      throw new Error('n must be between 1 and 10,000');
    }
    if (params.length < 1 || params.length > 10000) {
      throw new Error('length must be between 1 and 10,000');
    }
    if (params.min < -1000000000 || params.min > 1000000000) {
      throw new Error('min must be between -1,000,000,000 and 1,000,000,000');
    }
    if (params.max < -1000000000 || params.max > 1000000000) {
      throw new Error('max must be between -1,000,000,000 and 1,000,000,000');
    }
    if (params.min >= params.max) {
      throw new Error('min must be less than max');
    }
  }