n8n-nodes-openrouter-custom 1.0.0

package/README.md

@@ -0,0 +1,140 @@
+# n8n-nodes-openrouter-custom
+
+Custom OpenRouter Chat Model node for n8n with built-in usage tracking and extended options.
+
+## Features
+
+- **Usage Tracking**: Automatically track token usage and costs via webhook
+- **User ID Support**: Pass custom user identifiers to OpenRouter for tracking
+- **Session Keys**: Group usage by custom session keys (e.g., `article_123`, `batch_xyz`)
+- **Reasoning Models**: Built-in support for reasoning effort settings (o1, etc.)
+- **Custom Model Kwargs**: Pass any additional parameters to the OpenRouter API
+
+## Installation
+
+### Via n8n Community Nodes
+
+1. Go to **Settings** → **Community Nodes**
+2. Click **Install**
+3. Enter `n8n-nodes-openrouter-custom`
+4. Click **Install**
+
+### Manual Installation
+
+```bash
+cd ~/.n8n
+npm install n8n-nodes-openrouter-custom
+```
+
+Then restart n8n.
+
+### From Source
+
+```bash
+git clone https://github.com/yourusername/n8n-nodes-openrouter-custom
+cd n8n-nodes-openrouter-custom
+npm install
+npm run build
+npm link
+
+cd ~/.n8n
+npm link n8n-nodes-openrouter-custom
+```
+
+## Configuration
+
+### Credentials
+
+1. Create new credentials of type **OpenRouter Custom API**
+2. Enter your OpenRouter API key
+3. Optionally set a default **Usage Webhook URL**
+
+### Node Options
+
+#### Basic Options
+- **Model**: Select from available OpenRouter models
+- **Temperature**: Controls randomness (0-2)
+- **Max Tokens**: Maximum tokens to generate
+- **Top P**: Nucleus sampling parameter
+- **Frequency/Presence Penalty**: Token repetition controls
+- **Response Format**: Text or JSON mode
+
+#### Usage Tracking
+- **Enable Usage Tracking**: Toggle tracking on/off
+- **User ID**: Identifier sent to OpenRouter and logged
+- **Session Key**: Custom key for grouping usage data
+- **Webhook URL Override**: Override credentials webhook for this node
+- **Include Cost**: Include cost data in tracking
+
+#### Advanced Options
+- **Model Kwargs**: Additional JSON parameters for the API
+- **Reasoning Effort**: For reasoning models (low/medium/high)
+
+## Usage Tracking Webhook
+
+When enabled, the node sends a POST request to your webhook URL after each LLM call:
+
+```json
+{
+  "timestamp": "2024-01-15T10:30:00.000Z",
+  "run_id": "abc123",
+  "parent_run_id": "xyz789",
+  "model": "anthropic/claude-sonnet-4",
+  "user": "user_123",
+  "session_key": "article_456",
+  "input_tokens": 150,
+  "output_tokens": 500,
+  "total_tokens": 650,
+  "cost": 0.00325,
+  "cached_tokens": 50,
+  "reasoning_tokens": 0,
+  "finish_reason": "stop"
+}
+```
+
+### Example Webhook Workflow
+
+Create an n8n workflow with:
+1. **Webhook** trigger node (POST)
+2. **Google Sheets** or **Database** node to store the data
+
+## Example Usage
+
+### Basic Usage
+
+1. Add the **OpenRouter Custom** node to your AI Agent
+2. Select your model
+3. Configure options as needed
+
+### With Usage Tracking
+
+1. Set up a webhook workflow to receive usage data
+2. In credentials, set the **Usage Webhook URL**
+3. In the node, enable **Usage Tracking**
+4. Optionally set **User ID** and **Session Key**
+
+### With Reasoning Models
+
+1. Select a reasoning model (e.g., `openai/o1-preview`)
+2. In **Advanced Options**, set **Reasoning Effort** to `high`
+3. Set **Temperature** to `1` (required for some reasoning models)
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Watch mode
+npm run dev
+
+# Clean build
+npm run clean && npm run build
+```
+
+## License
+
+MIT

package/dist/credentials/OpenRouterCustomApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class OpenRouterCustomApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/OpenRouterCustomApi.credentials.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterCustomApi = void 0;
+class OpenRouterCustomApi {
+    constructor() {
+        this.name = 'openRouterCustomApi';
+        this.displayName = 'OpenRouter Custom API';
+        this.documentationUrl = 'https://openrouter.ai/docs';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                required: true,
+                default: '',
+                description: 'Your OpenRouter API key',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'url',
+                type: 'string',
+                default: 'https://openrouter.ai/api/v1',
+                description: 'OpenRouter API base URL',
+            },
+            {
+                displayName: 'Usage Webhook URL',
+                name: 'usageWebhookUrl',
+                type: 'string',
+                default: '',
+                description: 'Optional webhook URL to send usage data to (leave empty to disable)',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.url}}',
+                url: '/models',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.OpenRouterCustomApi = OpenRouterCustomApi;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node';
+export * from './credentials/OpenRouterCustomApi.credentials';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node"), exports);
+__exportStar(require("./credentials/OpenRouterCustomApi.credentials"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZGQUEyRTtBQUMzRSxnRkFBOEQiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL25vZGVzL0xtQ2hhdE9wZW5Sb3V0ZXJDdXN0b20vTG1DaGF0T3BlblJvdXRlckN1c3RvbS5ub2RlJztcbmV4cG9ydCAqIGZyb20gJy4vY3JlZGVudGlhbHMvT3BlblJvdXRlckN1c3RvbUFwaS5jcmVkZW50aWFscyc7XG4iXX0=

package/dist/nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node.d.ts

@@ -0,0 +1,5 @@
+import type { INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from 'n8n-workflow';
+export declare class LmChatOpenRouterCustom implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
+}

package/dist/nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmChatOpenRouterCustom = void 0;
+const openai_1 = require("@langchain/openai");
+const n8n_workflow_1 = require("n8n-workflow");
+class LmChatOpenRouterCustom {
+    constructor() {
+        this.description = {
+            displayName: 'OpenRouter Chat Model (Custom)',
+            name: 'lmChatOpenRouterCustom',
+            icon: 'file:openrouter.svg',
+            group: ['transform'],
+            version: [1],
+            description: 'Custom OpenRouter Chat Model with usage tracking and extended options',
+            defaults: {
+                name: 'OpenRouter Custom',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Language Models', 'Root Nodes'],
+                    'Language Models': ['Chat Models (Recommended)'],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://openrouter.ai/docs',
+                        },
+                    ],
+                },
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
+            outputNames: ['Model'],
+            credentials: [
+                {
+                    name: 'openRouterCustomApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                ignoreHttpStatusErrors: true,
+                baseURL: '={{ $credentials?.url }}',
+            },
+            properties: [
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    description: 'The model which will generate the completion. <a href="https://openrouter.ai/docs/models">Learn more</a>.',
+                    typeOptions: {
+                        loadOptions: {
+                            routing: {
+                                request: {
+                                    method: 'GET',
+                                    url: '/models',
+                                },
+                                output: {
+                                    postReceive: [
+                                        {
+                                            type: 'rootProperty',
+                                            properties: {
+                                                property: 'data',
+                                            },
+                                        },
+                                        {
+                                            type: 'setKeyValue',
+                                            properties: {
+                                                name: '={{$responseItem.id}}',
+                                                value: '={{$responseItem.id}}',
+                                            },
+                                        },
+                                        {
+                                            type: 'sort',
+                                            properties: {
+                                                key: 'name',
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                    routing: {
+                        send: {
+                            type: 'body',
+                            property: 'model',
+                        },
+                    },
+                    default: 'openai/gpt-4.1-mini',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    placeholder: 'Add Option',
+                    description: 'Additional options to add',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Frequency Penalty',
+                            name: 'frequencyPenalty',
+                            default: 0,
+                            typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+                            description: "Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim",
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Maximum Number of Tokens',
+                            name: 'maxTokens',
+                            default: -1,
+                            description: 'The maximum number of tokens to generate in the completion. Most models have a context length of 2048 tokens (except for the newest models, which support 32,768).',
+                            type: 'number',
+                            typeOptions: {
+                                maxValue: 128000,
+                            },
+                        },
+                        {
+                            displayName: 'Response Format',
+                            name: 'responseFormat',
+                            default: 'text',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Text',
+                                    value: 'text',
+                                    description: 'Regular text response',
+                                },
+                                {
+                                    name: 'JSON',
+                                    value: 'json_object',
+                                    description: 'Enables JSON mode, which should guarantee the message the model generates is valid JSON',
+                                },
+                            ],
+                        },
+                        {
+                            displayName: 'Presence Penalty',
+                            name: 'presencePenalty',
+                            default: 0,
+                            typeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },
+                            description: "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics",
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Sampling Temperature',
+                            name: 'temperature',
+                            default: 0.7,
+                            typeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },
+                            description: 'Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Timeout',
+                            name: 'timeout',
+                            default: 360000,
+                            description: 'Maximum amount of time a request is allowed to take in milliseconds',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Max Retries',
+                            name: 'maxRetries',
+                            default: 2,
+                            description: 'Maximum number of retries to attempt',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Top P',
+                            name: 'topP',
+                            default: 1,
+                            typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
+                            description: 'Controls diversity via nucleus sampling: 0.5 means half of all likelihood-weighted options are considered. We generally recommend altering this or temperature but not both.',
+                            type: 'number',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Usage Tracking',
+                    name: 'usageTracking',
+                    placeholder: 'Add Usage Tracking Options',
+                    description: 'Options for tracking token usage and costs',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Enable Usage Tracking',
+                            name: 'enableTracking',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to track and log usage data',
+                        },
+                        {
+                            displayName: 'User ID',
+                            name: 'userId',
+                            type: 'string',
+                            default: '',
+                            description: 'User identifier for usage tracking (sent to OpenRouter and logged)',
+                        },
+                        {
+                            displayName: 'Session Key',
+                            name: 'sessionKey',
+                            type: 'string',
+                            default: '',
+                            description: 'Custom session key for grouping usage (e.g., article_123, batch_xyz)',
+                        },
+                        {
+                            displayName: 'Webhook URL Override',
+                            name: 'webhookUrlOverride',
+                            type: 'string',
+                            default: '',
+                            description: 'Override the webhook URL from credentials for this specific node',
+                        },
+                        {
+                            displayName: 'Include Cost',
+                            name: 'includeCost',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to include cost data in usage tracking (requires OpenRouter to return it)',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Advanced Options',
+                    name: 'advancedOptions',
+                    placeholder: 'Add Advanced Option',
+                    description: 'Advanced model configuration options',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Model Kwargs (JSON)',
+                            name: 'modelKwargs',
+                            type: 'json',
+                            default: '{}',
+                            description: 'Additional model kwargs to pass to OpenRouter API as JSON',
+                        },
+                        {
+                            displayName: 'Reasoning Effort',
+                            name: 'reasoningEffort',
+                            type: 'options',
+                            default: '',
+                            description: 'For reasoning models (o1, etc.), set the reasoning effort level',
+                            options: [
+                                {
+                                    name: 'None',
+                                    value: '',
+                                },
+                                {
+                                    name: 'Low',
+                                    value: 'low',
+                                },
+                                {
+                                    name: 'Medium',
+                                    value: 'medium',
+                                },
+                                {
+                                    name: 'High',
+                                    value: 'high',
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const credentials = await this.getCredentials('openRouterCustomApi');
+        const modelName = this.getNodeParameter('model', itemIndex);
+        const options = this.getNodeParameter('options', itemIndex, {});
+        const usageTracking = this.getNodeParameter('usageTracking', itemIndex, {});
+        const advancedOptions = this.getNodeParameter('advancedOptions', itemIndex, {});
+        // Build configuration
+        const configuration = {
+            baseURL: credentials.url,
+        };
+        // Build model kwargs
+        let modelKwargs = {};
+        // Add response format if specified
+        if (options.responseFormat && options.responseFormat !== 'text') {
+            modelKwargs.response_format = { type: options.responseFormat };
+        }
+        // Add user ID if specified
+        if (usageTracking.userId) {
+            modelKwargs.user = usageTracking.userId;
+        }
+        // Always request usage data from OpenRouter
+        modelKwargs.usage = { include: true };
+        // Add reasoning effort if specified
+        if (advancedOptions.reasoningEffort) {
+            modelKwargs.reasoning_effort = advancedOptions.reasoningEffort;
+        }
+        // Merge custom model kwargs
+        if (advancedOptions.modelKwargs) {
+            try {
+                const customKwargs = typeof advancedOptions.modelKwargs === 'string'
+                    ? JSON.parse(advancedOptions.modelKwargs)
+                    : advancedOptions.modelKwargs;
+                modelKwargs = { ...modelKwargs, ...customKwargs };
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in Model Kwargs', { description: 'Please provide valid JSON for Model Kwargs' });
+            }
+        }
+        // Determine webhook URL
+        const webhookUrl = usageTracking.webhookUrlOverride || credentials.usageWebhookUrl || '';
+        const enableTracking = usageTracking.enableTracking !== false;
+        const sessionKey = usageTracking.sessionKey || '';
+        const userId = usageTracking.userId || '';
+        // Build callbacks
+        const callbacks = [];
+        if (enableTracking && webhookUrl) {
+            callbacks.push({
+                handleLLMEnd: async (output, runId, parentRunId) => {
+                    try {
+                        const generation = output.generations?.[0]?.[0];
+                        if (!generation)
+                            return;
+                        const message = generation.message;
+                        const usageMetadata = message?.usage_metadata;
+                        const responseMetadata = message?.response_metadata;
+                        const usageData = {
+                            timestamp: new Date().toISOString(),
+                            run_id: runId,
+                            parent_run_id: parentRunId,
+                            model: modelName,
+                            user: userId || undefined,
+                            session_key: sessionKey || undefined,
+                            input_tokens: usageMetadata?.input_tokens,
+                            output_tokens: usageMetadata?.output_tokens,
+                            total_tokens: usageMetadata?.total_tokens,
+                            cost: responseMetadata?.usage?.cost,
+                            cached_tokens: responseMetadata?.usage?.prompt_tokens_details?.cached_tokens,
+                            reasoning_tokens: responseMetadata?.usage?.completion_tokens_details?.reasoning_tokens,
+                            finish_reason: responseMetadata?.finish_reason,
+                        };
+                        // Send to webhook
+                        await fetch(webhookUrl, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(usageData),
+                        });
+                    }
+                    catch (err) {
+                        // Log error but don't fail the main request
+                        console.error('Usage tracking webhook failed:', err);
+                    }
+                },
+            });
+        }
+        // Create the model
+        const model = new openai_1.ChatOpenAI({
+            apiKey: credentials.apiKey,
+            model: modelName,
+            configuration,
+            timeout: options.timeout ?? 360000,
+            maxRetries: options.maxRetries ?? 2,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens > 0 ? options.maxTokens : undefined,
+            topP: options.topP,
+            frequencyPenalty: options.frequencyPenalty,
+            presencePenalty: options.presencePenalty,
+            modelKwargs,
+            callbacks,
+        });
+        return {
+            response: model,
+        };
+    }
+}
+exports.LmChatOpenRouterCustom = LmChatOpenRouterCustom;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LmChatOpenRouterCustom.node.js","sourceRoot":"","sources":["../../../src/nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChatOpenAI } from '@langchain/openai';\nimport type { ClientOptions } from '@langchain/openai';\nimport type {\n\tINodeType,\n\tINodeTypeDescription,\n\tISupplyDataFunctions,\n\tSupplyData,\n\tIDataObject,\n} from 'n8n-workflow';\nimport {\n\tNodeConnectionTypes,\n\tNodeOperationError,\n} from 'n8n-workflow';\n\ninterface OpenRouterCredential {\n\tapiKey: string;\n\turl: string;\n\tusageWebhookUrl?: string;\n}\n\ninterface UsageData {\n\ttimestamp: string;\n\trun_id: string;\n\tparent_run_id?: string;\n\tmodel: string;\n\tuser?: string;\n\tsession_key?: string;\n\tinput_tokens?: number;\n\toutput_tokens?: number;\n\ttotal_tokens?: number;\n\tcost?: number;\n\tcached_tokens?: number;\n\treasoning_tokens?: number;\n\tfinish_reason?: string;\n}\n\nexport class LmChatOpenRouterCustom implements INodeType {\n\tdescription: INodeTypeDescription = {\n\t\tdisplayName: 'OpenRouter Chat Model (Custom)',\n\t\tname: 'lmChatOpenRouterCustom',\n\t\ticon: 'file:openrouter.svg',\n\t\tgroup: ['transform'],\n\t\tversion: [1],\n\t\tdescription: 'Custom OpenRouter Chat Model with usage tracking and extended options',\n\t\tdefaults: {\n\t\t\tname: 'OpenRouter Custom',\n\t\t},\n\t\tcodex: {\n\t\t\tcategories: ['AI'],\n\t\t\tsubcategories: {\n\t\t\t\tAI: ['Language Models', 'Root Nodes'],\n\t\t\t\t'Language Models': ['Chat Models (Recommended)'],\n\t\t\t},\n\t\t\tresources: {\n\t\t\t\tprimaryDocumentation: [\n\t\t\t\t\t{\n\t\t\t\t\t\turl: 'https://openrouter.ai/docs',\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t},\n\n\t\tinputs: [],\n\t\toutputs: [NodeConnectionTypes.AiLanguageModel],\n\t\toutputNames: ['Model'],\n\t\tcredentials: [\n\t\t\t{\n\t\t\t\tname: 'openRouterCustomApi',\n\t\t\t\trequired: true,\n\t\t\t},\n\t\t],\n\t\trequestDefaults: {\n\t\t\tignoreHttpStatusErrors: true,\n\t\t\tbaseURL: '={{ $credentials?.url }}',\n\t\t},\n\t\tproperties: [\n\t\t\t{\n\t\t\t\tdisplayName: 'Model',\n\t\t\t\tname: 'model',\n\t\t\t\ttype: 'options',\n\t\t\t\tdescription:\n\t\t\t\t\t'The model which will generate the completion. <a href=\"https://openrouter.ai/docs/models\">Learn more</a>.',\n\t\t\t\ttypeOptions: {\n\t\t\t\t\tloadOptions: {\n\t\t\t\t\t\trouting: {\n\t\t\t\t\t\t\trequest: {\n\t\t\t\t\t\t\t\tmethod: 'GET',\n\t\t\t\t\t\t\t\turl: '/models',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\toutput: {\n\t\t\t\t\t\t\t\tpostReceive: [\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\ttype: 'rootProperty',\n\t\t\t\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\t\t\t\tproperty: 'data',\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\ttype: 'setKeyValue',\n\t\t\t\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\t\t\t\tname: '={{$responseItem.id}}',\n\t\t\t\t\t\t\t\t\t\t\tvalue: '={{$responseItem.id}}',\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\ttype: 'sort',\n\t\t\t\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\t\t\t\tkey: 'name',\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\trouting: {\n\t\t\t\t\tsend: {\n\t\t\t\t\t\ttype: 'body',\n\t\t\t\t\t\tproperty: 'model',\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tdefault: 'openai/gpt-4.1-mini',\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Options',\n\t\t\t\tname: 'options',\n\t\t\t\tplaceholder: 'Add Option',\n\t\t\t\tdescription: 'Additional options to add',\n\t\t\t\ttype: 'collection',\n\t\t\t\tdefault: {},\n\t\t\t\toptions: [\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Frequency Penalty',\n\t\t\t\t\t\tname: 'frequencyPenalty',\n\t\t\t\t\t\tdefault: 0,\n\t\t\t\t\t\ttypeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t\"Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim\",\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Maximum Number of Tokens',\n\t\t\t\t\t\tname: 'maxTokens',\n\t\t\t\t\t\tdefault: -1,\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t'The maximum number of tokens to generate in the completion. Most models have a context length of 2048 tokens (except for the newest models, which support 32,768).',\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t\ttypeOptions: {\n\t\t\t\t\t\t\tmaxValue: 128000,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Response Format',\n\t\t\t\t\t\tname: 'responseFormat',\n\t\t\t\t\t\tdefault: 'text',\n\t\t\t\t\t\ttype: 'options',\n\t\t\t\t\t\toptions: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'Text',\n\t\t\t\t\t\t\t\tvalue: 'text',\n\t\t\t\t\t\t\t\tdescription: 'Regular text response',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'JSON',\n\t\t\t\t\t\t\t\tvalue: 'json_object',\n\t\t\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t\t\t'Enables JSON mode, which should guarantee the message the model generates is valid JSON',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Presence Penalty',\n\t\t\t\t\t\tname: 'presencePenalty',\n\t\t\t\t\t\tdefault: 0,\n\t\t\t\t\t\ttypeOptions: { maxValue: 2, minValue: -2, numberPrecision: 1 },\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t\"Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics\",\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Sampling Temperature',\n\t\t\t\t\t\tname: 'temperature',\n\t\t\t\t\t\tdefault: 0.7,\n\t\t\t\t\t\ttypeOptions: { maxValue: 2, minValue: 0, numberPrecision: 1 },\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t'Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.',\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Timeout',\n\t\t\t\t\t\tname: 'timeout',\n\t\t\t\t\t\tdefault: 360000,\n\t\t\t\t\t\tdescription: 'Maximum amount of time a request is allowed to take in milliseconds',\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Max Retries',\n\t\t\t\t\t\tname: 'maxRetries',\n\t\t\t\t\t\tdefault: 2,\n\t\t\t\t\t\tdescription: 'Maximum number of retries to attempt',\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Top P',\n\t\t\t\t\t\tname: 'topP',\n\t\t\t\t\t\tdefault: 1,\n\t\t\t\t\t\ttypeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },\n\t\t\t\t\t\tdescription:\n\t\t\t\t\t\t\t'Controls diversity via nucleus sampling: 0.5 means half of all likelihood-weighted options are considered. We generally recommend altering this or temperature but not both.',\n\t\t\t\t\t\ttype: 'number',\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Usage Tracking',\n\t\t\t\tname: 'usageTracking',\n\t\t\t\tplaceholder: 'Add Usage Tracking Options',\n\t\t\t\tdescription: 'Options for tracking token usage and costs',\n\t\t\t\ttype: 'collection',\n\t\t\t\tdefault: {},\n\t\t\t\toptions: [\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Enable Usage Tracking',\n\t\t\t\t\t\tname: 'enableTracking',\n\t\t\t\t\t\ttype: 'boolean',\n\t\t\t\t\t\tdefault: true,\n\t\t\t\t\t\tdescription: 'Whether to track and log usage data',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'User ID',\n\t\t\t\t\t\tname: 'userId',\n\t\t\t\t\t\ttype: 'string',\n\t\t\t\t\t\tdefault: '',\n\t\t\t\t\t\tdescription: 'User identifier for usage tracking (sent to OpenRouter and logged)',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Session Key',\n\t\t\t\t\t\tname: 'sessionKey',\n\t\t\t\t\t\ttype: 'string',\n\t\t\t\t\t\tdefault: '',\n\t\t\t\t\t\tdescription: 'Custom session key for grouping usage (e.g., article_123, batch_xyz)',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Webhook URL Override',\n\t\t\t\t\t\tname: 'webhookUrlOverride',\n\t\t\t\t\t\ttype: 'string',\n\t\t\t\t\t\tdefault: '',\n\t\t\t\t\t\tdescription: 'Override the webhook URL from credentials for this specific node',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Include Cost',\n\t\t\t\t\t\tname: 'includeCost',\n\t\t\t\t\t\ttype: 'boolean',\n\t\t\t\t\t\tdefault: true,\n\t\t\t\t\t\tdescription: 'Whether to include cost data in usage tracking (requires OpenRouter to return it)',\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t\t{\n\t\t\t\tdisplayName: 'Advanced Options',\n\t\t\t\tname: 'advancedOptions',\n\t\t\t\tplaceholder: 'Add Advanced Option',\n\t\t\t\tdescription: 'Advanced model configuration options',\n\t\t\t\ttype: 'collection',\n\t\t\t\tdefault: {},\n\t\t\t\toptions: [\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Model Kwargs (JSON)',\n\t\t\t\t\t\tname: 'modelKwargs',\n\t\t\t\t\t\ttype: 'json',\n\t\t\t\t\t\tdefault: '{}',\n\t\t\t\t\t\tdescription: 'Additional model kwargs to pass to OpenRouter API as JSON',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tdisplayName: 'Reasoning Effort',\n\t\t\t\t\t\tname: 'reasoningEffort',\n\t\t\t\t\t\ttype: 'options',\n\t\t\t\t\t\tdefault: '',\n\t\t\t\t\t\tdescription: 'For reasoning models (o1, etc.), set the reasoning effort level',\n\t\t\t\t\t\toptions: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'None',\n\t\t\t\t\t\t\t\tvalue: '',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'Low',\n\t\t\t\t\t\t\t\tvalue: 'low',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'Medium',\n\t\t\t\t\t\t\t\tvalue: 'medium',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tname: 'High',\n\t\t\t\t\t\t\t\tvalue: 'high',\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t},\n\t\t],\n\t};\n\n\tasync supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData> {\n\t\tconst credentials = await this.getCredentials<OpenRouterCredential>('openRouterCustomApi');\n\n\t\tconst modelName = this.getNodeParameter('model', itemIndex) as string;\n\t\tconst options = this.getNodeParameter('options', itemIndex, {}) as IDataObject;\n\t\tconst usageTracking = this.getNodeParameter('usageTracking', itemIndex, {}) as IDataObject;\n\t\tconst advancedOptions = this.getNodeParameter('advancedOptions', itemIndex, {}) as IDataObject;\n\n\t\t// Build configuration\n\t\tconst configuration: ClientOptions = {\n\t\t\tbaseURL: credentials.url,\n\t\t};\n\n\t\t// Build model kwargs\n\t\tlet modelKwargs: IDataObject = {};\n\n\t\t// Add response format if specified\n\t\tif (options.responseFormat && options.responseFormat !== 'text') {\n\t\t\tmodelKwargs.response_format = { type: options.responseFormat };\n\t\t}\n\n\t\t// Add user ID if specified\n\t\tif (usageTracking.userId) {\n\t\t\tmodelKwargs.user = usageTracking.userId;\n\t\t}\n\n\t\t// Always request usage data from OpenRouter\n\t\tmodelKwargs.usage = { include: true };\n\n\t\t// Add reasoning effort if specified\n\t\tif (advancedOptions.reasoningEffort) {\n\t\t\tmodelKwargs.reasoning_effort = advancedOptions.reasoningEffort;\n\t\t}\n\n\t\t// Merge custom model kwargs\n\t\tif (advancedOptions.modelKwargs) {\n\t\t\ttry {\n\t\t\t\tconst customKwargs = typeof advancedOptions.modelKwargs === 'string'\n\t\t\t\t\t? JSON.parse(advancedOptions.modelKwargs)\n\t\t\t\t\t: advancedOptions.modelKwargs;\n\t\t\t\tmodelKwargs = { ...modelKwargs, ...customKwargs };\n\t\t\t} catch (error) {\n\t\t\t\tthrow new NodeOperationError(\n\t\t\t\t\tthis.getNode(),\n\t\t\t\t\t'Invalid JSON in Model Kwargs',\n\t\t\t\t\t{ description: 'Please provide valid JSON for Model Kwargs' }\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\t// Determine webhook URL\n\t\tconst webhookUrl = (usageTracking.webhookUrlOverride as string) || credentials.usageWebhookUrl || '';\n\t\tconst enableTracking = usageTracking.enableTracking !== false;\n\t\tconst sessionKey = usageTracking.sessionKey as string || '';\n\t\tconst userId = usageTracking.userId as string || '';\n\n\t\t// Build callbacks\n\t\tconst callbacks: any[] = [];\n\n\t\tif (enableTracking && webhookUrl) {\n\t\t\tcallbacks.push({\n\t\t\t\thandleLLMEnd: async (output: any, runId: string, parentRunId?: string) => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst generation = output.generations?.[0]?.[0];\n\t\t\t\t\t\tif (!generation) return;\n\n\t\t\t\t\t\tconst message = generation.message;\n\t\t\t\t\t\tconst usageMetadata = message?.usage_metadata;\n\t\t\t\t\t\tconst responseMetadata = message?.response_metadata;\n\n\t\t\t\t\t\tconst usageData: UsageData = {\n\t\t\t\t\t\t\ttimestamp: new Date().toISOString(),\n\t\t\t\t\t\t\trun_id: runId,\n\t\t\t\t\t\t\tparent_run_id: parentRunId,\n\t\t\t\t\t\t\tmodel: modelName,\n\t\t\t\t\t\t\tuser: userId || undefined,\n\t\t\t\t\t\t\tsession_key: sessionKey || undefined,\n\t\t\t\t\t\t\tinput_tokens: usageMetadata?.input_tokens,\n\t\t\t\t\t\t\toutput_tokens: usageMetadata?.output_tokens,\n\t\t\t\t\t\t\ttotal_tokens: usageMetadata?.total_tokens,\n\t\t\t\t\t\t\tcost: responseMetadata?.usage?.cost,\n\t\t\t\t\t\t\tcached_tokens: responseMetadata?.usage?.prompt_tokens_details?.cached_tokens,\n\t\t\t\t\t\t\treasoning_tokens: responseMetadata?.usage?.completion_tokens_details?.reasoning_tokens,\n\t\t\t\t\t\t\tfinish_reason: responseMetadata?.finish_reason,\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// Send to webhook\n\t\t\t\t\t\tawait fetch(webhookUrl, {\n\t\t\t\t\t\t\tmethod: 'POST',\n\t\t\t\t\t\t\theaders: { 'Content-Type': 'application/json' },\n\t\t\t\t\t\t\tbody: JSON.stringify(usageData),\n\t\t\t\t\t\t});\n\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\t// Log error but don't fail the main request\n\t\t\t\t\t\tconsole.error('Usage tracking webhook failed:', err);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t});\n\t\t}\n\n\t\t// Create the model\n\t\tconst model = new ChatOpenAI({\n\t\t\tapiKey: credentials.apiKey,\n\t\t\tmodel: modelName,\n\t\t\tconfiguration,\n\t\t\ttimeout: (options.timeout as number) ?? 360000,\n\t\t\tmaxRetries: (options.maxRetries as number) ?? 2,\n\t\t\ttemperature: options.temperature as number,\n\t\t\tmaxTokens: (options.maxTokens as number) > 0 ? (options.maxTokens as number) : undefined,\n\t\t\ttopP: options.topP as number,\n\t\t\tfrequencyPenalty: options.frequencyPenalty as number,\n\t\t\tpresencePenalty: options.presencePenalty as number,\n\t\t\tmodelKwargs,\n\t\t\tcallbacks,\n\t\t});\n\n\t\treturn {\n\t\t\tresponse: model,\n\t\t};\n\t}\n}\n"]}

package/dist/nodes/LmChatOpenRouterCustom/openrouter.dark.svg

@@ -0,0 +1 @@
+<svg fill="white" fill-rule="evenodd" width="40" height="40" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>OpenRouter</title><path d="M16.804 1.957l7.22 4.105v.087L16.73 10.21l.017-2.117-.821-.03c-1.059-.028-1.611.002-2.268.11-1.064.175-2.038.577-3.147 1.352L8.345 11.03c-.284.195-.495.336-.68.455l-.515.322-.397.234.385.23.53.338c.476.314 1.17.796 2.701 1.866 1.11.775 2.083 1.177 3.147 1.352l.3.045c.694.091 1.375.094 2.825.033l.022-2.159 7.22 4.105v.087L16.589 22l.014-1.862-.635.022c-1.386.042-2.137.002-3.138-.162-1.694-.28-3.26-.926-4.881-2.059l-2.158-1.5a21.997 21.997 0 00-.755-.498l-.467-.28a55.927 55.927 0 00-.76-.43C2.908 14.73.563 14.116 0 14.116V9.888l.14.004c.564-.007 2.91-.622 3.809-1.124l1.016-.58.438-.274c.428-.28 1.072-.726 2.686-1.853 1.621-1.133 3.186-1.78 4.881-2.059 1.152-.19 1.974-.213 3.814-.138l.02-1.907z"></path></svg>

package/dist/nodes/LmChatOpenRouterCustom/openrouter.svg

@@ -0,0 +1 @@
+<svg fill="#94A3B8" fill-rule="evenodd" width="40" height="40" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>OpenRouter</title><path d="M16.804 1.957l7.22 4.105v.087L16.73 10.21l.017-2.117-.821-.03c-1.059-.028-1.611.002-2.268.11-1.064.175-2.038.577-3.147 1.352L8.345 11.03c-.284.195-.495.336-.68.455l-.515.322-.397.234.385.23.53.338c.476.314 1.17.796 2.701 1.866 1.11.775 2.083 1.177 3.147 1.352l.3.045c.694.091 1.375.094 2.825.033l.022-2.159 7.22 4.105v.087L16.589 22l.014-1.862-.635.022c-1.386.042-2.137.002-3.138-.162-1.694-.28-3.26-.926-4.881-2.059l-2.158-1.5a21.997 21.997 0 00-.755-.498l-.467-.28a55.927 55.927 0 00-.76-.43C2.908 14.73.563 14.116 0 14.116V9.888l.14.004c.564-.007 2.91-.622 3.809-1.124l1.016-.58.438-.274c.428-.28 1.072-.726 2.686-1.853 1.621-1.133 3.186-1.78 4.881-2.059 1.152-.19 1.974-.213 3.814-.138l.02-1.907z"></path></svg>

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "n8n-nodes-openrouter-custom",
+  "author": "My Author",
+  "version": "1.0.0",
+  "description": "Custom OpenRouter Chat Model node with usage tracking and extended options",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/LmChatOpenRouterCustom/LmChatOpenRouterCustom.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/OpenRouterCustomApi.credentials.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-icons",
+    "copy-icons": "cp src/nodes/LmChatOpenRouterCustom/*.svg dist/nodes/LmChatOpenRouterCustom/ 2>/dev/null || true",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint . --ext .ts",
+    "clean": "rm -rf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@langchain/openai": "^0.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "*",
+    "typescript": "*",
+    "n8n-workflow": "^1.0.0"
+  },
+  "keywords": [
+    "n8n",
+    "n8n-community-node-package",
+    "openrouter",
+    "langchain",
+    "llm",
+    "ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/n8n-nodes-openrouter-custom"
+  }
+}