Add TeamoRouter nodes for n8n: chat model sub-node, chat/image/model action node, credentials, tests

2026-10-22 14:02:23 +03:00 · 2026-10-22 14:02:23 +03:00 · 775ba0a6d9
commit 775ba0a6d9
18 changed files with 3294 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,5 @@
 node_modules/
 dist/
 *.tgz
 npm-debug.log*
 .DS_Store
--- a/21
+++ b/21
@ -0,0 +1,21 @@
 MIT License
 Copyright (c) 2026 ITO Service
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
--- a/README.md
+++ b/README.md
@ -0,0 +1,173 @@
 # n8n-nodes-teamorouter
 Кастомные узлы n8n для шлюза **TeamoRouter** (`https://api.teamorouter.com/v1`) — OpenAI-совместимого роутера к GPT, Claude, Gemini, DeepSeek, GLM, Grok, Kimi и другим моделям.
 Пакет содержит два узла и один тип учётных данных:
 | Узел | Тип | Назначение |
 | --- | --- | --- |
 | **TeamoRouter Chat Model** (`lmChatTeamRouter`) | sub-node, `ai_languageModel` | Подключается к **AI Agent**, **Basic LLM Chain**, **Question and Answer Chain** и любым другим узлам, которые принимают Language Model |
 | **TeamoRouter** (`teamorouter`) | обычный узел | Три операции: `Chat → Message a Model`, `Image → Generate an Image`, `Model → List Models` |
 | **TeamoRouter API** (`teamorouterApi`) | credentials | API-ключ + Base URL |
 ---
 ## 1. Установка
 ### Вариант А. Через интерфейс n8n (рекомендуется)
 Community nodes в n8n ставятся из npm, поэтому пакет должен быть опубликован:
 1. Выгрузите папку в свой git-репозиторий.
 2. Опубликуйте в npm:
   ```bash
   npm install
   npm run build
   npm publish --access public
   ```
 3. В n8n: **Settings → Community nodes → Install a community node**, введите `n8n-nodes-teamorouter`, подтвердите предупреждение.
 4. Перезапускать n8n не нужно — узлы появляются сразу.
 Нужна роль Owner/Admin и включённые community nodes. Community nodes ставятся на весь инстанс.
 ### Вариант Б. Копированием папки (если есть доступ к серверу n8n)
 1. `npm install && npm run build` — на выходе нужна папка `dist/`.
 2. Положите **всю папку пакета** (в ней обязателен `package.json`) в каталог пользовательских расширений, например:
   * в Docker: `/home/node/.n8n/custom/n8n-nodes-teamorouter/`
   * через переменную окружения: `N8N_CUSTOM_EXTENSIONS=/path/to/custom-nodes`, а внутри уже папка пакета
 3. Внутри папки пакета один раз выполните `npm install --omit=dev`, чтобы `n8n-workflow` (peer-зависимость) был доступен из вашей папки.
 4. Перезапустите n8n.
 ### Вариант В. Локальная разработка
 ```bash
 npm install
 npm run build:watch     # tsc в режиме наблюдения
 export N8N_CUSTOM_EXTENSIONS="$(pwd)"
 npx n8n start
 ```
 ---
 ## 2. Учётные данные
 **Settings → Credentials → New → TeamoRouter API**
 | Поле | Значение |
 | --- | --- |
 | **API Key** | ключ из панели TeamoRouter, начинается с `sk-teamo-` |
 | **Base URL** | `https://api.teamorouter.com/v1` (по умолчанию; меняйте только для зеркала `.cn` или своего роутера) |
 Кнопка проверки делает `GET /v1/models` с заголовком `Authorization: Bearer <ключ>`.
 ---
 ## 3. TeamoRouter Chat Model (для AI Agent)
 1. Добавьте **AI Agent** (или **Basic LLM Chain**).
 2. В слот **Chat Model** добавьте **TeamoRouter Chat Model**.
 3. Выберите модель из списка — он читается вживую из `GET /v1/models`. В подписи к модели видны провайдер и цена за 1M токенов (если роутер их отдаёт).
 ### Опции
 | Опция | Что делает |
 | --- | --- |
 | **Sampling Temperature** | случайность ответа, 0…2 |
 | **Maximum Number of Tokens** | лимит генерации; `-1` = решает модель |
 | **Top P** | nucleus sampling; меняйте либо temperature, либо topP |
 | **Force JSON Response** | просит модель отвечать объектом JSON (в промпте должно быть слово JSON) |
 | **Service Tier → Fast** | режим Fast у TeamoRouter: до 2,5× быстрее, тарифицируется ×2 |
 | **Extra Body** | произвольные JSON-поля в тело запроса, например `{"top_k": 40}`; перекрывает всё выше |
 | **Timeout** | по умолчанию 600000 мс (роутер допускает ответы до 600 с) |
 | **Max Retries** | повторы при ошибке, по умолчанию 2 |
 ### Модель, которой нет в списке
 Поле **Model** можно переключить в режим выражения (переключатель `Expression` в правом верхнем углу поля) и вписать ID руками:
 ```
 {{ 'some-new-model-id' }}
 ```
 Это пригодится, если модель появилась у роутера, а список в UI ещё не перечитан.
 ---
 ## 4. Узел TeamoRouter (обычные операции)
 ### Chat → Message a Model
 Отправляет `POST /v1/chat/completions` и возвращает JSON-ответ как есть.
 | Поле | Описание |
 | --- | --- |
 | **Model** | список читается из `GET /v1/models` (только текстовые модели; картинные скрыты) |
 | **Prompt** | сообщение пользователя |
 | **Options → System Prompt** | системная инструкция |
 | **Options →** остальное | temperature, topP, max tokens, JSON-ответ, Service Tier Fast, Extra Body, Timeout |
 Текст ответа доступен как `{{ $json.choices[0].message.content }}`, расход токенов — `{{ $json.usage }}`.
 ### Image → Generate an Image
 Отправляет `POST /v1/images/generations` и кладёт результат **в бинарное поле** (по умолчанию `data`, PNG).
 | Поле | Описание |
 | --- | --- |
 | **Model** | по умолчанию `gpt-image-2`, список — только картинные модели; можно вписать ID выражением |
 | **Prompt** | описание картинки |
 | **Put Output File in Field** | имя бинарного свойства |
 Дальше файл уходит в **Write Binary File**, в Telegram, в S3 и т. д. Долгие генерации узел ждёт до 5 минут.
 ### Model → List Models
 Возвращает модели роутера: по одному элементу на модель (`id`, `object`, `owned_by`, `pricing` и др.). Удобно, чтобы построить собственный справочник или посчитать цены.
 ---
 ## 5. Известные особенности и ограничения
 * **Ответы идут на `/v1/chat/completions`.** Исключение — модель из семейства `gpt-5.6*` и всё, что содержит `codex`: LangChain внутри n8n сам переключает такие ID на `/v1/responses` (это поведение зашито в `@langchain/openai` и не отключается настройками). TeamoRouter поддерживает `/v1/responses`, но **только для GPT-моделей**, поэтому схема рабочая. Для Claude/Gemini запросы идут обычным Chat Completions.
 * **Claude через OpenAI-формат не отдаёт prompt caching.** Это ограничение формата роутера, а не узла: кэширование промпта доступно только через нативный протокол Anthropic (в README TeamoRouter это указано отдельно).
 * **`max_tokens`, а не `max_completion_tokens`.** Узел отправляет именно `max_tokens` — как в примере из документации TeamoRouter. Если конкретная модель требует `max_completion_tokens`, добавьте его через **Extra Body**.
 * **Формат ответа JSON** передаётся через `response_format` — это параметр Chat Completions. Для моделей, которые уходят на `/v1/responses`, он может игнорироваться.
 * **Список картинных моделей** определяется по имени: `*-image`, `gpt-image*`, `nano-banana*`, `dall-e*`, `imagen*`. Если роутер назовёт модель иначе, она попадёт в список чата (или наоборот); при этом поле всегда можно заполнить вручную выражением.
 * **Цены в списке моделей** — подсказка. Роутер может отдавать цену за токен или уже за 1M токенов; узел считает значения меньше `0.005` как «за токен». Это только отображение, на запросы не влияет.
 * У полей **Model** список загружается при открытии, кэша нет: если модель только что появилась, нажмите перезагрузить список или используйте выражение.
 ---
 ## 6. Разработка и проверки
 ```bash
 npm install
 npm run build          # tsc + копирование иконок в dist/
 npm test               # проверка структуры пакета + тесты узлов на мок-сервере
 npm run typecheck
 npm run mock           # мок TeamoRouter на http://127.0.0.1:4123/v1 (ключ test-key)
 ```
 `npm test` запускает два набора:
 1. `test/validate-nodes.mjs` — имитирует загрузку пакета n8n: проверяет описание узлов, наличие иконок, реализацию `loadOptionsMethod`, ссылки на credential, тип соединения `ai_languageModel` у саб-узла.
 2. `test/run-node-tests.mjs` — поднимает мок роутера (`test/mock-server.mjs`, без зависимостей) и прогоняет скомпилированные узлы с настоящим HTTP и настоящим `@langchain/openai`: список моделей и фильтрация картинных, `supplyData` + реальный вызов модели, проброс опций (`service_tier`, `extra_body`, лимиты), обе операции у обычного узла, генерация изображения в бинарном виде, разбор ошибок 401/402/404, `Continue On Fail` и таймаут.
 Тесты не требуют ключа TeamoRouter. Модели `fail-401`, `fail-402`, `fail-404`, `fail-500` в моке принудительно отдают ошибку, `slow-model` отвечает через 2,5 с.
 ---
 ## 7. Первый запуск и диагностика
 * Пакет собран и проверен автотестами (см. `npm test`), но **в живом n8n ещё не запускался** — первый запуск делайте на тестовом воркфлоу.
 * При установке через `Settings → Community nodes` интерфейс может показать предупреждение о сообщественном узле — это нормально.
 * Если n8n пишет, что узел не загрузился, проверьте `Help → About` (версия n8n) и логи контейнера: чаще всего причина — недоступная peer-зависимость `n8n-workflow` (Вариант Б, шаг 3).
 ## Лицензия
 MIT
