@drx974/n8n-nodes-deepseek-fixed 0.1.0

package/README.md

@@ -0,0 +1,68 @@
+# n8n-nodes-deepseek-fixed-romy
+
+Nœud DeepSeek Chat Model "maison" pour l'AI Agent n8n. Corrige les deux bugs
+documentés qui cassent le Tool Calling avec DeepSeek dans n8n :
+
+1. **Rejet du schéma `strict`** : DeepSeek renvoie une erreur 400
+   ("Required properties must match...") quand n8n envoie `strict: true`
+   dans la définition JSON Schema des tools. Ce nœud ne transmet jamais ce
+   flag, quel que soit ce que l'AI Agent essaie de passer.
+
+2. **`reasoning_content` non renvoyé** : en Thinking Mode, DeepSeek exige que
+   le `reasoning_content` du tour précédent soit renvoyé tel quel dès que ce
+   tour contenait des tool_calls, sinon 400 ("The reasoning_content in the
+   thinking mode must be passed back to the API"). Ce nœud stocke ce champ
+   sur chaque message assistant et le réinjecte automatiquement au tour
+   suivant — Thinking Mode reste utilisable même avec des tools.
+
+Par défaut, Thinking Mode est **désactivé** (le plus sûr avec Tool Calling) ;
+vous pouvez l'activer (`high` / `max`) si vous voulez le raisonnement
+chain-of-thought sur cet agent.
+
+## Build
+
+```bash
+npm install
+npm run build
+```
+
+## Déploiement recommandé (le plus sûr, évite l'incident déjà rencontré)
+
+Ne PAS faire `npm install` à la main dans le container n8n (ça duplique les
+dépendances et peut casser le chargement des nodes, comme déjà vécu).
+
+**Méthode recommandée : publier sur npm puis installer via l'UI n8n**
+
+```bash
+npm login                # une fois, avec un compte npm (peut être le vôtre)
+npm publish --access public
+```
+
+Puis, dans n8n : **Settings → Community Nodes → Install**, coller le nom du
+package `n8n-nodes-deepseek-fixed-romy`, cocher la case de risque, Install,
+puis **redémarrer le container n8n** (obligatoire pour que le node se charge,
+surtout en mode queue).
+
+Si vous préférez ne pas publier publiquement, publiez sous un nom scope privé
+(`@votre-compte/n8n-nodes-deepseek-fixed`) avec un compte npm payant "private
+package", ou utilisez un registre npm privé si vous en avez un (Verdaccio,
+GitHub Packages, etc.) — le flux d'installation via l'UI reste identique.
+
+## Utilisation dans l'AI Agent
+
+1. Ajouter le nœud **DeepSeek Chat Model (Fixed)**
+2. Credential : coller votre clé API DeepSeek (`DeepSeek Fixed API`)
+3. Le connecter à l'entrée "Chat Model" de l'AI Agent
+4. Laisser **Thinking Mode = Disabled** pour du Tool Calling simple, ou
+   passer à `high`/`max` si vous voulez le raisonnement — les deux
+   fonctionnent avec les tools.
+5. Connecter vos tools comme d'habitude.
+
+## Limites connues
+
+- Pas de support du streaming token-par-token (`_generate` uniquement,
+  pas de `_streamResponseChunks`) — suffisant pour l'usage AI Agent classique,
+  mais à garder en tête si vous branchez ça sur un chat en streaming.
+- Testé par compilation TypeScript stricte contre `@langchain/core@1.2.2` et
+  `n8n-workflow@2.16.0` (versions au 10/07/2026) — à revalider si n8n monte
+  une version majeure différente de LangChain en interne.

package/dist/credentials/DeepSeekFixedApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class DeepSeekFixedApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/DeepSeekFixedApi.credentials.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepSeekFixedApi = void 0;
+class DeepSeekFixedApi {
+    constructor() {
+        this.name = 'deepSeekFixedApi';
+        this.displayName = 'DeepSeek Fixed API';
+        this.documentationUrl = 'https://api-docs.deepseek.com/';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://api.deepseek.com',
+                description: 'Override if you proxy DeepSeek through your own endpoint',
+            },
+        ];
+    }
+}
+exports.DeepSeekFixedApi = DeepSeekFixedApi;

package/dist/nodes/LmChatDeepSeekFixed/ChatDeepSeekFixed.d.ts

