World Model

 npm install axios

 // Replace the axios.post call
// Original: const resp = await axios.post(`https://${MPS_HOST}`, payload, { headers });
//     return resp.data;
// Change to:
const resp = await fetch(`https://${MPS_HOST}`, {
    method: 'POST',
    headers: headers,
    body: JSON.stringify(payload)
});
return await resp.json();


{
  "tencentCloud": {
    "secretId": "Your SecretId",
    "secretKey": "Your SecretKey",
    "region": "ap-guangzhou"
  }
}

/**
 * TencentCloud API Signature Tool (TC3-HMAC-SHA256)
 */
const crypto = require('crypto');

function sha256(message) {
    return crypto.createHash('sha256').update(message).digest('hex');
}

function hmac256(key, message) {
    return crypto.createHmac('sha256', key).update(message).digest();
}

/**
 * Generate a TencentCloud API V3 signature.
 * @param {string} secretId   - TencentCloud SecretId
 * @param {string} secretKey  - TencentCloud SecretKey
 * @param {string} service    - Service name, for example, 'mps'
 * @param {string} action     - API name, for example, 'CreateAigcVideoTask'
 * @param {string} payload    - Request body in JSON string format
 * @param {string} region     - Region, for example, 'ap-guangzhou'
 * @param {string} [version]  - API version number, default '2019-06-12'
 * @returns {{ headers: object }} - Request headers with the complete signature.
 */
function signRequest(secretId, secretKey, service, action, payload, region, version) {
    const timestamp = Math.floor(Date.now() / 1000);
    const date = new Date(timestamp * 1000).toISOString().split('T')[0];

    // ===== Step 1: Concatenate the canonical request string =====
    const httpRequestMethod = 'POST';
    const canonicalUri = '/';
    const canonicalQueryString = '';
    const contentType = 'application/json';
    const canonicalHeaders =
        `content-type:${contentType}\n` +
        `host:${service}.tencentcloudapi.com\n` +
        `x-tc-action:${action.toLowerCase()}\n`;
    const signedHeaders = 'content-type;host;x-tc-action';
    const hashedRequestPayload = sha256(payload);
    const canonicalRequest =
        `${httpRequestMethod}\n${canonicalUri}\n${canonicalQueryString}\n` +
        `${canonicalHeaders}\n${signedHeaders}\n${hashedRequestPayload}`;

    // ===== Step 2: Concatenate the string to sign =====
    const algorithm = 'TC3-HMAC-SHA256';
    const credentialScope = `${date}/${service}/tc3_request`;
    const hashedCanonicalRequest = sha256(canonicalRequest);
    const stringToSign =
        `${algorithm}\n${timestamp}\n${credentialScope}\n${hashedCanonicalRequest}`;

    // ===== Step 3: Calculate the signature =====
    const secretDate = hmac256(`TC3${secretKey}`, date);
    const secretService = hmac256(secretDate, service);
    const secretSigning = hmac256(secretService, 'tc3_request');
    const signature = crypto.createHmac('sha256', secretSigning)
        .update(stringToSign).digest('hex');

    // ===== Step 4: Concatenate the Authorization header =====
    const authorization =
        `${algorithm} Credential=${secretId}/${credentialScope}, ` +
        `SignedHeaders=${signedHeaders}, Signature=${signature}`;

    return {
        headers: {
            'Authorization': authorization,
            'Content-Type': contentType,
            'Host': `${service}.tencentcloudapi.com`,
            'X-TC-Action': action,
            'X-TC-Timestamp': String(timestamp),
            'X-TC-Version': version || '2019-06-12',
            'X-TC-Region': region || ''
        }
    };
}

module.exports = { signRequest };

const axios = require('axios');
const { signRequest } = require('./tencent-sign');
const MPS_HOST = 'mps.intl.tencentcloudapi.com';
const SERVICE = 'mps';
/**
 * Generic MPS API call function
 */
async function callMpsApi(action, params, config) {
    const payload = JSON.stringify(params);
    const { headers } = signRequest(
        config.tencentCloud.secretId,
        config.tencentCloud.secretKey,
        SERVICE,
        action,
        payload,
        config.tencentCloud.region
    );
    const resp = await axios.post(`https://${MPS_HOST}`, payload, { headers });
    return resp.data;
}
// =============================================
// Hunyuan panoramic image (360°, ModelVersion=3d-world-panorama-2.0)
// =============================================
/**
 * Create a Hunyuan panoramic image task
 * @param {string} prompt   - Panoramic description (up to 600 characters)
 * @param {string} imageUrl - Reference image URL (optional, used for image-to-panorama generation)
 * @param {object} options  - Additional options
 * @param {string} options.modelName    - Model name, default: 'Hunyuan'
 * @param {string} options.modelVersion - Model version, default: '3d-world-panorama-2.0'
 * @param {object} options.storeCos     - COS storage parameters
 * @returns {{ Response: { TaskId: string, RequestId: string } }}
 */