--- a/credentials/TeamorouterApi.credentials.ts
+++ b/credentials/TeamorouterApi.credentials.ts
@ -0,0 +1,51 @@
 import type {
 	IAuthenticateGeneric,
 	ICredentialTestRequest,
 	ICredentialType,
 	INodeProperties,
 } from 'n8n-workflow';
 export class TeamorouterApi implements ICredentialType {
 	name = 'teamorouterApi';
 	displayName = 'TeamoRouter API';
 	documentationUrl = 'https://api.teamorouter.com/docs/api-integration';
 	properties: INodeProperties[] = [
 		{
 			displayName: 'API Key',
 			name: 'apiKey',
 			type: 'string',
 			typeOptions: { password: true },
 			required: true,
 			default: '',
 			description: 'API key from the TeamoRouter dashboard. Starts with sk-teamo-',
 		},
 		{
 			displayName: 'Base URL',
 			name: 'baseUrl',
 			type: 'string',
 			required: true,
 			default: 'https://api.teamorouter.com/v1',
 			description: 'OpenAI-compatible base URL. Change it only for the .cn mirror or a self-hosted router',
 		},
 	];
 	authenticate: IAuthenticateGeneric = {
 		type: 'generic',
 		properties: {
 			headers: {
 				Authorization: '=Bearer {{$credentials.apiKey}}',
 			},
 		},
 	};
 	test: ICredentialTestRequest = {
 		request: {
 			baseURL: '={{ $credentials.baseUrl }}',
 			url: '/models',
 			method: 'GET',
 		},
 	};
 }
--- a/nodes/LmChatTeamRouter/LmChatTeamRouter.node.ts
+++ b/nodes/LmChatTeamRouter/LmChatTeamRouter.node.ts
@ -0,0 +1,200 @@
 import type {
 	INodeType,
 	INodeTypeDescription,
 	ISupplyDataFunctions,
 	SupplyData,
 } from 'n8n-workflow';
 import { NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';
 import { loadChatOpenAi, loadN8nLlmTracing } from '../shared/langchainModules';
 import { modelLoader } from '../shared/loadModels';
 import { errorMessage, normalizeBaseUrl, parseExtraBody } from '../shared/teamorouter';
 interface ChatModelOptions {
 	temperature?: number;
 	maxTokens?: number;
 	topP?: number;
 	forceJsonResponse?: boolean;
 	serviceTier?: 'auto' | 'fast';
 	extraBody?: unknown;
 	timeout?: number;
 	maxRetries?: number;
 }
 export class LmChatTeamRouter implements INodeType {
 	description: INodeTypeDescription = {
 		displayName: 'TeamoRouter Chat Model',
 		name: 'lmChatTeamRouter',
 		icon: 'file:teamorouter.svg',
 		group: ['transform'],
 		version: 1,
 		description:
 			'Chat model served by the TeamoRouter gateway (GPT, Claude, Gemini, DeepSeek, GLM, Grok, Kimi)',
 		defaults: {
 			name: 'TeamoRouter Chat Model',
 		},
 		inputs: [],
 		outputs: [NodeConnectionTypes.AiLanguageModel],
 		outputNames: ['Model'],
 		credentials: [
 			{
 				name: 'teamorouterApi',
 				required: true,
 			},
 		],
 		properties: [
 			{
 				displayName: 'Model',
 				name: 'model',
 				type: 'options',
 				typeOptions: {
 					loadOptionsMethod: 'getChatModels',
 				},
 				default: '',
 				required: true,
 				description:
 					'Model ID to use. The list is read live from GET /v1/models. For an ID that is missing from the list, switch this field to expression mode and enter the ID.',
 			},
 			{
 				displayName: 'Options',
 				name: 'options',
 				placeholder: 'Add Option',
 				type: 'collection',
 				default: {},
 				options: [
 					{
 						displayName: 'Extra Body',
 						name: 'extraBody',
 						type: 'json',
 						default: '',
 						description:
 							'Extra JSON properties to merge into the request body, e.g. {"top_k": 40}. Overrides the fields set by the options above.',
 					},
 					{
 						displayName: 'Force JSON Response',
 						name: 'forceJsonResponse',
 						type: 'boolean',
 						default: false,
 						description:
 							'Whether to request a JSON object from the model. The prompt must mention JSON.',
 					},
 					{
 						displayName: 'Maximum Number of Tokens',
 						name: 'maxTokens',
 						type: 'number',
 						default: -1,
 						description: 'Maximum number of tokens to generate. -1 leaves it to the model.',
 					},
 					{
 						displayName: 'Max Retries',
 						name: 'maxRetries',
 						type: 'number',
 						default: 2,
 						description: 'Maximum number of retries for failed requests',
 					},
 					{
 						displayName: 'Sampling Temperature',
 						name: 'temperature',
 						type: 'number',
 						default: 0.7,
 						typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
 						description:
 							'Controls randomness: lower values make the output more deterministic and repetitive',
 					},
 					{
 						displayName: 'Service Tier',
 						name: 'serviceTier',
 						type: 'options',
 						default: 'auto',
 						options: [
 							{ name: 'Auto', value: 'auto', description: 'Standard processing' },
 							{
 								name: 'Fast',
 								value: 'fast',
 								description: 'TeamoRouter Fast mode: up to 2.5x faster, billed at 2x the standard rate',
 							},
 						],
 						description: 'Processing mode requested from TeamoRouter',
 					},
 					{
 						displayName: 'Timeout',
 						name: 'timeout',
 						type: 'number',
 						default: 600000,
 						description:
 							'Time to wait for an answer in milliseconds. TeamoRouter allows responses up to 600 seconds.',
 					},
 					{
 						displayName: 'Top P',
 						name: 'topP',
 						type: 'number',
 						default: 1,
 						typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 2 },
 						description:
 							'Controls diversity via nucleus sampling. Change this or the temperature, not both.',
 					},
 				],
 			},
 		],
 	};
 	methods = {
 		loadOptions: {
 			getChatModels: modelLoader('chat'),
 		},
 	};
 	async supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData> {
 		const credentials = await this.getCredentials('teamorouterApi');
 		const modelName = this.getNodeParameter('model', itemIndex) as string;
 		if (typeof modelName !== 'string' || modelName === '') {
 			throw new NodeOperationError(
 				this.getNode(),
 				'No model selected. Pick one from the list or switch the field to expression mode and enter the model ID.',
 			);
 		}
 		const options = this.getNodeParameter('options', itemIndex, {}) as ChatModelOptions;
 		const modelKwargs: Record<string, unknown> = {};
 		if (options.forceJsonResponse === true) modelKwargs.response_format = { type: 'json_object' };
 		if (options.serviceTier === 'fast') modelKwargs.service_tier = 'fast';
 		Object.assign(modelKwargs, parseExtraBody(options.extraBody, this.getNode()));
 		const config: Record<string, unknown> = {
 			apiKey: credentials.apiKey,
 			model: modelName,
 			configuration: { baseURL: normalizeBaseUrl(credentials.baseUrl as string) },
 			timeout: typeof options.timeout === 'number' && options.timeout > 0 ? options.timeout : 600000,
 			maxRetries: typeof options.maxRetries === 'number' ? options.maxRetries : 2,
 			// Keep the plain Chat Completions endpoint unless the installed LangChain decides otherwise
 			// (it always uses the Responses API for "gpt-5.6*" and "codex" IDs, which TeamoRouter supports too).
 			useResponsesApi: false,
 		};
 		if (typeof options.temperature === 'number') config.temperature = options.temperature;
 		if (typeof options.topP === 'number') config.topP = options.topP;
 		if (typeof options.maxTokens === 'number' && options.maxTokens > 0) {
 			config.maxTokens = options.maxTokens;
 		}
 		if (Object.keys(modelKwargs).length > 0) config.modelKwargs = modelKwargs;
 		let model: unknown;
 		try {
 			const ChatOpenAi = loadChatOpenAi();
 			model = new ChatOpenAi(config);
 		} catch (error) {
 			throw new NodeOperationError(this.getNode(), errorMessage(error));
 		}
 		const tracing = loadN8nLlmTracing(this);
 		if (tracing !== undefined) {
 			(model as { callbacks?: unknown[] }).callbacks = [tracing];
 		}
 		return { response: model };
 	}
 }
