n8n-nodes-openrouter-selector 0.3.0

package/dist/nodes/OpenRouterSmartChat/OpenRouterSmartChat.node.js

@@ -0,0 +1,657 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterSmartChat = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const types_1 = require("./types");
+const taskProfiles_1 = require("./taskProfiles");
+const modelScoring_1 = require("./modelScoring");
+class OpenRouterSmartChat {
+    description = {
+        displayName: 'OpenRouter Smart Chat',
+        name: 'openRouterSmartChat',
+        icon: 'file:openrouter-smart.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: 'Intelligent OpenRouter integration: auto-select models or direct chat completion',
+        defaults: {
+            name: 'OpenRouter Smart Chat',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'openRouterApi',
+                required: true,
+            },
+            {
+                name: 'supabaseModelCatalogApi',
+                required: false,
+                displayOptions: {
+                    show: {
+                        operation: ['smartChat', 'selectOnly'],
+                    },
+                },
+            },
+        ],
+        properties: [
+            // ===========================================================================
+            // Operation Selection
+            // ===========================================================================
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                default: 'chat',
+                options: [
+                    {
+                        name: 'Chat Completion',
+                        value: 'chat',
+                        description: 'Send messages to a specified model',
+                    },
+                    {
+                        name: 'Smart Chat (Auto-Select Model)',
+                        value: 'smartChat',
+                        description: 'Automatically select the best model based on task and budget, then chat',
+                    },
+                    {
+                        name: 'Select Model Only',
+                        value: 'selectOnly',
+                        description: 'Only select the best model, no API call',
+                    },
+                ],
+            },
+            // ===========================================================================
+            // Model (for 'chat' operation)
+            // ===========================================================================
+            {
+                displayName: 'Model',
+                name: 'model',
+                type: 'string',
+                default: 'anthropic/claude-3.5-haiku',
+                required: true,
+                description: 'OpenRouter model ID (e.g., anthropic/claude-3.5-haiku, openai/gpt-4o)',
+                placeholder: 'anthropic/claude-3.5-haiku',
+                displayOptions: {
+                    show: {
+                        operation: ['chat'],
+                    },
+                },
+            },
+            // ===========================================================================
+            // Task Category (for 'smartChat' and 'selectOnly')
+            // ===========================================================================
+            {
+                displayName: 'Task Category',
+                name: 'task',
+                type: 'options',
+                default: 'chat',
+                required: true,
+                description: 'What type of task will this model perform?',
+                options: (0, taskProfiles_1.getTaskCategories)().map((task) => ({
+                    name: (0, taskProfiles_1.getTaskDescription)(task),
+                    value: task,
+                })),
+                displayOptions: {
+                    show: {
+                        operation: ['smartChat', 'selectOnly'],
+                    },
+                },
+            },
+            // ===========================================================================
+            // Budget (for 'smartChat' and 'selectOnly')
+            // ===========================================================================
+            {
+                displayName: 'Budget',
+                name: 'budget',
+                type: 'options',
+                default: 'balanced',
+                required: true,
+                description: 'How much are you willing to spend?',
+                options: [
+                    {
+                        name: 'Cheap - Lowest cost, quality secondary',
+                        value: 'cheap',
+                    },
+                    {
+                        name: 'Balanced - Good price-performance ratio',
+                        value: 'balanced',
+                    },
+                    {
+                        name: 'Premium - Best quality, cost no concern',
+                        value: 'premium',
+                    },
+                ],
+                displayOptions: {
+                    show: {
+                        operation: ['smartChat', 'selectOnly'],
+                    },
+                },
+            },
+            // ===========================================================================
+            // Model Override (for 'smartChat' and 'selectOnly')
+            // ===========================================================================
+            {
+                displayName: 'Model Override',
+                name: 'modelOverride',
+                type: 'options',
+                default: 'default',
+                description: 'Override automatic selection with a specific model',
+                typeOptions: {
+                    loadOptionsMethod: 'getTopModels',
+                },
+                displayOptions: {
+                    show: {
+                        operation: ['smartChat', 'selectOnly'],
+                    },
+                },
+            },
+            // ===========================================================================
+            // Messages (for 'chat' and 'smartChat')
+            // ===========================================================================
+            {
+                displayName: 'Messages',
+                name: 'messages',
+                type: 'fixedCollection',
+                typeOptions: {
+                    multipleValues: true,
+                    sortable: true,
+                },
+                default: {},
+                placeholder: 'Add Message',
+                description: 'The messages to send to the model',
+                displayOptions: {
+                    show: {
+                        operation: ['chat', 'smartChat'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'messageValues',
+                        displayName: 'Message',
+                        values: [
+                            {
+                                displayName: 'Role',
+                                name: 'role',
+                                type: 'options',
+                                default: 'user',
+                                options: [
+                                    { name: 'System', value: 'system' },
+                                    { name: 'User', value: 'user' },
+                                    { name: 'Assistant', value: 'assistant' },
+                                ],
+                                description: 'The role of the message author',
+                            },
+                            {
+                                displayName: 'Content',
+                                name: 'content',
+                                type: 'string',
+                                typeOptions: {
+                                    rows: 4,
+                                },
+                                default: '',
+                                description: 'The content of the message',
+                            },
+                        ],
+                    },
+                ],
+            },
+            // ===========================================================================
+            // Filters (for 'smartChat' and 'selectOnly')
+            // ===========================================================================
+            {
+                displayName: 'Filters',
+                name: 'filters',
+                type: 'collection',
+                placeholder: 'Add Filter',
+                default: {},
+                displayOptions: {
+                    show: {
+                        operation: ['smartChat', 'selectOnly'],
+                    },
+                },
+                options: [
+                    {
+                        displayName: 'Min Context Length',
+                        name: 'minContextLength',
+                        type: 'number',
+                        default: 8000,
+                        description: 'Minimum context window size (tokens)',
+                    },
+                    {
+                        displayName: 'Require JSON Mode',
+                        name: 'requireJsonMode',
+                        type: 'boolean',
+                        default: false,
+                        description: 'Only include models that support JSON output mode',
+                    },
+                    {
+                        displayName: 'Require Vision',
+                        name: 'requireVision',
+                        type: 'boolean',
+                        default: false,
+                        description: 'Only include multimodal models with image input support',
+                    },
+                    {
+                        displayName: 'Max Cost per 1K Tokens',
+                        name: 'maxCostPerK',
+                        type: 'number',
+                        default: 0,
+                        description: 'Maximum cost in USD per 1K tokens (0 = no limit)',
+                    },
+                    {
+                        displayName: 'Provider Whitelist',
+                        name: 'providerWhitelist',
+                        type: 'multiOptions',
+                        default: [],
+                        description: 'Only include models from these providers (empty = all)',
+                        options: [
+                            { name: 'Anthropic', value: 'anthropic' },
+                            { name: 'OpenAI', value: 'openai' },
+                            { name: 'Google', value: 'google' },
+                            { name: 'DeepSeek', value: 'deepseek' },
+                            { name: 'Meta Llama', value: 'meta-llama' },
+                            { name: 'Mistral AI', value: 'mistralai' },
+                            { name: 'Qwen', value: 'qwen' },
+                            { name: 'Cohere', value: 'cohere' },
+                            { name: 'Perplexity', value: 'perplexity' },
+                            { name: 'xAI', value: 'x-ai' },
+                        ],
+                    },
+                    {
+                        displayName: 'Provider Blacklist',
+                        name: 'providerBlacklist',
+                        type: 'multiOptions',
+                        default: [],
+                        description: 'Exclude models from these providers',
+                        options: [
+                            { name: 'Anthropic', value: 'anthropic' },
+                            { name: 'OpenAI', value: 'openai' },
+                            { name: 'Google', value: 'google' },
+                            { name: 'DeepSeek', value: 'deepseek' },
+                            { name: 'Meta Llama', value: 'meta-llama' },
+                            { name: 'Mistral AI', value: 'mistralai' },
+                            { name: 'Qwen', value: 'qwen' },
+                            { name: 'Cohere', value: 'cohere' },
+                            { name: 'Perplexity', value: 'perplexity' },
+                            { name: 'xAI', value: 'x-ai' },
+                        ],
+                    },
+                ],
+            },
+            // ===========================================================================
+            // Chat Options
+            // ===========================================================================
+            {
+                displayName: 'Options',
+                name: 'options',
+                type: 'collection',
+                placeholder: 'Add Option',
+                default: {},
+                options: [
+                    {
+                        displayName: 'Temperature',
+                        name: 'temperature',
+                        type: 'number',
+                        default: 0.7,
+                        typeOptions: {
+                            minValue: 0,
+                            maxValue: 2,
+                            numberPrecision: 2,
+                        },
+                        description: 'Sampling temperature (0-2). Higher = more creative, lower = more focused.',
+                    },
+                    {
+                        displayName: 'Max Tokens',
+                        name: 'maxTokens',
+                        type: 'number',
+                        default: 1000,
+                        typeOptions: {
+                            minValue: 1,
+                            maxValue: 128000,
+                        },
+                        description: 'Maximum number of tokens to generate',
+                    },
+                    {
+                        displayName: 'JSON Mode',
+                        name: 'jsonMode',
+                        type: 'boolean',
+                        default: false,
+                        description: 'Whether to force JSON output format',
+                    },
+                    {
+                        displayName: 'Top P',
+                        name: 'topP',
+                        type: 'number',
+                        default: 1,
+                        typeOptions: {
+                            minValue: 0,
+                            maxValue: 1,
+                            numberPrecision: 2,
+                        },
+                        description: 'Nucleus sampling parameter (0-1)',
+                    },
+                    {
+                        displayName: 'Frequency Penalty',
+                        name: 'frequencyPenalty',
+                        type: 'number',
+                        default: 0,
+                        typeOptions: {
+                            minValue: -2,
+                            maxValue: 2,
+                            numberPrecision: 2,
+                        },
+                        description: 'Penalty for token frequency (-2 to 2)',
+                    },
+                    {
+                        displayName: 'Presence Penalty',
+                        name: 'presencePenalty',
+                        type: 'number',
+                        default: 0,
+                        typeOptions: {
+                            minValue: -2,
+                            maxValue: 2,
+                            numberPrecision: 2,
+                        },
+                        description: 'Penalty for token presence (-2 to 2)',
+                    },
+                    {
+                        displayName: 'Alternatives Count',
+                        name: 'alternativesCount',
+                        type: 'number',
+                        default: types_1.DEFAULT_ALTERNATIVES,
+                        description: 'Number of alternative models to return (for selectOnly)',
+                        typeOptions: {
+                            minValue: 1,
+                            maxValue: types_1.MAX_ALTERNATIVES,
+                        },
+                        displayOptions: {
+                            show: {
+                                '/operation': ['selectOnly'],
+                            },
+                        },
+                    },
+                ],
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            async getTopModels() {
+                const task = this.getNodeParameter('task', 'chat');
+                const budget = this.getNodeParameter('budget', 'balanced');
+                try {
+                    const credentials = await this.getCredentials('supabaseModelCatalogApi');
+                    const models = await fetchModelsWithBenchmarks(credentials.url, credentials.apiKey);
+                    const filters = {};
+                    const scoredModels = (0, modelScoring_1.scoreAndRankModels)(models, task, budget, filters, 5);
+                    const options = [
+                        {
+                            name: 'Default (Auto-Select Best)',
+                            value: 'default',
+                        },
+                    ];
+                    for (const model of scoredModels) {
+                        options.push({
+                            name: `${model.displayName}  |  Score: ${model.score}  |  $${model.pricing.promptPerMUsd.toFixed(2)} in / $${model.pricing.completionPerMUsd.toFixed(2)} out /M`,
+                            value: model.modelId,
+                        });
+                    }
+                    return options;
+                }
+                catch (error) {
+                    return [
+                        {
+                            name: 'Default (Auto-Select Best)',
+                            value: 'default',
+                        },
+                    ];
+                }
+            },
+        },
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        // Get OpenRouter credentials (always required)
+        const openRouterCredentials = await this.getCredentials('openRouterApi');
+        const apiKey = openRouterCredentials.apiKey;
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const operation = this.getNodeParameter('operation', itemIndex);
+                const options = this.getNodeParameter('options', itemIndex, {});
+                let result;
+                if (operation === 'chat') {
+                    // Simple chat completion with manual model
+                    const model = this.getNodeParameter('model', itemIndex);
+                    result = await executeChatCompletion(this, apiKey, model, itemIndex, options, items[itemIndex].json);
+                }
+                else if (operation === 'smartChat') {
+                    // Smart chat: select model + chat completion
+                    const { selectedModel, model } = await selectModel(this, itemIndex);
+                    const chatResult = await executeChatCompletion(this, apiKey, model, itemIndex, options, items[itemIndex].json);
+                    result = {
+                        ...chatResult,
+                        selectedModel: {
+                            modelId: selectedModel.modelId,
+                            displayName: selectedModel.displayName,
+                            score: selectedModel.score,
+                            reasoning: selectedModel.reasoning,
+                            pricing: selectedModel.pricing,
+                        },
+                    };
+                }
+                else if (operation === 'selectOnly') {
+                    // Only select model, no API call
+                    const { selectedModel, alternatives } = await selectModelWithAlternatives(this, itemIndex, options.alternativesCount);
+                    result = {
+                        recommended: selectedModel,
+                        alternatives,
+                    };
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex });
+                }
+                returnData.push({
+                    json: result,
+                    pairedItem: { item: itemIndex },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                            _input: items[itemIndex].json,
+                        },
+                        pairedItem: { item: itemIndex },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.OpenRouterSmartChat = OpenRouterSmartChat;
+// =============================================================================
+// Helper Functions
+// =============================================================================
+async function executeChatCompletion(context, apiKey, model, itemIndex, options, inputJson) {
+    const messagesCollection = context.getNodeParameter('messages', itemIndex);
+    const messages = (messagesCollection.messageValues || []).map((msg) => ({
+        role: msg.role,
+        content: msg.content,
+    }));
+    if (messages.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'At least one message is required', { itemIndex });
+    }
+    const body = {
+        model,
+        messages,
+    };
+    if (options.temperature !== undefined) {
+        body.temperature = options.temperature;
+    }
+    if (options.maxTokens !== undefined) {
+        body.max_tokens = options.maxTokens;
+    }
+    if (options.jsonMode) {
+        body.response_format = { type: 'json_object' };
+    }
+    if (options.topP !== undefined && options.topP !== 1) {
+        body.top_p = options.topP;
+    }
+    if (options.frequencyPenalty !== undefined && options.frequencyPenalty !== 0) {
+        body.frequency_penalty = options.frequencyPenalty;
+    }
+    if (options.presencePenalty !== undefined && options.presencePenalty !== 0) {
+        body.presence_penalty = options.presencePenalty;
+    }
+    const response = await context.helpers.httpRequest({
+        method: 'POST',
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'HTTP-Referer': 'https://n8n.io',
+            'X-Title': 'n8n OpenRouter Smart Chat',
+        },
+        body,
+        json: true,
+    });
+    if (response.error) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `OpenRouter API Error: ${response.error.message}`, { itemIndex });
+    }
+    const content = response.choices?.[0]?.message?.content || '';
+    return {
+        content,
+        model: response.model,
+        finishReason: response.choices?.[0]?.finish_reason,
+        usage: response.usage,
+        id: response.id,
+        _input: inputJson,
+    };
+}
+async function selectModel(context, itemIndex) {
+    const credentials = await context.getCredentials('supabaseModelCatalogApi');
+    const supabaseUrl = credentials.url;
+    const supabaseKey = credentials.apiKey;
+    const task = context.getNodeParameter('task', itemIndex);
+    const budget = context.getNodeParameter('budget', itemIndex);
+    const modelOverride = context.getNodeParameter('modelOverride', itemIndex, 'default');
+    const filtersRaw = context.getNodeParameter('filters', itemIndex, {});
+    const filters = {
+        minContextLength: filtersRaw.minContextLength ?? 8000,
+        requireJsonMode: filtersRaw.requireJsonMode ?? false,
+        requireVision: filtersRaw.requireVision ?? false,
+        maxCostPerK: filtersRaw.maxCostPerK || undefined,
+        providerWhitelist: filtersRaw.providerWhitelist && filtersRaw.providerWhitelist.length > 0
+            ? filtersRaw.providerWhitelist
+            : undefined,
+        providerBlacklist: filtersRaw.providerBlacklist && filtersRaw.providerBlacklist.length > 0
+            ? filtersRaw.providerBlacklist
+            : undefined,
+    };
+    const models = await fetchModelsWithBenchmarks(supabaseUrl, supabaseKey);
+    let selectedModel;
+    if (modelOverride !== 'default') {
+        const selected = models.find((m) => m.model.model === modelOverride);
+        if (!selected) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Model not found: ${modelOverride}`, { itemIndex });
+        }
+        selectedModel = (0, modelScoring_1.createManualSelection)(selected);
+    }
+    else {
+        const scoredModels = (0, modelScoring_1.scoreAndRankModels)(models, task, budget, filters, 1);
+        if (scoredModels.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'No models match the specified filters', { itemIndex });
+        }
+        selectedModel = scoredModels[0];
+    }
+    return {
+        selectedModel,
+        model: selectedModel.modelId,
+    };
+}
+async function selectModelWithAlternatives(context, itemIndex, alternativesCount) {
+    const credentials = await context.getCredentials('supabaseModelCatalogApi');
+    const supabaseUrl = credentials.url;
+    const supabaseKey = credentials.apiKey;
+    const task = context.getNodeParameter('task', itemIndex);
+    const budget = context.getNodeParameter('budget', itemIndex);
+    const modelOverride = context.getNodeParameter('modelOverride', itemIndex, 'default');
+    const filtersRaw = context.getNodeParameter('filters', itemIndex, {});
+    const filters = {
+        minContextLength: filtersRaw.minContextLength ?? 8000,
+        requireJsonMode: filtersRaw.requireJsonMode ?? false,
+        requireVision: filtersRaw.requireVision ?? false,
+        maxCostPerK: filtersRaw.maxCostPerK || undefined,
+        providerWhitelist: filtersRaw.providerWhitelist && filtersRaw.providerWhitelist.length > 0
+            ? filtersRaw.providerWhitelist
+            : undefined,
+        providerBlacklist: filtersRaw.providerBlacklist && filtersRaw.providerBlacklist.length > 0
+            ? filtersRaw.providerBlacklist
+            : undefined,
+    };
+    const models = await fetchModelsWithBenchmarks(supabaseUrl, supabaseKey);
+    const topN = 1 + (alternativesCount ?? types_1.DEFAULT_ALTERNATIVES);
+    if (modelOverride !== 'default') {
+        const selected = models.find((m) => m.model.model === modelOverride);
+        if (!selected) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Model not found: ${modelOverride}`, { itemIndex });
+        }
+        return {
+            selectedModel: (0, modelScoring_1.createManualSelection)(selected),
+            alternatives: [],
+        };
+    }
+    const scoredModels = (0, modelScoring_1.scoreAndRankModels)(models, task, budget, filters, topN);
+    if (scoredModels.length === 0) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'No models match the specified filters', { itemIndex });
+    }
+    const [selectedModel, ...alternatives] = scoredModels;
+    return { selectedModel, alternatives };
+}
+async function fetchModelsWithBenchmarks(supabaseUrl, supabaseKey) {
+    const modelsResponse = await fetch(`${supabaseUrl}/rest/v1/models_catalog?select=*`, {
+        headers: {
+            apikey: supabaseKey,
+            Authorization: `Bearer ${supabaseKey}`,
+        },
+    });
+    if (!modelsResponse.ok) {
+        throw new Error(`Failed to fetch models: ${modelsResponse.statusText}`);
+    }
+    const models = (await modelsResponse.json());
+    const benchmarksResponse = await fetch(`${supabaseUrl}/rest/v1/model_benchmarks?select=*`, {
+        headers: {
+            apikey: supabaseKey,
+            Authorization: `Bearer ${supabaseKey}`,
+        },
+    });
+    let benchmarks = [];
+    if (benchmarksResponse.ok) {
+        benchmarks = (await benchmarksResponse.json());
+    }
+    const mappingsResponse = await fetch(`${supabaseUrl}/rest/v1/model_name_mappings?select=*`, {
+        headers: {
+            apikey: supabaseKey,
+            Authorization: `Bearer ${supabaseKey}`,
+        },
+    });
+    let mappings = [];
+    if (mappingsResponse.ok) {
+        mappings = (await mappingsResponse.json());
+    }
+    const benchmarkMap = new Map(benchmarks.map((b) => [b.openrouter_id, b]));
+    const mappingMap = new Map(mappings.map((m) => [m.openrouter_id, m]));
+    return models.map((model) => ({
+        model,
+        benchmarks: benchmarkMap.get(model.model) ?? null,
+        mapping: mappingMap.get(model.model) ?? null,
+    }));
+}
+//# sourceMappingURL=OpenRouterSmartChat.node.js.map