@@ -0,0 +1,56 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { BaseChatModelParams, BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ChatResult } from '@langchain/core/outputs';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+export type ThinkingMode = 'disabled' | 'high' | 'max';
+export interface ChatDeepSeekFixedParams extends BaseChatModelParams {
+    apiKey: string;
+    baseURL?: string;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    thinkingMode?: ThinkingMode;
+    timeout?: number;
+}
+/**
+ * Minimal, self-contained LangChain ChatModel for DeepSeek that fixes the two
+ * documented n8n / DeepSeek incompatibilities when used behind the AI Agent node:
+ *
+ *  1. DeepSeek rejects tool definitions carrying `"strict": true` in the JSON
+ *     schema (400 "Required properties must match..."). We never emit `strict`.
+ *
+ *  2. In Thinking Mode, DeepSeek requires the `reasoning_content` of a prior
+ *     assistant turn to be echoed back once that turn included tool_calls,
+ *     otherwise it 400s with "The reasoning_content in the thinking mode must
+ *     be passed back to the API." We stash it on additional_kwargs and replay
+ *     it automatically on the next turn.
+ *
+ * Thinking Mode defaults to "disabled", which sidesteps rule 2 entirely and is
+ * the recommended setting whenever the model is wired into an AI Agent with
+ * tools. Set it to "high"/"max" if you need chain-of-thought and are fine with
+ * the extra latency/token cost — rule 2's handling keeps tool calls working
+ * either way.
+ */
+export declare class ChatDeepSeekFixed extends BaseChatModel {
+    apiKey: string;
+    baseURL: string;
+    modelName: string;
+    temperature?: number;
+    maxTokens?: number;
+    thinkingMode: ThinkingMode;
+    timeout: number;
+    private client;
+    private boundTools;
+    constructor(fields: ChatDeepSeekFixedParams);
+    _llmType(): string;
+    /**
+     * Fix #1: convert tools without ever passing a `strict` flag through, no
+     * matter what the caller (n8n's AI Agent) asks for. `convertToOpenAITool`
+     * only sets `strict` when explicitly told to, so simply not forwarding it
+     * here is enough to keep it out of the wire payload.
+     */
+    bindTools(tools: BindToolsInput[], _kwargs?: Record<string, unknown>): ReturnType<NonNullable<BaseChatModel['bindTools']>>;
+    private toOpenAIMessages;
+    _generate(messages: BaseMessage[], _options: this['ParsedCallOptions'], _runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+}

package/dist/nodes/LmChatDeepSeekFixed/ChatDeepSeekFixed.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatDeepSeekFixed = void 0;
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const messages_1 = require("@langchain/core/messages");
+const function_calling_1 = require("@langchain/core/utils/function_calling");
+const openai_1 = __importDefault(require("openai"));
+/**
+ * Minimal, self-contained LangChain ChatModel for DeepSeek that fixes the two
+ * documented n8n / DeepSeek incompatibilities when used behind the AI Agent node:
+ *
+ *  1. DeepSeek rejects tool definitions carrying `"strict": true` in the JSON
+ *     schema (400 "Required properties must match..."). We never emit `strict`.
+ *
+ *  2. In Thinking Mode, DeepSeek requires the `reasoning_content` of a prior
+ *     assistant turn to be echoed back once that turn included tool_calls,
+ *     otherwise it 400s with "The reasoning_content in the thinking mode must
+ *     be passed back to the API." We stash it on additional_kwargs and replay
+ *     it automatically on the next turn.
+ *
+ * Thinking Mode defaults to "disabled", which sidesteps rule 2 entirely and is
+ * the recommended setting whenever the model is wired into an AI Agent with
+ * tools. Set it to "high"/"max" if you need chain-of-thought and are fine with
+ * the extra latency/token cost — rule 2's handling keeps tool calls working
+ * either way.
+ */
+class ChatDeepSeekFixed extends chat_models_1.BaseChatModel {
+    constructor(fields) {
+        super(fields);
+        this.boundTools = [];
+        this.apiKey = fields.apiKey;
+        this.baseURL = fields.baseURL ?? 'https://api.deepseek.com';
+        this.modelName = fields.model;
+        this.temperature = fields.temperature;
+        this.maxTokens = fields.maxTokens;
+        this.thinkingMode = fields.thinkingMode ?? 'disabled';
+        this.timeout = fields.timeout ?? 60000;
+        this.client = new openai_1.default({
+            apiKey: this.apiKey,
+            baseURL: this.baseURL,
+            timeout: this.timeout,
+        });
+    }
+    _llmType() {
+        return 'deepseek-fixed';
+    }
+    /**
+     * Fix #1: convert tools without ever passing a `strict` flag through, no
+     * matter what the caller (n8n's AI Agent) asks for. `convertToOpenAITool`
+     * only sets `strict` when explicitly told to, so simply not forwarding it
+     * here is enough to keep it out of the wire payload.
+     */
+    bindTools(tools, _kwargs) {
+        this.boundTools = tools.map((tool) => (0, function_calling_1.convertToOpenAITool)(tool));
+        // n8n's AI Agent supplies a fresh model instance per execution via
+        // supplyData(), so mutating in place and returning `this` is safe here
+        // and avoids depending on Runnable.bind(), which this LangChain version
+        // no longer exposes on BaseChatModel.
+        return this;
+    }
+    toOpenAIMessages(messages) {
+        return messages.map((message) => {
+            const type = message._getType();
+            if (type === 'human') {
+                return { role: 'user', content: message.content };
+            }
+            if (type === 'system') {
+                return { role: 'system', content: message.content };
+            }
+            if (type === 'tool') {
+                const toolMessage = message;
+                return {
+                    role: 'tool',
+                    tool_call_id: toolMessage.tool_call_id,
+                    content: toolMessage.content,
+                };
+            }
+            // assistant / ai turn
+            const aiMessage = message;
+            const toolCalls = aiMessage.tool_calls && aiMessage.tool_calls.length > 0
+                ? aiMessage.tool_calls.map((toolCall) => ({
+                    id: toolCall.id ?? '',
+                    type: 'function',
+                    function: {
+                        name: toolCall.name,
+                        arguments: JSON.stringify(toolCall.args ?? {}),
+                    },
+                }))
+                : undefined;
+            // Fix #2: replay reasoning_content we stashed from DeepSeek's previous
+            // response, only relevant when Thinking Mode is active.
+            const storedReasoning = aiMessage.additional_kwargs?.reasoning_content;
+            const extra = this.thinkingMode !== 'disabled' && storedReasoning
+                ? { reasoning_content: storedReasoning }
+                : {};
+            return {
+                role: 'assistant',
+                content: aiMessage.content ?? '',
+                ...(toolCalls ? { tool_calls: toolCalls } : {}),
+                ...extra,
+            };
+        });
+    }
+    async _generate(messages, _options, _runManager) {
+        const openAIMessages = this.toOpenAIMessages(messages);
+        const body = {
+            model: this.modelName,
+            messages: openAIMessages,
+            max_tokens: this.maxTokens,
+        };
+        // DeepSeek ignores temperature/top_p/penalties in Thinking Mode (silently,
+        // no error) — omit it in that case to avoid misleading configuration.
+        if (this.thinkingMode === 'disabled') {
+            body.temperature = this.temperature;
+        }
+        if (this.boundTools.length > 0) {
+            body.tools = this.boundTools;
+        }
+        if (this.thinkingMode !== 'disabled') {
+            body.extra_body = {
+                thinking: { type: 'enabled' },
+                ...(this.thinkingMode === 'max' ? { reasoning_effort: 'max' } : {}),
+            };
+        }
+        const completion = await this.client.chat.completions.create(body);
+        const choice = completion.choices[0];
+        const rawMessage = choice.message;
+        const toolCalls = (rawMessage.tool_calls ?? [])
+            .filter((toolCall) => 'function' in toolCall)
+            .map((toolCall) => {
+            let args = {};
+            try {
+                args = JSON.parse(toolCall.function.arguments || '{}');
+            }
+            catch {
+                args = {};
+            }
+            return {
+                id: toolCall.id,
+                name: toolCall.function.name,
+                args,
+                type: 'tool_call',
+            };
+        });
+        const aiMessage = new messages_1.AIMessage({
+            content: rawMessage.content ?? '',
+            tool_calls: toolCalls,
+            additional_kwargs: rawMessage.reasoning_content
+                ? { reasoning_content: rawMessage.reasoning_content }
+                : {},
+        });
+        const generation = {
+            text: rawMessage.content ?? '',
+            message: aiMessage,
+        };
+        return { generations: [generation] };
+    }
+}
+exports.ChatDeepSeekFixed = ChatDeepSeekFixed;

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

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

package/dist/nodes/LmChatDeepSeekFixed/LmChatDeepSeekFixed.node.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LmChatDeepSeekFixed = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ChatDeepSeekFixed_1 = require("./ChatDeepSeekFixed");
+class LmChatDeepSeekFixed {
+    constructor() {
+        this.description = {
+            displayName: 'DeepSeek Chat Model (Fixed)',
+            name: 'lmChatDeepSeekFixed',
+            icon: 'fa:comment',
+            iconColor: 'black',
+            group: ['transform'],
+            version: 1,
+            description: 'DeepSeek chat model for the AI Agent — fixes the strict tool-schema rejection and the reasoning_content passback error',
+            defaults: {
+                name: 'DeepSeek Chat Model (Fixed)',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Language Models'],
+                },
+            },
+            // eslint-disable-next-line n8n-nodes-base/node-class-description-inputs-wrong-regular-node
+            inputs: [],
+            // eslint-disable-next-line n8n-nodes-base/node-class-description-outputs-wrong
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
+            outputNames: ['Model'],
+            credentials: [
+                {
+                    name: 'deepSeekFixedApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'string',
+                    default: 'deepseek-v4-flash',
+                    description: 'e.g. deepseek-v4-flash, deepseek-v4-pro',
+                },
+                {
+                    displayName: 'Thinking Mode',
+                    name: 'thinkingMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Disabled (Recommended With Tool Calling)', value: 'disabled' },
+                        { name: 'Enabled — High Effort', value: 'high' },
+                        { name: 'Enabled — Max Effort', value: 'max' },
+                    ],
+                    default: 'disabled',
+                    description: 'When enabled, reasoning_content is tracked and replayed automatically so tool calling keeps working',
+                },
+                {
+                    displayName: 'Temperature',
+                    name: 'temperature',
+                    type: 'number',
+                    default: 0.7,
+                    typeOptions: { minValue: 0, maxValue: 2, numberPrecision: 2 },
+                    description: 'Ignored by DeepSeek whenever Thinking Mode is enabled',
+                },
+                {
+                    displayName: 'Max Tokens',
+                    name: 'maxTokens',
+                    type: 'number',
+                    default: 2048,
+                },
+                {
+                    displayName: 'Timeout (ms)',
+                    name: 'timeout',
+                    type: 'number',
+                    default: 60000,
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const credentials = await this.getCredentials('deepSeekFixedApi');
+        const model = this.getNodeParameter('model', itemIndex);
+        const thinkingMode = this.getNodeParameter('thinkingMode', itemIndex);
+        const temperature = this.getNodeParameter('temperature', itemIndex);
+        const maxTokens = this.getNodeParameter('maxTokens', itemIndex);
+        const timeout = this.getNodeParameter('timeout', itemIndex);
+        const chatModel = new ChatDeepSeekFixed_1.ChatDeepSeekFixed({
+            apiKey: credentials.apiKey,
+            baseURL: credentials.baseUrl || 'https://api.deepseek.com',
+            model,
+            thinkingMode,
+            temperature,
+            maxTokens,
+            timeout,
+        });
+        return { response: chatModel };
+    }
+}
+exports.LmChatDeepSeekFixed = LmChatDeepSeekFixed;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@drx974/n8n-nodes-deepseek-fixed",
+  "version": "0.1.0",
+  "description": "DeepSeek Chat Model for n8n AI Agent — fixes strict tool-schema rejection and reasoning_content passback",
+  "keywords": [
+    "n8n-community-node-package"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/nodes/LmChatDeepSeekFixed/LmChatDeepSeekFixed.node.js",
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/DeepSeekFixedApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/LmChatDeepSeekFixed/LmChatDeepSeekFixed.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "peerDependencies": {
+    "@langchain/core": "*"
+  },
+  "dependencies": {
+    "openai": "^6.46.0"
+  },
+  "devDependencies": {
+    "@langchain/core": "^1.2.2",
+    "@types/node": "^24.0.0",
+    "n8n-workflow": "^2.16.0",
+    "typescript": "^5.9.3"
+  }
+}