--- a/nodes/LmChatTeamRouter/teamorouter.svg
+++ b/nodes/LmChatTeamRouter/teamorouter.svg
@ -0,0 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="0 0 60 60" fill="none"><rect x="6" y="6" width="48" height="48" rx="12" fill="#4F46E5"/><circle cx="20" cy="20" r="4" fill="#fff"/><circle cx="40" cy="20" r="4" fill="#fff"/><circle cx="30" cy="40" r="4" fill="#fff"/><path d="M20 20h20M20 20l10 20M40 20L30 40" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/></svg>
--- a/nodes/Teamorouter/Teamorouter.node.ts
+++ b/nodes/Teamorouter/Teamorouter.node.ts
@ -0,0 +1,435 @@
 import type {
 	IDataObject,
 	IExecuteFunctions,
 	IHttpRequestOptions,
 	INodeExecutionData,
 	INodeType,
 	INodeTypeDescription,
 } from 'n8n-workflow';
 import { NodeOperationError } from 'n8n-workflow';
 import { modelLoader } from '../shared/loadModels';
 import {
 	errorMessage,
 	hintForError,
 	normalizeBaseUrl,
 	parseExtraBody,
 	type TeamorouterModel,
 } from '../shared/teamorouter';
 interface ChatCompletionResponse extends IDataObject {
 	choices?: Array<{ message?: { content?: string | null } }>;
 }
 interface ImageResponse extends IDataObject {
 	data?: Array<{ b64_json?: string }>;
 }
 interface ChatOptions {
 	systemPrompt?: string;
 	temperature?: number;
 	maxTokens?: number;
 	topP?: number;
 	forceJsonResponse?: boolean;
 	serviceTier?: 'auto' | 'fast';
 	extraBody?: unknown;
 	timeout?: number;
 }
 /** Adds TeamoRouter specific hints to failed requests and keeps the original error otherwise. */
 async function callApi<T>(context: IExecuteFunctions, requestOptions: IHttpRequestOptions): Promise<T> {
 	try {
 		return (await context.helpers.httpRequestWithAuthentication.call(
 			context,
 			'teamorouterApi',
 			requestOptions,
 		)) as T;
 	} catch (error) {
 		const hint = hintForError(error);
 		if (hint === undefined) throw error;
 		throw new NodeOperationError(context.getNode(), `${hint} ${errorMessage(error)}`);
 	}
 }
 function buildChatBody(
 	context: IExecuteFunctions,
 	model: string,
 	prompt: string,
 	options: ChatOptions,
 ): IDataObject {
 	const messages: IDataObject[] = [];
 	if (typeof options.systemPrompt === 'string' && options.systemPrompt !== '') {
 		messages.push({ role: 'system', content: options.systemPrompt });
 	}
 	messages.push({ role: 'user', content: prompt });
 	const body: IDataObject = { model, messages };
 	if (typeof options.temperature === 'number') body.temperature = options.temperature;
 	if (typeof options.topP === 'number') body.top_p = options.topP;
 	if (typeof options.maxTokens === 'number' && options.maxTokens > 0) body.max_tokens = options.maxTokens;
 	if (options.forceJsonResponse === true) body.response_format = { type: 'json_object' };
 	if (options.serviceTier === 'fast') body.service_tier = 'fast';
 	return Object.assign(body, parseExtraBody(options.extraBody, context.getNode()));
 }
 export class Teamorouter implements INodeType {
 	description: INodeTypeDescription = {
 		displayName: 'TeamoRouter',
 		name: 'teamorouter',
 		icon: 'file:teamorouter.svg',
 		group: ['transform'],
 		version: 1,
 		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
 		description:
 			'Call the TeamoRouter gateway: chat completions, model list and image generation (GPT, Claude, Gemini, DeepSeek, GLM, Grok, Kimi)',
 		defaults: {
 			name: 'TeamoRouter',
 		},
 		usableAsTool: true,
 		inputs: ['main'],
 		outputs: ['main'],
 		credentials: [
 			{
 				name: 'teamorouterApi',
 				required: true,
 			},
 		],
 		properties: [
 			{
 				displayName: 'Resource',
 				name: 'resource',
 				type: 'options',
 				noDataExpression: true,
 				options: [
 					{
 						name: 'Chat',
 						value: 'chat',
 						description: 'Send a prompt to a chat model',
 					},
 					{
 						name: 'Image',
 						value: 'image',
 						description: 'Generate an image',
 					},
 					{
 						name: 'Model',
 						value: 'model',
 						description: 'Read the model list from the router',
 					},
 				],
 				default: 'chat',
 			},
 			// ---------------------------------------------------------------- chat
 			{
 				displayName: 'Operation',
 				name: 'operation',
 				type: 'options',
 				noDataExpression: true,
 				displayOptions: { show: { resource: ['chat'] } },
 				options: [
 					{
 						name: 'Message a Model',
 						value: 'message',
 						description: 'Send a prompt and get the completion',
 						action: 'Send a chat completion request',
 					},
 				],
 				default: 'message',
 			},
 			{
 				displayName: 'Model',
 				name: 'model',
 				type: 'options',
 				typeOptions: {
 					loadOptionsMethod: 'getChatModels',
 				},
 				default: '',
 				required: true,
 				displayOptions: { show: { resource: ['chat'] } },
 				description:
 					'Model ID to use. The list is read live from GET /v1/models. For an ID that is missing from the list, switch this field to expression mode and enter the ID.',
 			},
 			{
 				displayName: 'Prompt',
 				name: 'prompt',
 				type: 'string',
 				default: '',
 				required: true,
 				typeOptions: { rows: 4 },
 				displayOptions: { show: { resource: ['chat'] } },
 				description: 'Message to send to the model',
 			},
 			{
 				displayName: 'Options',
 				name: 'options',
 				placeholder: 'Add Option',
 				type: 'collection',
 				default: {},
 				displayOptions: { show: { resource: ['chat'] } },
 				options: [
 					{
 						displayName: 'Extra Body',
 						name: 'extraBody',
 						type: 'json',
 						default: '',
 						description:
 							'Extra JSON properties to merge into the request body, e.g. {"top_k": 40}. Overrides the fields set by the options above.',
 					},
 					{
 						displayName: 'Force JSON Response',
 						name: 'forceJsonResponse',
 						type: 'boolean',
 						default: false,
 						description:
 							'Whether to request a JSON object from the model. The prompt must mention JSON.',
 					},
 					{
 						displayName: 'Maximum Number of Tokens',
 						name: 'maxTokens',
 						type: 'number',
 						default: -1,
 						description: 'Maximum number of tokens to generate. -1 leaves it to the model.',
 					},
 					{
 						displayName: 'Sampling Temperature',
 						name: 'temperature',
 						type: 'number',
 						default: 0.7,
 						typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
 						description:
 							'Controls randomness: lower values make the output more deterministic and repetitive',
 					},
 					{
 						displayName: 'Service Tier',
 						name: 'serviceTier',
 						type: 'options',
 						default: 'auto',
 						options: [
 							{ name: 'Auto', value: 'auto', description: 'Standard processing' },
 							{
 								name: 'Fast',
 								value: 'fast',
 								description: 'TeamoRouter Fast mode: up to 2.5x faster, billed at 2x the standard rate',
 							},
 						],
 						description: 'Processing mode requested from TeamoRouter',
 					},
 					{
 						displayName: 'System Prompt',
 						name: 'systemPrompt',
 						type: 'string',
 						default: '',
 						typeOptions: { rows: 3 },
 						description: 'Optional instruction that sets the behaviour of the assistant',
 					},
 					{
 						displayName: 'Timeout',
 						name: 'timeout',
 						type: 'number',
 						default: 600000,
 						description:
 							'Time to wait for an answer in milliseconds. TeamoRouter allows responses up to 600 seconds.',
 					},
 					{
 						displayName: 'Top P',
 						name: 'topP',
 						type: 'number',
 						default: 1,
 						typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 2 },
 						description:
 							'Controls diversity via nucleus sampling. Change this or the temperature, not both.',
 					},
 				],
 			},
 			// --------------------------------------------------------------- image
 			{
 				displayName: 'Operation',
 				name: 'operation',
 				type: 'options',
 				noDataExpression: true,
 				displayOptions: { show: { resource: ['image'] } },
 				options: [
 					{
 						name: 'Generate an Image',
 						value: 'generate',
 						description: 'Create an image from a text prompt',
 						action: 'Generate an image',
 					},
 				],
 				default: 'generate',
 			},
 			{
 				displayName: 'Model',
 				name: 'imageModel',
 				type: 'options',
 				typeOptions: {
 					loadOptionsMethod: 'getImageModels',
 				},
 				default: 'gpt-image-2',
 				required: true,
 				displayOptions: { show: { resource: ['image'] } },
 				description:
 					'Image model ID. The list is read live from GET /v1/models. For an ID that is missing from the list, switch this field to expression mode and enter the ID.',
 			},
 			{
 				displayName: 'Prompt',
 				name: 'imagePrompt',
 				type: 'string',
 				default: '',
 				required: true,
 				typeOptions: { rows: 4 },
 				displayOptions: { show: { resource: ['image'] } },
 				description: 'Text description of the image to generate',
 			},
 			{
 				displayName: 'Put Output File in Field',
 				name: 'binaryPropertyName',
 				type: 'string',
 				default: 'data',
 				required: true,
 				displayOptions: { show: { resource: ['image'] } },
 				description: 'Name of the binary property that holds the generated image',
 			},
 			{
 				displayName:
 					'Image generation can take a while. The request waits up to 5 minutes before it fails.',
 				name: 'imageNotice',
 				type: 'notice',
 				default: '',
 				displayOptions: { show: { resource: ['image'] } },
 			},
 			// --------------------------------------------------------------- model
 			{
 				displayName: 'Operation',
 				name: 'operation',
 				type: 'options',
 				noDataExpression: true,
 				displayOptions: { show: { resource: ['model'] } },
 				options: [
 					{
 						name: 'List Models',
 						value: 'list',
 						description: 'Read the models currently offered by TeamoRouter',
 						action: 'List models',
 					},
 				],
 				default: 'list',
 			},
 		],
 	};
 	methods = {
 		loadOptions: {
 			getChatModels: modelLoader('chat'),
 			getImageModels: modelLoader('image'),
 		},
 	};
 	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
 		const items = this.getInputData();
 		const returnData: INodeExecutionData[] = [];
 		const credentials = await this.getCredentials('teamorouterApi');
 		const baseURL = normalizeBaseUrl(credentials.baseUrl as string);
 		for (let i = 0; i < items.length; i++) {
 			try {
 				const resource = this.getNodeParameter('resource', i) as string;
 				if (resource === 'chat') {
 					const options = this.getNodeParameter('options', i, {}) as ChatOptions;
 					const response = await callApi<ChatCompletionResponse>(this, {
 						method: 'POST',
 						baseURL,
 						url: '/chat/completions',
 						body: buildChatBody(
 							this,
 							this.getNodeParameter('model', i) as string,
 							this.getNodeParameter('prompt', i) as string,
 							options,
 						),
 						json: true,
 						timeout: typeof options.timeout === 'number' && options.timeout > 0 ? options.timeout : 600000,
 					});
 					returnData.push(
 						...this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(response), {
 							itemData: { item: i },
 						}),
 					);
 					continue;
 				}
 				if (resource === 'image') {
 					const imageModel = this.getNodeParameter('imageModel', i) as string;
 					const prompt = this.getNodeParameter('imagePrompt', i) as string;
 					const response = await callApi<ImageResponse>(this, {
 						method: 'POST',
 						baseURL,
 						url: '/images/generations',
 						body: { model: imageModel, prompt },
 						json: true,
 						timeout: 300000,
 					});
 					const base64 = response?.data?.[0]?.b64_json;
 					if (typeof base64 !== 'string' || base64 === '') {
 						throw new NodeOperationError(
 							this.getNode(),
 							'TeamoRouter returned no image data (expected data[0].b64_json)',
 							{ itemIndex: i },
 						);
 					}
 					const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i) as string;
 					const binary = await this.helpers.prepareBinaryData(
 						Buffer.from(base64, 'base64'),
 						`teamo-image-${Date.now()}.png`,
 						'image/png',
 					);
 					returnData.push({
 						json: { model: imageModel, prompt },
 						binary: { [binaryPropertyName]: binary },
 						pairedItem: { item: i },
 					});
 					continue;
 				}
 				const response = await callApi<{ data?: TeamorouterModel[] } | TeamorouterModel[]>(this, {
 					method: 'GET',
 					baseURL,
 					url: '/models',
 					json: true,
 					timeout: 60000,
 				});
 				const models = Array.isArray(response) ? response : response?.data ?? [];
 				returnData.push(
 					...this.helpers.constructExecutionMetaData(
 						this.helpers.returnJsonArray(models as unknown as IDataObject[]),
 						{ itemData: { item: i } },
 					),
 				);
 			} catch (error) {
 				if (this.continueOnFail()) {
 					returnData.push(
 						...this.helpers.constructExecutionMetaData(
 							this.helpers.returnJsonArray({ error: errorMessage(error) }),
 							{ itemData: { item: i } },
 						),
 					);
 					continue;
 				}
 				throw error;
 			}
 		}
 		return [returnData];
 	}
 }