async function createPanoramaTask(prompt, imageUrl, options = {}) {
    const config = options._config; // Pass in the configuration object
    const params = {
        ModelName: options.modelName || 'Hunyuan',
        ModelVersion: options.modelVersion || '3d-world-panorama-2.0',
        Prompt: prompt,
        Operator: options.operator || 'admin'
    };
    // Reference image (image-to-panorama)
    if (imageUrl) {
        params.ImageUrl = imageUrl;
    }
    // COS Storage
    if (options.storeCos) {
        params.StoreCosParam = options.storeCos;
    }
    return await callMpsApi('CreateAigcImageTask', params, config);
}
// =============================================
// Hunyuan 3D World (ModelVersion=3d-world-scene-2.0)
// =============================================
/**
 * Create a Hunyuan 3D World task (text-to-3D / image-to-3D, or real-scene 3D reconstruction)
 * @param {string} prompt   - Scene description (up to 600 characters)
 * @param {string} imageUrl - Reference image URL (optional, used for image-to-3D generation)
 * @param {object} options  - Additional options
 * @param {string} options.modelName    - Model name, default: 'Hunyuan'
 * @param {string} options.modelVersion - Model version, default: '3d-world-scene-2.0'
 * @param {object} options.storeCos     - COS storage parameters
 * @returns {{ Response: { TaskId: string, RequestId: string } }}
 */
async function createWorldTask(prompt, imageUrl, options = {}) {
    const config = options._config; // Pass in the configuration object
    const params = {
        ModelName: options.modelName || 'Hunyuan',
        ModelVersion: options.modelVersion || '3d-world-scene-2.0',
        Prompt: prompt,
        Operator: options.operator || 'admin'
    };
    // Reference image (image-to-3D / real-scene reconstruction)
    if (imageUrl) {
        params.ImageUrl = imageUrl;
    }
    // COS Storage
    if (options.storeCos) {
        params.StoreCosParam = options.storeCos;
    }
    return await callMpsApi('CreateAigcVideoTask', params, config);
}
/**
 * Query a Hunyuan panoramic image task
 * @param {string} taskId - TaskId returned during task creation, in the format '4-AigcImage-xxx'
 * @param {object} config - Configuration object
 * @returns {{ Response: { Status: string, ImageUrl: string[], Message: string, RequestId: string } }}
 *   Status: 'WAIT' | 'RUN' | 'DONE' | 'FAIL'
 *   ImageUrl: A list of panoramic image URLs returned when the task is completed (⚠️ stored for only 12 hours)
 */
async function describeImageTask(taskId, config) {
    return await callMpsApi('DescribeAigcImageTask', { TaskId: taskId }, config);
}
/**
 * Query a Hunyuan 3D world task
 * @param {string} taskId - TaskId returned during task creation, in the format '4-AigcImage-xxx'
 * @param {object} config - Configuration object
 * @returns {{ Response: { Status: string, Message: string, RequestId: string,
 *     image_url: string, scene_url: string, point_url: string,
 *     mesh_url: string, mesh_simplified_url: string, position_info: string } }}
 *   Status: 'WAIT' | 'RUN' | 'DONE' | 'FAIL'
 *   Returned when the task is completed (DONE):
 *   scene_url           - 3DGS scene file URL
 *   mesh_url            - Mesh file URL (GLB/FBX/OBJ)
 *   mesh_simplified_url - Simplified Mesh URL
 *   point_url           - Point cloud file URL (PLY)
 *   image_url           - Preview image URL
 *   position_info       - Position/bounding box information as a JSON string (up_direction, facing_direction, center_point, scale, x/y/z_min/max)
 *   ⚠️ The above result URLs are stored for only 12 hours.
 */
async function describeSceneTask(taskId, config) {
    return await callMpsApi('DescribeAigcImageTask', { TaskId: taskId }, config);
}
module.exports = {
    callMpsApi,
    createPanoramaTask,
    createWorldTask,
    describeImageTask,
    describeSceneTask
};


async function generatePanorama() {
    // Step 1: Create a panoramic image generation task
    console.log('🌏 Creating panoramic image generation task...');
    const createResult = await callMpsApi('CreateAigcImageTask', {
        ModelName: 'Hunyuan',  
        ModelVersion: '3d-world-panorama-2.0',  
        Prompt: 'a 360 panorama of a fantasy castle on a cliff',  
        Operator: 'admin'
    });
    const taskId = createResult.Response.TaskId;
    console.log(`✅ Task created successfully, TaskId: ${taskId}`);
    // Step 2: Poll for task status
    let status = 'WAIT';
    let imageUrls = [];
    while (status === 'WAIT' || status === 'RUN') {
        await new Promise(resolve => setTimeout(resolve, 5000));
        const queryResult = await callMpsApi('DescribeAigcImageTask', {
            TaskId: taskId
        });
        status = queryResult.Response.Status;
        console.log(`⏳ Task status: ${status}`);
        if (status === 'DONE') {
            imageUrls = queryResult.Response.ImageUrls;
            console.log('🎉 Panoramic image generated successfully!');
            console.log(`🖼️ Panoramic image URL: ${imageUrls}`);
        } else if (status === 'FAIL') {
            console.error('❌ Generation failed:');
        }
    }
    return imageUrls;
}
generatePanorama().catch(console.error);


