n8n-nodes-wavespeed
Version:
N8N nodes for WaveSpeed AI API - multimodal AI models for text-to-image, image-to-image, text-to-video, and image-to-video generation
203 lines (202 loc) • 9.61 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.WaveSpeedTaskSubmitByJson = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const WaveSpeedClient_1 = require("../../utils/WaveSpeedClient");
class WaveSpeedTaskSubmitByJson {
constructor() {
this.description = {
displayName: 'WaveSpeed Task Submit By JSON',
name: 'waveSpeedTaskSubmitByJson',
icon: 'file:WaveSpeedTaskSubmitByJson.svg',
group: ['input'],
version: 1,
subtitle: '={{$parameter["modelId"]}}',
description: 'Submit tasks to WaveSpeed AI models using model UUID and JSON parameters (for automation scenarios)',
documentationUrl: 'https://wavespeed.ai/docs',
defaults: {
name: 'WaveSpeed Task Submit By JSON',
},
inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
credentials: [
{
name: 'wavespeedApi',
required: true,
},
],
properties: [
{
displayName: 'Model UUID',
name: 'modelId',
type: 'string',
default: '',
required: true,
description: 'The UUID of the model to use (e.g., "f2a7c7b8-1234-5678-9abc-def012345678")',
placeholder: 'Enter model UUID',
},
{
displayName: 'Parameters (JSON)',
name: 'parametersJson',
type: 'json',
default: '{}',
required: false,
description: 'Model parameters in JSON format. Example: {"prompt": "Hello world", "temperature": 0.7}',
},
{
displayName: 'Execution Mode',
name: 'executionMode',
type: 'options',
options: [
{
name: 'Submit Task Only',
value: 'submit',
description: 'Submit task and return task ID immediately',
},
{
name: 'Wait for Completion',
value: 'wait',
description: 'Submit task and wait for completion',
},
],
default: 'submit',
description: 'Whether to wait for task completion or return immediately',
},
{
displayName: 'Polling Options',
name: 'pollingOptions',
type: 'collection',
placeholder: 'Add Option',
default: {},
displayOptions: {
show: {
executionMode: ['wait'],
},
},
options: [
{
displayName: 'Max Wait Time (minutes)',
name: 'maxWaitTime',
type: 'number',
default: 5,
description: 'Maximum time to wait for completion in minutes',
},
{
displayName: 'Poll Interval (seconds)',
name: 'pollInterval',
type: 'number',
default: 5,
description: 'How often to check task status in seconds',
},
{
displayName: 'Max Retries (Check Status Errors)',
name: 'maxRetries',
type: 'number',
default: 20,
description: 'Maximum number of retries when status check fails (for network/server errors)',
typeOptions: {
minValue: 1,
maxValue: 100
}
},
],
},
],
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
for (let i = 0; i < items.length; i++) {
try {
const modelId = this.getNodeParameter('modelId', i);
const parametersJson = this.getNodeParameter('parametersJson', i);
const executionMode = this.getNodeParameter('executionMode', i);
// Validate model ID
if (!modelId || modelId.trim() === '') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Model UUID is required', { itemIndex: i });
}
const credentials = await this.getCredentials('wavespeedApi');
const apiKey = credentials.apiKey;
// Parse JSON parameters
let requestData = {};
try {
if (parametersJson && parametersJson.trim() !== '' && parametersJson.trim() !== '{}') {
requestData = JSON.parse(parametersJson);
if (typeof requestData !== 'object' || requestData === null || Array.isArray(requestData)) {
throw new Error('Parameters JSON must be a valid JSON object');
}
}
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON parameters: ${error instanceof Error ? error.message : 'Unknown JSON parsing error'}`, { itemIndex: i });
}
// Submit task
const taskResult = await WaveSpeedClient_1.WaveSpeedClient.submitTask(modelId, requestData, apiKey);
let result = {
task_id: taskResult.id,
model: taskResult.model,
input: taskResult.input,
status: taskResult.status,
created_at: taskResult.created_at,
model_id: modelId,
parameters: requestData,
};
// If task is already completed (synchronous return), include results directly
if (taskResult.status === 'completed') {
result.outputs = taskResult.outputs;
result.has_nsfw_contents = taskResult.has_nsfw_contents;
result.timings = taskResult.timings;
}
// If wait for completion mode is selected and task is not completed
if (executionMode === 'wait' && taskResult.status !== 'completed' && taskResult.status !== 'failed') {
const pollingOptions = this.getNodeParameter('pollingOptions', i, {});
const maxWaitTime = (pollingOptions.maxWaitTime || 5) * 60 * 1000; // Convert to milliseconds
const pollInterval = (pollingOptions.pollInterval || 5) * 1000; // Convert to milliseconds
const maxRetries = pollingOptions.maxRetries || 20; // Default 20 retries
try {
const completedTask = await WaveSpeedClient_1.WaveSpeedClient.waitForTaskCompletion(taskResult.id, apiKey, maxWaitTime, pollInterval, maxRetries);
result = {
...result,
status: completedTask.status,
outputs: completedTask.outputs,
has_nsfw_contents: completedTask.has_nsfw_contents,
timings: completedTask.timings,
error: completedTask.error,
};
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Task completion error: ${error}`, { itemIndex: i });
}
}
// If task failed
if (taskResult.status === 'failed') {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Task failed: ${taskResult.error || 'Unknown error'}`, { itemIndex: i });
}
returnData.push({
json: result,
pairedItem: { item: i },
});
}
catch (error) {
if (this.continueOnFail()) {
let errorMessage = 'Unknown error occurred';
if (error instanceof Error) {
errorMessage = error.message;
}
else if (typeof error === 'string') {
errorMessage = error;
}
returnData.push({
json: { error: errorMessage },
pairedItem: { item: i },
});
continue;
}
throw error;
}
}
return [this.helpers.returnJsonArray(returnData)];
}
}
exports.WaveSpeedTaskSubmitByJson = WaveSpeedTaskSubmitByJson;