--- a/nodes/Teamorouter/teamorouter.svg
+++ b/nodes/Teamorouter/teamorouter.svg
@ -0,0 +1 @@
 <svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="0 0 60 60" fill="none"><rect x="6" y="6" width="48" height="48" rx="12" fill="#4F46E5"/><circle cx="20" cy="20" r="4" fill="#fff"/><circle cx="40" cy="20" r="4" fill="#fff"/><circle cx="30" cy="40" r="4" fill="#fff"/><path d="M20 20h20M20 20l10 20M40 20L30 40" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/></svg>
--- a/nodes/shared/langchainModules.ts
+++ b/nodes/shared/langchainModules.ts
@ -0,0 +1,76 @@
 import { dirname, join } from 'node:path';
 /**
 * n8n bundles `@langchain/openai` and `@n8n/ai-utilities` inside its own installation, and those
 * modules are only reachable by a plain `require` when the package was installed as a community
 * node (npm installs it below `~/.n8n/nodes`). When the package is mounted as a custom extension
 * the resolution starts from our own folder, so we additionally look next to n8n itself
 * (the directory of `require.main.filename` is n8n's CLI entry point).
 */
 function candidateModuleDirs(): string[] {
 	const dirs = new Set<string>();
 	const addChain = (start: string | undefined): void => {
 		if (!start) return;
 		let current = start;
 		for (;;) {
 			dirs.add(join(current, 'node_modules'));
 			const parent = dirname(current);
 			if (parent === current) break;
 			current = parent;
 		}
 	};
 	addChain(__dirname);
 	addChain(process.cwd());
 	if (require.main?.filename) addChain(dirname(require.main.filename));
 	return [...dirs];
 }
 export function loadN8nModule<T = unknown>(moduleName: string): T | undefined {
 	try {
 		return require(moduleName) as T;
 	} catch {
 		// Not reachable from our own folder - fall through to the n8n installation.
 	}
 	for (const dir of candidateModuleDirs()) {
 		try {
 			return require(join(dir, moduleName)) as T;
 		} catch {
 			// Keep looking.
 		}
 	}
 	return undefined;
 }
 export type ChatOpenAiConstructor = new (config: Record<string, unknown>) => unknown;
 export function loadChatOpenAi(): ChatOpenAiConstructor {
 	const loaded = loadN8nModule<{ ChatOpenAI?: ChatOpenAiConstructor }>('@langchain/openai');
 	if (typeof loaded?.ChatOpenAI !== 'function') {
 		throw new Error(
 			'Could not load "@langchain/openai" from the n8n installation. The Chat Model node needs the LangChain packages that ship with n8n (@n8n/n8n-nodes-langchain must be installed).',
 		);
 	}
 	return loaded.ChatOpenAI;
 }
 /**
 * Token/cost accounting in the execution log is provided by n8n's own tracer. It is an internal
 * helper, so we use it when it is reachable and stay silent when it is not - the model itself
 * works either way.
 */
 export function loadN8nLlmTracing(context: unknown): unknown | undefined {
 	for (const moduleName of ['@n8n/ai-utilities', 'n8n-core']) {
 		const loaded = loadN8nModule<{ N8nLlmTracing?: new (context: unknown) => unknown }>(moduleName);
 		if (typeof loaded?.N8nLlmTracing === 'function') {
 			try {
 				return new loaded.N8nLlmTracing(context);
 			} catch {
 				return undefined;
 			}
 		}
 	}
 	return undefined;
 }