async function generateWorld() {
    // Step 1: Create a 3D scene generation task (using an image as a reference for image-to-3D scene generation)
    console.log('🌍 Creating 3D world generation task...');
    const createResult = await callMpsApi('CreateAigcVideoTask', {
        ModelName: 'Hunyuan',  
        ModelVersion: '3d-world-scene-2.0',  
        Prompt: 'generate a walkable 3D world from this image',  
        ImageUrl: 'https://example.com/scene.png',   // Reference image (image-to-3D)  
        Operator: 'admin'

    });
    const taskId = createResult.Response.TaskId;
    console.log(`✅ Task created successfully, TaskId: ${taskId}`);
    // Step 2: Poll for task status
    let status = 'WAIT';
    let videoUrls = [];
    while (status === 'WAIT' || status === 'RUN') {
        await new Promise(resolve => setTimeout(resolve, 5000));
        const queryResult = await callMpsApi('DescribeAigcVideoTask', {
            TaskId: taskId
        });
        status = queryResult.Response.Status;
        console.log(`⏳ Task status: ${status}`);
        if (status === 'DONE') {
            videoUrls = queryResult.Response.VideoUrls;
            const resolution = queryResult.Response.Resolution;
            console.log('🎉 3D scene generated successfully!');
            console.log(`📹 Result URL: ${videoUrls}`);
            console.log(`📐 Resolution: ${resolution}`);
        } else if (status === 'FAIL') {
            console.error('❌ Generation failed:');
        }
    }
    return videoUrls;
}
generateWorld().catch(console.error);


/**
 * Polling function with retries and timeouts (both panorama and 3D scene tasks are queried through DescribeAigcImageTask)
 * @param {string} taskId   - Task ID
 * @param {number} timeout - Timeout in milliseconds, defaulting to 30 minutes
 * @param {number} interval - Polling interval in milliseconds, defaulting to 5000
 */
async function pollTaskResult(taskId, timeout = 1800000, interval = 5000) {
    const startTime = Date.now();
    while (Date.now() - startTime < timeout) {
        const result = await callMpsApi('DescribeAigcImageTask', { TaskId: taskId });
        const resp = result.Response;
        if (resp.Status === 'DONE') {
            // Panorama: resp.ImageUrl; 3D scene: resp.scene_url / mesh_url / point_url, etc.
            return { success: true, response: resp };
        }
        if (resp.Status === 'FAIL') {
            return {
                success: false,
                error: resp.Message || 'Task failed'
            };
        }
        // WAIT or RUN, continue waiting
        await new Promise(resolve => setTimeout(resolve, interval));
    }
    return { success: false, error: 'Polling timed out' };
}
// Usage example
async function main() {
    // Create a panoramic image task (360°)
    const panoTask = await callMpsApi('CreateAigcImageTask', {
        ModelName: 'Hunyuan',
        ModelVersion: '3d-world-panorama-2.0',
        Prompt: 'a 360 panorama of a fantasy castle on a cliff',
        Operator: 'admin'
    });

    const panoResult = await pollTaskResult(panoTask.Response.TaskId);
    if (panoResult.success) {
        console.log('Panorama:', panoResult.response.ImageUrl[0]);
        // Continue generating a walkable 3D scene using the panorama as a reference image.
        const worldTask = await callMpsApi('CreateAigcVideoTask', {
            ModelName: 'Hunyuan',
            ModelVersion: '3d-world-scene-2.0',
            Prompt: 'generate a walkable 3D world from this image',
            ImageUrl: panoResult.response.ImageUrl[0],
            Operator: 'admin'
        });
        const worldResult = await pollTaskResult(worldTask.Response.TaskId);
        if (worldResult.success) {
            const resp = worldResult.response;
            console.log('3DGS scene:', resp.scene_url);
            console.log('Mesh:', resp.mesh_url);
            console.log('Simplified Mesh:', resp.mesh_simplified_url);
            console.log('Point cloud PLY:', resp.point_url);
        }
    }
}
main().catch(console.error);


{
    "tencentCloud": {
        "secretId": "Your SecretId",
        "secretKey": "Your SecretKey",
        "region": "ap-guangzhou"
    },
    "cosOutput": {
        "bucket": "your-bucket-name-1234567890",
        "region": "ap-guangzhou",
        "outputDir": "/aigc-output/"
    },
    "mps": {
        "panorama": {
            "enabled": true,
            "modelName": "Hunyuan",
            "modelVersion": "3d-world-panorama-2.0"
        },
        "world3d": {
            "enabled": true,
            "modelName": "Hunyuan",
            "modelVersion": "3d-world-scene-2.0"
        }
    },
    "concurrency": {
        "maxPanoramaTasks": 2,
        "maxWorldTasks": 1,
        "pollIntervalMs": 5000
    }
}