Task Management

apiV1JobJobIdGet()

Get current task status:

const { Configuration, ImageApi } = require('@legnext-api/js-sdk');

const apiClient = new Configuration();
apiClient.basePath = 'https://api.legnext.ai';
const imageApi = new ImageApi(apiClient);

const apiKey = 'your-api-key-here';
const jobId = 'job-123';

const task = await imageApi.apiV1JobJobIdGet(jobId, apiKey);
console.log('Status:', task.status);
console.log('Progress:', task.progress + '%');

if (task.status === 'completed') {
    console.log('Result:', task.output);
}

Polling for Completion

Wait for task completion with polling:

async function waitForCompletion(
    api,
    jobId,
    apiKey,
    timeoutSeconds = 300,
    pollIntervalSeconds = 3
) {
    const startTime = Date.now();
    const timeout = timeoutSeconds * 1000;

    while (true) {
        const task = await api.apiV1JobJobIdGet(jobId, apiKey);
        console.log('Current status:', task.status);

        if (task.status === 'completed') {
            console.log('Task completed successfully!');
            console.log('Output:', task.output);
            return task;
        } else if (task.status === 'failed') {
            throw new Error(`Task failed: ${task.error}`);
        }

        // Check timeout
        if (Date.now() - startTime > timeout) {
            throw new Error(`Task timeout after ${timeoutSeconds} seconds`);
        }

        // Wait before next poll
        await new Promise(resolve => setTimeout(resolve, pollIntervalSeconds * 1000));
    }
}

Usage:

try {
    const result = await waitForCompletion(imageApi, jobId, apiKey, 300, 3);
    console.log('Final result:', result);
} catch (error) {
    console.error('Error:', error.message);
}

Complete Example with Error Handling

const { Configuration, ImageApi } = require('@legnext-api/js-sdk');

async function generateImageWithPolling() {
    const apiClient = new Configuration();
    apiClient.basePath = 'https://api.legnext.ai';
    const imageApi = new ImageApi(apiClient);

    const apiKey = process.env.LEGNEXT_API_KEY;

    try {
        // Step 1: Start generation
        const body = {
            text: 'a beautiful sunset over mountains'
        };

        const response = await imageApi.apiV1DiffusionPost(apiKey, body);
        const jobId = response.jobId;
        console.log('Job started:', jobId);

        // Step 2: Poll for completion
        const result = await waitForCompletion(imageApi, jobId, apiKey, 600, 3);

        // Step 3: Get final result
        console.log('Image URLs:', result.output.imageUrls);

    } catch (error) {
        handleError(error);
    }
}

function handleError(error) {
    if (error.status) {
        const statusCode = error.status;
        const errorBody = error.response?.body;

        switch (statusCode) {
            case 400:
                console.error('Validation error:', errorBody);
                break;
            case 401:
                console.error('Authentication error: Invalid API key');
                break;
            case 404:
                console.error('Resource not found:', errorBody);
                break;
            case 429:
                console.error('Rate limit exceeded. Please retry later.');
                break;
            case 500:
            case 502:
            case 503:
                console.error('Server error:', errorBody);
                break;
            default:
                console.error(`API error (${statusCode}):`, errorBody);
        }
    } else {
        console.error('Unexpected error:', error.message);
    }
}

generateImageWithPolling();

Error Handling

Common HTTP Status Codes:

Status Code	Description	Action
400	Invalid request parameters	Check request body format
401	Invalid API key	Verify API key is correct
404	Resource not found	Check job ID exists
429	Rate limit exceeded	Wait and retry with backoff
500/502/503	Server error	Retry with exponential backoff

Handling Different Error Scenarios:

async function callWithRetry(apiCall, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            return await apiCall();
        } catch (error) {
            if (error.status === 429) {
                // Rate limited - wait and retry
                await new Promise(resolve => setTimeout(resolve, 5000));
                continue;
            } else if (error.status >= 500) {
                // Server error - exponential backoff
                const delay = Math.pow(2, i) * 1000;
                await new Promise(resolve => setTimeout(resolve, delay));
                if (i === maxRetries - 1) throw error; // Last retry
                continue;
            } else {
                // Other errors - don't retry
                throw error;
            }
        }
    }
}

// Usage
try {
    const response = await callWithRetry(() =>
        imageApi.apiV1DiffusionPost(apiKey, body)
    );
} catch (error) {
    console.error('Failed after retries:', error);
}

Async Operations with Promise.all

For concurrent operations:

async function generateMultipleImages() {
    const apiClient = new Configuration();
    apiClient.basePath = 'https://api.legnext.ai';
    const imageApi = new ImageApi(apiClient);
    const apiKey = process.env.LEGNEXT_API_KEY;

    const prompts = ['sunset', 'mountains', 'ocean'];

    try {
        // Start all generations concurrently
        const promises = prompts.map(async (prompt) => {
            const body = { text: prompt };
            const response = await imageApi.apiV1DiffusionPost(apiKey, body);

            // Wait for each to complete
            const result = await waitForCompletion(
                imageApi,
                response.jobId,
                apiKey,
                600,
                3
            );

            return result.output.imageUrls[0];
        });

        const imageUrls = await Promise.all(promises);

        imageUrls.forEach((url, index) => {
            console.log(`Image ${index + 1}:`, url);
        });

    } catch (error) {
        console.error('Error:', error);
    }
}

generateMultipleImages();

Progress Callbacks

async function waitForCompletionWithProgress(
    api,
    jobId,
    apiKey,
    onProgress,
    timeoutSeconds = 300,
    pollIntervalSeconds = 3
) {
    const startTime = Date.now();
    const timeout = timeoutSeconds * 1000;

    while (true) {
        const task = await api.apiV1JobJobIdGet(jobId, apiKey);

        // Call progress callback
        if (onProgress) {
            onProgress(task.progress || 0, task.status);
        }

        if (task.status === 'completed') {
            return task;
        } else if (task.status === 'failed') {
            throw new Error(`Task failed: ${task.error}`);
        }

        if (Date.now() - startTime > timeout) {
            throw new Error(`Task timeout after ${timeoutSeconds} seconds`);
        }

        await new Promise(resolve => setTimeout(resolve, pollIntervalSeconds * 1000));
    }
}

// Usage
const result = await waitForCompletionWithProgress(
    imageApi,
    jobId,
    apiKey,
    (progress, status) => {
        console.log(`Progress: ${progress}% - Status: ${status}`);
    }
);

Overview

Client Libraries

apiV1JobJobIdGet()

Polling for Completion

Complete Example with Error Handling

Error Handling

Async Operations with Promise.all

Progress Callbacks

Learn More

​apiV1JobJobIdGet()

​Polling for Completion

​Complete Example with Error Handling

​Error Handling

​Async Operations with Promise.all

​Progress Callbacks

​Learn More

apiV1JobJobIdGet()

Polling for Completion

Complete Example with Error Handling

Error Handling

Async Operations with Promise.all

Progress Callbacks

Learn More