--- a/nodes/shared/loadModels.ts
+++ b/nodes/shared/loadModels.ts
@ -0,0 +1,19 @@
 import type { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
 import { normalizeBaseUrl, toModelOptions, type TeamorouterModel } from './teamorouter';
 /** Dropdown content for the model field, read live from `GET /v1/models`. */
 export function modelLoader(kind: 'chat' | 'image' | 'all') {
 	return async function (this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
 		const credentials = await this.getCredentials('teamorouterApi');
 		const response = (await this.helpers.httpRequestWithAuthentication.call(this, 'teamorouterApi', {
 			method: 'GET',
 			baseURL: normalizeBaseUrl(credentials.baseUrl as string),
 			url: '/models',
 			json: true,
 		})) as { data?: TeamorouterModel[] } | TeamorouterModel[];
 		const models = Array.isArray(response) ? response : response?.data ?? [];
 		return toModelOptions(models, kind);
 	};
 }
--- a/nodes/shared/teamorouter.ts
+++ b/nodes/shared/teamorouter.ts
@ -0,0 +1,104 @@
 import type { INode, INodePropertyOptions } from 'n8n-workflow';
 import { NodeOperationError } from 'n8n-workflow';
 export const DEFAULT_BASE_URL = 'https://api.teamorouter.com/v1';
 export interface TeamorouterModel {
 	id: string;
 	owned_by?: string;
 	pricing?: Record<string, unknown>;
 }
 export function normalizeBaseUrl(baseUrl?: string): string {
 	const value = (baseUrl ?? '').trim();
 	return (value === '' ? DEFAULT_BASE_URL : value).replace(/\/+$/, '');
 }
 const IMAGE_MODEL_PATTERNS = [/(^|-)image(-|$)/i, /gpt-image/i, /nano-banana/i, /dall-e/i, /imagen/i];
 export function isImageModel(modelId: string): boolean {
 	return IMAGE_MODEL_PATTERNS.some((pattern) => pattern.test(modelId));
 }
 function pricePerMillion(value: unknown): string | undefined {
 	if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) return undefined;
 	// The router may report prices per token (0.00000053) or already per 1M tokens (0.29).
 	// Below 0.005 only the per-token reading makes sense.
 	const perMillion = value < 0.005 ? value * 1_000_000 : value;
 	return `$${Number(perMillion.toFixed(perMillion < 1 ? 4 : 2))}`;
 }
 function modelDescription(model: TeamorouterModel): string | undefined {
 	const parts: string[] = [];
 	if (typeof model.owned_by === 'string' && model.owned_by !== '') parts.push(model.owned_by);
 	const pricing = model.pricing;
 	if (pricing !== null && typeof pricing === 'object') {
 		const input = pricePerMillion(pricing.prompt ?? pricing.input);
 		const output = pricePerMillion(pricing.completion ?? pricing.output);
 		if (input || output) parts.push(`${input ?? '?'} in / ${output ?? '?'} out per 1M tokens`);
 	}
 	return parts.length > 0 ? parts.join(' · ') : undefined;
 }
 export function toModelOptions(
 	models: TeamorouterModel[],
 	kind: 'chat' | 'image' | 'all',
 ): INodePropertyOptions[] {
 	const usable = models.filter((model) => typeof model?.id === 'string' && model.id !== '');
 	const matching = usable.filter((model) => isImageModel(model.id) === (kind === 'image'));
 	// Never hand back an empty dropdown because of our own naming heuristic.
 	const selected = kind === 'all' || matching.length === 0 ? usable : matching;
 	return selected
 		.map((model) => ({
 			name: model.id,
 			value: model.id,
 			description: modelDescription(model),
 		}))
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
 function errorStatus(error: unknown): number | undefined {
 	if (error === null || typeof error !== 'object') return undefined;
 	const candidate = error as { httpCode?: unknown; statusCode?: unknown; response?: { status?: unknown } };
 	const status = candidate.httpCode ?? candidate.statusCode ?? candidate.response?.status;
 	return typeof status === 'number' ? status : undefined;
 }
 export function errorMessage(error: unknown): string {
 	if (error instanceof Error) return error.message;
 	return typeof error === 'string' ? error : 'Unknown error';
 }
 /** Turns the router's status codes into something a workflow author can act on. */
 export function hintForError(error: unknown): string | undefined {
 	switch (errorStatus(error)) {
 		case 401:
 			return 'TeamoRouter rejected the API key (401). Check the key and that the Base URL ends with /v1.';
 		case 402:
 			return 'TeamoRouter reports insufficient balance (402). Top up the account or pick a model with the "-free" suffix.';
 		case 404:
 			return 'Endpoint or model not found (404). Verify the model ID with the List Models operation and that the Base URL ends with /v1.';
 		case 429:
 			return 'TeamoRouter rate limit reached (429). Lower the request rate or retry later.';
 		default:
 			return undefined;
 	}
 }
 export function parseExtraBody(extraBody: unknown, node: INode): Record<string, unknown> {
 	if (extraBody === undefined || extraBody === null || extraBody === '') return {};
 	if (typeof extraBody === 'object' && !Array.isArray(extraBody)) return extraBody as Record<string, unknown>;
 	try {
 		const parsed = JSON.parse(String(extraBody)) as unknown;
 		if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
 			throw new Error('expected a JSON object');
 		}
 		return parsed as Record<string, unknown>;
 	} catch (error) {
 		throw new NodeOperationError(node, `Extra Body must be a JSON object: ${errorMessage(error)}`);
 	}
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -0,0 +1,52 @@
 {
 	"name": "n8n-nodes-teamorouter",
 	"version": "0.1.0",
 	"description": "n8n nodes for TeamoRouter — OpenAI-compatible LLM router (chat model for AI Agent, chat completions, model list, image generation)",
 	"keywords": [
 		"n8n-community-node-package",
 		"n8n",
 		"teamorouter",
 		"llm",
 		"openai-compatible"
 	],
 	"license": "MIT",
 	"author": {
 		"name": "ITO Service",
 		"url": "https://itoservice.ru"
 	},
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/REPLACE-ME/n8n-nodes-teamorouter.git"
 	},
 	"scripts": {
 		"build": "tsc && node scripts/copy-assets.mjs",
 		"build:watch": "tsc --watch",
 		"typecheck": "tsc --noEmit",
 		"test": "node test/validate-nodes.mjs && node test/run-node-tests.mjs",
 		"mock": "node test/mock-server.mjs",
 		"prepublishOnly": "npm run build"
 	},
 	"files": [
 		"dist"
 	],
 	"n8n": {
 		"n8nNodesApiVersion": 1,
 		"credentials": [
 			"dist/credentials/TeamorouterApi.credentials.js"
 		],
 		"nodes": [
 			"dist/nodes/LmChatTeamRouter/LmChatTeamRouter.node.js",
 			"dist/nodes/Teamorouter/Teamorouter.node.js"
 		]
 	},
 	"peerDependencies": {
 		"n8n-workflow": "*"
 	},
 	"devDependencies": {
 		"@langchain/core": "^1.2.0",
 		"@langchain/openai": "^1.6.0",
 		"@types/node": "^22.10.0",
 		"n8n-workflow": "*",
 		"typescript": "^5.9.0"
 	}
 }
