@neosapience/n8n-nodes-typecast 1.0.2 → 1.0.4

package/nodes/Typecast/resources/voice/index.ts

@@ -1,95 +1,196 @@
 import type { INodeProperties } from 'n8n-workflow';
 
 const showOnlyForVoice = {
-	resource: ['voice'],
+  resource: ['voice'],
 };
 
 export const voiceDescription: INodeProperties[] = [
-	{
-		displayName: 'Operation',
-		name: 'operation',
-		type: 'options',
-		noDataExpression: true,
-		displayOptions: {
-			show: showOnlyForVoice,
-		},
-		options: [
-			{
-				name: 'Get',
-				value: 'get',
-				description: 'Get details of a specific voice model',
-				action: 'Get a voice',
-			},
-			{
-				name: 'Get Many',
-				value: 'getMany',
-				description: 'Get all available voice models',
-				action: 'Get all voices',
-			},
-		],
-		default: 'getMany',
-	},
-	// ----------------------------------
-	//         voice:get
-	// ----------------------------------
-	{
-		displayName: 'Voice ID',
-		name: 'voiceId',
-		type: 'string',
-		required: true,
-		displayOptions: {
-			show: {
-				resource: ['voice'],
-				operation: ['get'],
-			},
-		},
-		default: 'tc_62a8975e695ad26f7fb514d1',
-		description: 'The ID of the voice to retrieve',
-		placeholder: 'tc_62a8975e695ad26f7fb514d1',
-	},
-	{
-		displayName: 'Model',
-		name: 'model',
-		type: 'options',
-		displayOptions: {
-			show: {
-				resource: ['voice'],
-				operation: ['get'],
-			},
-		},
-		options: [
-			{
-				name: 'SSFM-V21',
-				value: 'ssfm-v21',
-			},
-		],
-		default: 'ssfm-v21',
-		description: 'Voice model to use',
-	},
-	// ----------------------------------
-	//         voice:getMany
-	// ----------------------------------
-	{
-		displayName: 'Model',
-		name: 'model',
-		type: 'options',
-		displayOptions: {
-			show: {
-				resource: ['voice'],
-				operation: ['getMany'],
-			},
-		},
-		options: [
-			{
-				name: 'All',
-				value: '',
-			},
-			{
-				name: 'SSFM-V21',
-				value: 'ssfm-v21',
-			},
-		],
-		default: '',
-		description: 'Filter by voice model (optional)',
-	},
+  {
+    displayName: 'Operation',
+    name: 'operation',
+    type: 'options',
+    noDataExpression: true,
+    displayOptions: {
+      show: showOnlyForVoice,
+    },
+    options: [
+      {
+        name: 'Get All Voices',
+        value: 'getMany',
+        description: 'Get all available voice models',
+        action: 'Get all voices',
+      },
+    ],
+    default: 'getMany',
+  },
+  // ----------------------------------
+  //         voice:getMany
+  // ----------------------------------
+  {
+    displayName: 'Filters',
+    name: 'filters',
+    type: 'collection',
+    placeholder: 'Add Filter',
+    default: {},
+    displayOptions: {
+      show: {
+        resource: ['voice'],
+        operation: ['getMany'],
+      },
+    },
+    options: [
+      {
+        displayName: 'Model',
+        name: 'model',
+        type: 'options',
+        options: [
+          {
+            name: 'All',
+            value: '',
+            description: 'List all available voices for all models',
+          },
+          {
+            name: 'SSFM-V30 (Latest)',
+            value: 'ssfm-v30',
+            description: 'Latest model with improved prosody and additional emotion presets',
+          },
+          {
+            name: 'SSFM-V21',
+            value: 'ssfm-v21',
+            description: 'Stable production model with proven reliability',
+          },
+        ],
+        default: '',
+        description: 'Filter voices by TTS model version',
+      },
+      {
+        displayName: 'Gender',
+        name: 'gender',
+        type: 'options',
+        options: [
+          {
+            name: 'Female',
+            value: 'female',
+            description: 'Female voice',
+          },
+          {
+            name: 'Male',
+            value: 'male',
+            description: 'Male voice',
+          },
+        ],
+        default: 'female',
+        description: 'Filter voices by gender',
+      },
+      {
+        displayName: 'Age',
+        name: 'age',
+        type: 'options',
+        options: [
+          {
+            name: 'Child',
+            value: 'child',
+            description: 'Child voice (under 12 years old)',
+          },
+          {
+            name: 'Elder',
+            value: 'elder',
+            description: 'Elder voice (over 60 years old)',
+          },
+          {
+            name: 'Middle Age',
+            value: 'middle_age',
+            description: 'Middle-aged voice (36-60 years old)',
+          },
+          {
+            name: 'Teenager',
+            value: 'teenager',
+            description: 'Teenage voice (13-19 years old)',
+          },
+          {
+            name: 'Young Adult',
+            value: 'young_adult',
+            description: 'Young adult voice (20-35 years old)',
+          },
+        ],
+        default: 'child',
+        description: 'Filter voices by age group',
+      },
+      {
+        displayName: 'Use Cases',
+        name: 'use_cases',
+        type: 'options',
+        options: [
+          {
+            name: 'Ads',
+            value: 'Ads',
+            description: 'Advertising and promotional content',
+          },
+          {
+            name: 'Anime',
+            value: 'Anime',
+            description: 'Animation and character voices',
+          },
+          {
+            name: 'Announcer',
+            value: 'Announcer',
+            description: 'Public announcements and presentations',
+          },
+          {
+            name: 'Audiobook',
+            value: 'Audiobook',
+            description: 'Long-form narration and storytelling',
+          },
+          {
+            name: 'Conversational',
+            value: 'Conversational',
+            description: 'Chatbots and conversational AI',
+          },
+          {
+            name: 'Documentary',
+            value: 'Documentary',
+            description: 'Documentary narration and commentary',
+          },
+          {
+            name: 'E-Learning',
+            value: 'E-learning',
+            description: 'Educational content and tutorials',
+          },
+          {
+            name: 'Game',
+            value: 'Game',
+            description: 'Video game characters and narration',
+          },
+          {
+            name: 'News',
+            value: 'News',
+            description: 'News broadcasting',
+          },
+          {
+            name: 'Podcast',
+            value: 'Podcast',
+            description: 'Broadcasting and podcast production',
+          },
+          {
+            name: 'Rapper',
+            value: 'Rapper',
+            description: 'Rap and music performance',
+          },
+          {
+            name: 'TikTok/Reels',
+            value: 'Tiktok/Reels',
+            description: 'Short-form social media content',
+          },
+          {
+            name: 'Voicemail',
+            value: 'Voicemail',
+            description: 'IVR systems and voice assistants',
+          },
+        ],
+        default: 'Announcer',
+        description: 'Filter voices by use case category',
+      },
+    ],
+    description: 'Filter voices by model, gender, age, or use cases',
+  },
 ];