--- a/scripts/copy-assets.mjs
+++ b/scripts/copy-assets.mjs
@ -0,0 +1,19 @@
 // tsc does not copy static assets: icons next to compiled nodes are required by `icon: 'file:...'`.
 import { cp, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const assets = [
 	['nodes/LmChatTeamRouter/teamorouter.svg', 'dist/nodes/LmChatTeamRouter/teamorouter.svg'],
 	['nodes/Teamorouter/teamorouter.svg', 'dist/nodes/Teamorouter/teamorouter.svg'],
 ];
 for (const [from, to] of assets) {
 	const target = join(root, to);
 	await mkdir(dirname(target), { recursive: true });
 	await cp(join(root, from), target);
 }
 console.log(`Copied ${assets.length} asset(s) to dist/`);
--- a/test/mock-server.mjs
+++ b/test/mock-server.mjs
@ -0,0 +1,139 @@
 // OpenAI-compatible stand-in for api.teamorouter.com — used by the node tests, no dependencies.
 import { createServer } from 'node:http';
 // 1x1 transparent PNG.
 export const TINY_PNG_BASE64 =
 	'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFAAH/q842iQAAAABJRU5ErkJggg==';
 export const MODELS = [
 	{ id: 'gpt-5.6-sol', object: 'model', owned_by: 'openai', pricing: { prompt: 0.00000053, completion: 0.00000318 } },
 	{ id: 'claude-sonnet-5', object: 'model', owned_by: 'anthropic', pricing: { prompt: 0.0000005, completion: 0.00000252 } },
 	{ id: 'deepseek-flash-free', object: 'model', owned_by: 'deepseek' },
 	{ id: 'gemini-3.1-pro-preview', object: 'model', owned_by: 'google', pricing: { input: 0.29, output: 1.73 } },
 	{ id: 'gpt-image-2', object: 'model', owned_by: 'openai' },
 	{ id: 'nano-banana-2.1', object: 'model', owned_by: 'google' },
 ];
 const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /**
 * Models whose IDs start with "fail-" make the mock answer with the matching HTTP status,
 * "slow-model" delays the answer, everything else echoes the user message back.
 */
 export function createMockServer({ apiKey = 'test-key' } = {}) {
 	const requests = [];
 	const handle = async (request, response) => {
 		const chunks = [];
 		for await (const chunk of request) chunks.push(chunk);
 		const rawBody = Buffer.concat(chunks).toString('utf8');
 		let body;
 		try {
 			body = rawBody === '' ? undefined : JSON.parse(rawBody);
 		} catch {
 			body = undefined;
 		}
 		requests.push({ method: request.method, url: request.url, headers: request.headers, body });
 		const json = (status, payload) => {
 			response.writeHead(status, { 'content-type': 'application/json' });
 			response.end(JSON.stringify(payload));
 		};
 		if (!request.url.startsWith('/v1/')) {
 			return json(404, { error: { message: `unknown path ${request.url}` } });
 		}
 		if (request.headers.authorization !== `Bearer ${apiKey}`) {
 			return json(401, { error: { message: 'invalid api key' } });
 		}
 		if (request.method === 'GET' && request.url === '/v1/models') {
 			return json(200, { object: 'list', data: MODELS });
 		}
 		if (request.method === 'POST' && request.url === '/v1/chat/completions') {
 			const model = body?.model ?? '';
 			if (model.startsWith('fail-')) {
 				const status = Number(model.replace('fail-', ''));
 				return json(status, { error: { message: `forced failure ${status}` } });
 			}
 			if (model === 'slow-model') await delay(2500);
 			const userMessage = [...(body?.messages ?? [])].reverse().find((message) => message.role === 'user');
 			const content = `echo: ${userMessage?.content ?? ''}`;
 			if (body?.stream === true) {
 				response.writeHead(200, { 'content-type': 'text/event-stream' });
 				response.write(
 					`data: ${JSON.stringify({ object: 'chat.completion.chunk', choices: [{ index: 0, delta: { content } }] })}\n\n`,
 				);
 				response.write('data: [DONE]\n\n');
 				return response.end();
 			}
 			return json(200, {
 				object: 'chat.completion',
 				model,
 				choices: [{ index: 0, message: { role: 'assistant', content }, finish_reason: 'stop' }],
 				usage: { prompt_tokens: 11, completion_tokens: 4, total_tokens: 15 },
 			});
 		}
 		// LangChain's ChatOpenAI serves "gpt-5.6*" and "codex" model IDs through the Responses API.
 		if (request.method === 'POST' && request.url === '/v1/responses') {
 			const userMessage = (body?.input ?? []).find?.((message) => message.role === 'user');
 			const content = `echo: ${typeof body?.input === 'string' ? body.input : userMessage?.content ?? ''}`;
 			return json(200, {
 				id: 'resp_mock',
 				object: 'response',
 				created_at: 1,
 				status: 'completed',
 				model: body?.model,
 				output: [
 					{
 						type: 'message',
 						id: 'msg_mock',
 						role: 'assistant',
 						status: 'completed',
 						content: [{ type: 'output_text', text: content, annotations: [] }],
 					},
 				],
 				usage: { input_tokens: 11, output_tokens: 4, total_tokens: 15 },
 			});
 		}
 		if (request.method === 'POST' && request.url === '/v1/images/generations') {
 			if (String(body?.prompt ?? '').includes('noimage')) {
 				return json(400, { error: { message: 'prompt rejected' } });
 			}
 			return json(200, { created: 1, data: [{ b64_json: TINY_PNG_BASE64 }] });
 		}
 		return json(404, { error: { message: `unknown route ${request.method} ${request.url}` } });
 	};
 	const server = createServer((request, response) => {
 		handle(request, response).catch((error) => {
 			response.writeHead(500, { 'content-type': 'application/json' });
 			response.end(JSON.stringify({ error: { message: String(error) } }));
 		});
 	});
 	return {
 		requests,
 		/** Starts on `port` (0 = random) and returns the base URL, e.g. http://127.0.0.1:4123 */
 		async listen(port = 0) {
 			await new Promise((resolve) => server.listen(port, '127.0.0.1', resolve));
 			return `http://127.0.0.1:${server.address().port}`;
 		},
 		async close() {
 			await new Promise((resolve) => server.close(resolve));
 		},
 	};
 }
 if (process.argv[1]?.endsWith('mock-server.mjs') === true) {
 	const mock = createMockServer({ apiKey: process.env.MOCK_API_KEY ?? 'test-key' });
 	const baseUrl = await mock.listen(Number(process.env.PORT ?? 4123));
 	console.log(`mock TeamoRouter listening on ${baseUrl}/v1 (api key: ${process.env.MOCK_API_KEY ?? 'test-key'})`);
 }
--- a/test/run-node-tests.mjs
+++ b/test/run-node-tests.mjs
@ -0,0 +1,348 @@
 // Exercises the compiled nodes against the mock router: real HTTP, real LangChain model.
 import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createMockServer, TINY_PNG_BASE64 } from './mock-server.mjs';
 const require = createRequire(import.meta.url);
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const { LmChatTeamRouter } = require(join(root, 'dist/nodes/LmChatTeamRouter/LmChatTeamRouter.node.js'));
 const { Teamorouter } = require(join(root, 'dist/nodes/Teamorouter/Teamorouter.node.js'));
 const { TeamorouterApi } = require(join(root, 'dist/credentials/TeamorouterApi.credentials.js'));
 const apiKey = 'test-key';
 const mock = createMockServer({ apiKey });
 const baseUrl = await mock.listen();
 /** Mirrors n8n's httpRequestWithAuthentication closely enough for the code paths under test. */
 async function httpRequest(_credentialName, options) {
 	const url = `${options.baseURL ?? baseUrl}${options.url}`;
 	const timeout = typeof options.timeout === 'number' && options.timeout > 0 ? options.timeout : undefined;
 	let response;
 	try {
 		response = await fetch(url, {
 			method: options.method ?? 'GET',
 			headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
 			body: options.body === undefined ? undefined : JSON.stringify(options.body),
 			signal: timeout === undefined ? undefined : AbortSignal.timeout(timeout),
 		});
 	} catch (error) {
 		const wrapped = new Error(error?.cause?.message ?? error.message);
 		wrapped.httpCode = 504;
 		throw wrapped;
 	}
 	const text = await response.text();
 	let parsed = text;
 	try {
 		parsed = JSON.parse(text);
 	} catch {
 		// keep the raw text
 	}
 	if (!response.ok) {
 		const error = new Error(`Request failed with status code ${response.status}`);
 		error.httpCode = response.status;
 		error.response = { status: response.status, data: parsed };
 		throw error;
 	}
 	return parsed;
 }
 function makeContext(parameters, { continueOnFail = false } = {}) {
 	return {
 		getCredentials: async () => ({ apiKey, baseUrl: `${baseUrl}/v1` }),
 		getNodeParameter: (name, _itemIndex, fallback) =>
 			parameters[name] === undefined ? fallback : parameters[name],
 		getNode: () => ({
 			name: 'TeamoRouter',
 			type: 'n8n-nodes-teamorouter',
 			typeVersion: 1,
 			position: [0, 0],
 			parameters,
 		}),
 		continueOnFail: () => continueOnFail,
 		getInputData: () => [{ json: {} }],
 		logger: { debug() {}, info() {}, warn() {}, error() {} },
 		helpers: {
 			httpRequestWithAuthentication: httpRequest,
 			prepareBinaryData: async (data, fileName, mimeType) => {
 				const buffer = Buffer.from(data);
 				return {
 					data: buffer.toString('base64'),
 					fileName,
 					mimeType,
 					fileExtension: 'png',
 					fileSize: buffer.length,
 				};
 			},
 			returnJsonArray: (data) => (Array.isArray(data) ? data : [data]).map((json) => ({ json })),
 			constructExecutionMetaData: (items) => items,
 		},
 	};
 }
 const lastRequest = () => mock.requests[mock.requests.length - 1];
 const chatModel = new LmChatTeamRouter();
 const actionNode = new Teamorouter();
 let failures = 0;
 async function test(name, fn) {
 	try {
 		await fn();
 		console.log(`ok   ${name}`);
 	} catch (error) {
 		failures += 1;
 		console.log(`FAIL ${name}\n     ${error.message}`);
 	}
 }
 await test('credential points at GET /v1/models and the endpoint enforces the key', async () => {
 	const test = new TeamorouterApi().test;
 	assert.equal(test.request.url, '/models');
 	assert.match(test.request.baseURL, /\$credentials\.baseUrl/);
 	const ok = await fetch(`${baseUrl}/v1/models`, { headers: { authorization: `Bearer ${apiKey}` } });
 	assert.equal(ok.status, 200);
 	const denied = await fetch(`${baseUrl}/v1/models`, { headers: { authorization: 'Bearer wrong' } });
 	assert.equal(denied.status, 401);
 });
 await test('chat model dropdown lists chat models with prices and hides image models', async () => {
 	const options = await chatModel.methods.loadOptions.getChatModels.call(makeContext({}));
 	const ids = options.map((option) => option.value);
 	assert.ok(ids.includes('gpt-5.6-sol'), 'gpt-5.6-sol missing');
 	assert.ok(ids.includes('gemini-3.1-pro-preview'), 'gemini missing');
 	assert.ok(!ids.includes('gpt-image-2'), 'image model leaked into the chat list');
 	assert.ok(!ids.includes('nano-banana-2.1'), 'image model leaked into the chat list');
 	const sol = options.find((option) => option.value === 'gpt-5.6-sol');
 	assert.match(sol.description, /openai/);
 	assert.match(sol.description, /\$0\.53 in \/ \$3\.18 out per 1M tokens/);
 	const gemini = options.find((option) => option.value === 'gemini-3.1-pro-preview');
 	assert.match(gemini.description, /\$0\.29 in \/ \$1\.73 out per 1M tokens/);
 	assert.deepEqual(ids, [...ids].sort(), 'options must be sorted');
 });
 await test('image dropdown lists only image models', async () => {
 	const options = await actionNode.methods.loadOptions.getImageModels.call(makeContext({}));
 	assert.deepEqual(
 		options.map((option) => option.value),
 		['gpt-image-2', 'nano-banana-2.1'],
 	);
 });
 await test('supplyData returns a working LangChain chat model', async () => {
 	const { response: model } = await chatModel.supplyData.call(
 		makeContext({ model: 'claude-sonnet-5', options: {} }),
 		0,
 	);
 	const answer = await model.invoke('ping');
 	assert.equal(answer.content, 'echo: ping');
 	const request = lastRequest();
 	assert.equal(request.url, '/v1/chat/completions');
 	assert.equal(request.headers.authorization, `Bearer ${apiKey}`);
 	assert.equal(request.body.model, 'claude-sonnet-5');
 	assert.equal(request.body.messages.at(-1).content, 'ping');
 	assert.equal(request.body.max_tokens, undefined, 'maxTokens -1 must not be sent');
 });
 await test('supplyData works for GPT models served through the Responses API', async () => {
 	const { response: model } = await chatModel.supplyData.call(
 		makeContext({ model: 'gpt-5.6-sol', options: {} }),
 		0,
 	);
 	const answer = await model.invoke('ping');
 	// The Responses API path returns content blocks instead of a plain string.
 	const text = Array.isArray(answer.content)
 		? answer.content.map((block) => block.text).join('')
 		: answer.content;
 	assert.equal(text, 'echo: ping');
 	const request = lastRequest();
 	// LangChain routes gpt-5.6* to /v1/responses on its own; TeamoRouter serves that endpoint for GPT models.
 	assert.ok(
 		['/v1/chat/completions', '/v1/responses'].includes(request.url),
 		`unexpected endpoint ${request.url}`,
 	);
 	assert.equal(request.body.model, 'gpt-5.6-sol');
 	// The router answers both endpoints, so the model must not care which one was used.
 	assert.match(request.url, /^\/v1\/(chat\/completions|responses)$/);
 });
 await test('options reach the request body (service tier, extra body, limits)', async () => {
 	const { response: model } = await chatModel.supplyData.call(
 		makeContext({
 			model: 'claude-sonnet-5',
 			options: {
 				temperature: 0.2,
 				maxTokens: 128,
 				topP: 0.5,
 				serviceTier: 'fast',
 				forceJsonResponse: true,
 				extraBody: '{"top_k":7}',
 			},
 		}),
 		0,
 	);
 	await model.invoke('json please');
 	const body = lastRequest().body;
 	assert.equal(body.model, 'claude-sonnet-5');
 	assert.equal(body.temperature, 0.2);
 	assert.equal(body.top_p, 0.5);
 	assert.equal(body.max_tokens, 128);
 	assert.equal(body.service_tier, 'fast');
 	assert.deepEqual(body.response_format, { type: 'json_object' });
 	assert.equal(body.top_k, 7);
 });
 await test('chat model rejects a broken Extra Body JSON', async () => {
 	await assert.rejects(
 		async () => {
 			await chatModel.supplyData.call(
 				makeContext({ model: 'gpt-5.6-sol', options: { extraBody: 'not-json' } }),
 				0,
 			);
 		},
 		(error) => {
 			assert.match(error.message, /Extra Body must be a JSON object/);
 			return true;
 		},
 	);
 });
 await test('chat model rejects an empty model selection', async () => {
 	await assert.rejects(
 		async () => {
 			await chatModel.supplyData.call(makeContext({ model: '', options: {} }), 0);
 		},
 		(error) => {
 			assert.match(error.message, /No model selected/);
 			return true;
 		},
 	);
 });
 await test('action node: message a model returns the completion with usage', async () => {
 	const context = makeContext({
 		resource: 'chat',
 		operation: 'message',
 		model: 'claude-sonnet-5',
 		prompt: 'привет',
 		options: { systemPrompt: 'be brief' },
 	});
 	const [items] = await actionNode.execute.call(context);
 	assert.equal(items.length, 1);
 	assert.equal(items[0].json.choices[0].message.content, 'echo: привет');
 	assert.equal(items[0].json.usage.total_tokens, 15);
 	const body = lastRequest().body;
 	assert.deepEqual(body.messages[0], { role: 'system', content: 'be brief' });
 	assert.deepEqual(body.messages[1], { role: 'user', content: 'привет' });
 	assert.equal(lastRequest().url, '/v1/chat/completions');
 });
 await test('action node: list models returns the router payload', async () => {
 	const [items] = await actionNode.execute.call(
 		makeContext({ resource: 'model', operation: 'list' }),
 	);
 	assert.equal(items.length, 6);
 	assert.equal(items[0].json.id, 'gpt-5.6-sol');
 	assert.equal(lastRequest().url, '/v1/models');
 });
 await test('action node: generate image writes a PNG binary', async () => {
 	const [items] = await actionNode.execute.call(
 		makeContext({
 			resource: 'image',
 			operation: 'generate',
 			imageModel: 'gpt-image-2',
 			imagePrompt: 'orange cat',
 			binaryPropertyName: 'data',
 		}),
 	);
 	const binary = items[0].binary.data;
 	assert.equal(binary.mimeType, 'image/png');
 	assert.equal(binary.fileExtension, 'png');
 	assert.equal(binary.data, TINY_PNG_BASE64);
 	assert.equal(Buffer.from(binary.data, 'base64').subarray(0, 8).toString('hex'), '89504e470d0a1a0a');
 	assert.deepEqual(lastRequest().body, { model: 'gpt-image-2', prompt: 'orange cat' });
 });
 await test('action node: router errors become actionable messages', async () => {
 	const cases = [
 		['fail-401', /API key/],
 		['fail-402', /insufficient balance/],
 		['fail-404', /not found/],
 	];
 	for (const [model, expected] of cases) {
 		await assert.rejects(
 			async () => {
 				await actionNode.execute.call(
 					makeContext({ resource: 'chat', operation: 'message', model, prompt: 'hi', options: {} }),
 				);
 			},
 			(error) => {
 				assert.match(error.message, expected);
 				return true;
 			},
 			`${model} did not produce a hint`,
 		);
 	}
 });
 await test('action node: image without b64_json fails clearly', async () => {
 	await assert.rejects(
 		async () => {
 			await actionNode.execute.call(
 				makeContext({
 					resource: 'image',
 					operation: 'generate',
 					imageModel: 'gpt-image-2',
 					imagePrompt: 'noimage please',
 					binaryPropertyName: 'data',
 				}),
 			);
 		},
 		// 400 from the router: no hint, but the request must fail instead of returning empty binary.
 		(error) => {
 			assert.match(error.message, /400/);
 			return true;
 		},
 	);
 });
 await test('action node: continueOnFail returns the error as item data', async () => {
 	const [items] = await actionNode.execute.call(
 		makeContext(
 			{ resource: 'chat', operation: 'message', model: 'fail-500', prompt: 'hi', options: {} },
 			{ continueOnFail: true },
 		),
 	);
 	assert.equal(items.length, 1);
 	assert.match(items[0].json.error, /500/);
 });
 await test('action node: timeout is applied to the request', async () => {
 	await assert.rejects(async () => {
 		await actionNode.execute.call(
 			makeContext({
 				resource: 'chat',
 				operation: 'message',
 				model: 'slow-model',
 				prompt: 'hi',
 				options: { timeout: 300 },
 			}),
 		);
 	});
 });
 await mock.close();
 console.log(`\n${failures === 0 ? 'All node tests passed' : `${failures} test(s) failed`}`);
 process.exitCode = failures === 0 ? 0 : 1;
--- a/test/validate-nodes.mjs
+++ b/test/validate-nodes.mjs
@ -0,0 +1,118 @@
 // Loads the compiled node package the way n8n does and fails loudly on anything n8n would reject.
 import assert from 'node:assert/strict';
 import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const require = createRequire(import.meta.url);
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const packageJson = require(join(root, 'package.json'));
 const loaded = {
 	nodes: packageJson.n8n.nodes.map((file) => {
 		const module = require(join(root, file));
 		const exported = Object.values(module).find((value) => typeof value === 'function');
 		assert.ok(exported, `${file} exports no class`);
 		return { file, instance: new exported() };
 	}),
 	credentials: packageJson.n8n.credentials.map((file) => {
 		const module = require(join(root, file));
 		const exported = Object.values(module).find((value) => typeof value === 'function');
 		assert.ok(exported, `${file} exports no class`);
 		return { file, instance: new exported() };
 	}),
 };
 const credentialNames = new Set(loaded.credentials.map(({ instance }) => instance.name));
 for (const { file, instance } of loaded.credentials) {
 	assert.equal(typeof instance.name, 'string', `${file}: credential has no name`);
 	assert.equal(typeof instance.displayName, 'string', `${file}: credential has no displayName`);
 	assert.ok(Array.isArray(instance.properties) && instance.properties.length > 0, `${file}: no properties`);
 	assert.ok(instance.authenticate, `${file}: no authenticate block`);
 	assert.ok(instance.test?.request, `${file}: no credential test request`);
 	const keyProperty = instance.properties.find((property) => property.name === 'apiKey');
 	assert.ok(keyProperty?.typeOptions?.password, `${file}: apiKey must be a password field`);
 }
 for (const { file, instance } of loaded.nodes) {
 	const description = instance.description;
 	const label = `${file}: `;
 	assert.ok(description, `${label}no description`);
 	assert.equal(typeof description.displayName, 'string', `${label}displayName missing`);
 	assert.match(description.name, /^[a-zA-Z][a-zA-Z0-9]*$/, `${label}name must be camelCase`);
 	assert.ok(description.version !== undefined, `${label}version missing`);
 	assert.ok(description.defaults?.name, `${label}defaults.name missing`);
 	assert.ok(Array.isArray(description.properties), `${label}properties missing`);
 	assert.ok(description.inputs !== undefined, `${label}inputs missing`);
 	assert.ok(description.outputs !== undefined, `${label}outputs missing`);
 	assert.ok(
 		existsSync(join(dirname(join(root, file)), description.icon.replace('file:', ''))),
 		`${label}icon ${description.icon} not found next to the compiled node`,
 	);
 	const names = description.properties.map((property) => property.name);
 	// The same name may be reused for different resources (n8n's own nodes do this with "operation"),
 	// but never for the same visible state.
 	const seen = new Map();
 	for (const property of description.properties) {
 		const show = JSON.stringify(property.displayOptions?.show ?? {});
 		const key = `${property.name}|${show}`;
 		assert.ok(!seen.has(key), `${label}duplicate parameter "${property.name}" with identical display options`);
 		seen.set(key, true);
 	}
 	assert.equal(names.length > 0, true, `${label}no parameters`);
 	const loadOptionsMethods = description.properties
 		.filter((property) => property.typeOptions?.loadOptionsMethod)
 		.map((property) => property.typeOptions.loadOptionsMethod);
 	for (const method of loadOptionsMethods) {
 		assert.equal(
 			typeof instance.methods?.loadOptions?.[method],
 			'function',
 			`${label}parameter uses loadOptionsMethod "${method}" but the node does not implement it`,
 		);
 	}
 	assert.ok(loadOptionsMethods.length > 0, `${label}no dynamic model list`);
 	for (const credential of description.credentials ?? []) {
 		assert.ok(credentialNames.has(credential.name), `${label}references unknown credential ${credential.name}`);
 	}
 	for (const property of description.properties) {
 		if (property.typeOptions?.loadOptionsMethod !== undefined) continue; // dynamic list, filled at runtime
 		if (property.type === 'options') {
 			assert.ok(Array.isArray(property.options) && property.options.length > 0, `${label}"${property.name}" has no options`);
 			for (const option of property.options) {
 				assert.equal(typeof option.value, 'string', `${label}option of "${property.name}" without a value`);
 				assert.ok(option.value !== '', `${label}option of "${property.name}" with an empty value`);
 			}
 			assert.ok(
 				property.options.some((option) => option.value === property.default),
 				`${label}default "${property.default}" of "${property.name}" is not one of its options`,
 			);
 		}
 		if (property.type === 'collection') {
 			for (const option of property.options ?? []) {
 				assert.equal(typeof option.name, 'string', `${label}collection "${property.name}" has an option without a name`);
 				assert.equal(typeof option.type, 'string', `${label}collection "${property.name}" has an option without a type`);
 			}
 		}
 	}
 }
 const chatModel = loaded.nodes.find(({ instance }) => instance.description.name === 'lmChatTeamRouter').instance;
 assert.deepEqual(chatModel.description.inputs, [], 'chat model sub-node must not have a main input');
 assert.ok(
 	chatModel.description.outputs.includes('ai_languageModel'),
 	'chat model sub-node must output the ai_languageModel connection type',
 );
 assert.equal(typeof chatModel.supplyData, 'function', 'chat model sub-node must implement supplyData');
 console.error(
 	`OK validation: ${loaded.nodes.length} nodes, ${loaded.credentials.length} credential(s) [${[...credentialNames].join(', ')}]`,
 );