package/nodes/Typecast/shared/transport.ts

@@ -1,54 +1,82 @@
 import type {
-	IExecuteFunctions,
-	ILoadOptionsFunctions,
-	IHookFunctions,
-	IHttpRequestMethods,
-	IDataObject,
-	IHttpRequestOptions,
+  IExecuteFunctions,
+  ILoadOptionsFunctions,
+  IHookFunctions,
+  IHttpRequestMethods,
+  IDataObject,
+  IHttpRequestOptions,
 } from 'n8n-workflow';
 
 export async function typecastApiRequest(
-	this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions,
-	method: IHttpRequestMethods,
-	endpoint: string,
-	body: IDataObject = {},
-	qs: IDataObject = {},
+  this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions,
+  method: IHttpRequestMethods,
+  endpoint: string,
+  body: IDataObject = {},
+  qs: IDataObject = {},
+  version: string = 'v2',
 ) {
-	const options: IHttpRequestOptions = {
-		method,
-		body,
-		qs,
-		url: `https://api.typecast.ai/v1${endpoint}`,
-		json: true,
-	};
-
-	try {
-		return await this.helpers.httpRequestWithAuthentication.call(this, 'typecastApi', options);
-	} catch (error) {
-		throw new Error(`Typecast API request failed: ${(error as Error).message}`);
-	}
+  const options: IHttpRequestOptions = {
+    method,
+    body,
+    qs,
+    url: `https://api.typecast.ai/${version}${endpoint}`,
+    json: true,
+  };
+
+  try {
+    return await this.helpers.httpRequestWithAuthentication.call(this, 'typecastApi', options);
+  } catch (error) {
+    const errorData = error as {
+      message?: string;
+      httpCode?: number;
+      errorResponse?: { error_code?: string };
+      error_code?: string;
+    };
+    const errorMessage = errorData.message || 'Unknown error';
+    const statusCode = errorData.httpCode;
+    const errorCode = errorData.errorResponse?.error_code || errorData.error_code;
+
+    const statusDetails = statusCode ? `[${statusCode}] ` : '';
+    const errorCodeDetails = errorCode ? `(Error Code: ${errorCode}) ` : '';
+
+    throw new Error(`Typecast API request failed: ${statusDetails}${errorCodeDetails}${errorMessage}`);
+  }
 }
 
 export async function typecastApiRequestBinary(
-	this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions,
-	method: IHttpRequestMethods,
-	endpoint: string,
-	body: IDataObject = {},
-	qs: IDataObject = {},
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+  this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions,
+  method: IHttpRequestMethods,
+  endpoint: string,
+  body: IDataObject = {},
+  qs: IDataObject = {},
+  version: string = 'v1',
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ): Promise<any> {
-	const options: IHttpRequestOptions = {
-		method,
-		body,
-		qs,
-		url: `https://api.typecast.ai/v1${endpoint}`,
-		json: true,
-		encoding: 'arraybuffer',
-	};
-
-	try {
-		return await this.helpers.httpRequestWithAuthentication.call(this, 'typecastApi', options);
-	} catch (error) {
-		throw new Error(`Typecast API binary request failed: ${(error as Error).message}`);
-	}
+  const options: IHttpRequestOptions = {
+    method,
+    body,
+    qs,
+    url: `https://api.typecast.ai/${version}${endpoint}`,
+    json: true,
+    encoding: 'arraybuffer',
+  };
+
+  try {
+    return await this.helpers.httpRequestWithAuthentication.call(this, 'typecastApi', options);
+  } catch (error) {
+    const errorData = error as {
+      message?: string;
+      httpCode?: number;
+      errorResponse?: { error_code?: string };
+      error_code?: string;
+    };
+    const errorMessage = errorData.message || 'Unknown error';
+    const statusCode = errorData.httpCode;
+    const errorCode = errorData.errorResponse?.error_code || errorData.error_code;
+
+    const statusDetails = statusCode ? `[${statusCode}] ` : '';
+    const errorCodeDetails = errorCode ? `(Error Code: ${errorCode}) ` : '';
+
+    throw new Error(`Typecast API binary request failed: ${statusDetails}${errorCodeDetails}${errorMessage}`);
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neosapience/n8n-nodes-typecast",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "n8n node for Typecast TTS API integration",
   "keywords": [
     "n8n-community-node-package",