--- a/tsconfig.json
+++ b/tsconfig.json
@ -0,0 +1,24 @@
 {
 	"compilerOptions": {
 		"strict": true,
 		"module": "commonjs",
 		"moduleResolution": "node",
 		"target": "es2019",
 		"lib": ["es2019", "es2020", "es2022.error"],
 		"removeComments": true,
 		"useUnknownInCatchVariables": false,
 		"forceConsistentCasingInFileNames": true,
 		"noImplicitAny": true,
 		"noImplicitReturns": true,
 		"noUnusedLocals": true,
 		"strictNullChecks": true,
 		"preserveConstEnums": true,
 		"esModuleInterop": true,
 		"resolveJsonModule": true,
 		"skipLibCheck": true,
 		"declaration": false,
 		"sourceMap": false,
 		"outDir": "./dist/"
 	},
 	"include": ["credentials/**/*.ts", "nodes/**/*.ts"]
 }
		`@ -0,0 +1 @@`
							`<svg xmlns="http://www.w3.org/2000/svg" width="60" height="60" viewBox="0 0 60 60" fill="none"><rect x="6" y="6" width="48" height="48" rx="12" fill="#4F46E5"/><circle cx="20" cy="20" r="4" fill="#fff"/><circle cx="40" cy="20" r="4" fill="#fff"/><circle cx="30" cy="40" r="4" fill="#fff"/><path d="M20 20h20M20 20l10 20M40 20L30 40" stroke="#fff" stroke-width="2.5" stroke-linecap="round"/></svg>`