n8n-nodes-coding-stream 0.1.6 → 0.1.7

package/dist/nodes/CodingStreamChatModel/CodingStreamChatModel.node.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodingStreamChatModel = void 0;
+const N8nModelTracing_1 = require("./N8nModelTracing");
+const reasoningFallback_1 = require("./reasoningFallback");
 const openai_1 = require("@langchain/openai");
 const n8n_workflow_1 = require("n8n-workflow");
 class CodingStreamChatModel {
@@ -22,10 +24,10 @@ class CodingStreamChatModel {
                     name: 'baseURL',
                     type: 'string',
                     required: true,
-                    default: 'https://external-ai-gateway.sovcombank.group/llm/v1',
+                    default: '',
                     description: 'Base URL that ends in /v1 (the SDK adds /chat/completions)',
                 },
-                { displayName: 'Model', name: 'model', type: 'string', required: true, default: 'coding-ultima' },
+                { displayName: 'Model', name: 'model', type: 'string', required: true, default: '' },
                 {
                     displayName: 'Bearer Token',
                     name: 'bearerToken',
@@ -104,6 +106,7 @@ class CodingStreamChatModel {
             configuration: {
                 baseURL,
                 defaultHeaders: { 'X-Request-By': requestBy },
+                fetch: (0, reasoningFallback_1.createReasoningFallbackFetch)(),
             },
             temperature: options.temperature ?? 0.3,
             ...(options.maxTokens != null ? { maxTokens: Number(options.maxTokens) } : {}),
@@ -113,7 +116,7 @@ class CodingStreamChatModel {
             timeout: options.timeout ?? 120000,
             maxRetries: 0,
             supportsStrictToolCalling: false,
-            callbacks: [],
+            callbacks: [new N8nModelTracing_1.N8nModelTracing(this)],
         });
         return { response: model };
     }

package/dist/nodes/CodingStreamChatModel/N8nModelTracing.d.ts

@@ -0,0 +1,17 @@
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { LLMResult } from '@langchain/core/outputs';
+import { type ISupplyDataFunctions } from 'n8n-workflow';
+export declare class N8nModelTracing extends BaseCallbackHandler {
+    private context;
+    name: string;
+    awaitHandlers: boolean;
+    private runs;
+    private connection;
+    constructor(context: ISupplyDataFunctions);
+    private recordInput;
+    handleChatModelStart(_model: unknown, messages: BaseMessage[][], runId: string): void;
+    handleLLMStart(_model: unknown, prompts: string[], runId: string): void;
+    handleLLMEnd(output: LLMResult, runId: string): void;
+    handleLLMError(error: Error, runId: string): void;
+}

package/dist/nodes/CodingStreamChatModel/N8nModelTracing.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nModelTracing = void 0;
+const base_1 = require("@langchain/core/callbacks/base");
+const n8n_workflow_1 = require("n8n-workflow");
+class N8nModelTracing extends base_1.BaseCallbackHandler {
+    constructor(context) {
+        super();
+        this.context = context;
+        this.name = 'N8nModelTracing';
+        this.awaitHandlers = true;
+        this.runs = new Map();
+        this.connection = n8n_workflow_1.NodeConnectionTypes.AiLanguageModel;
+    }
+    recordInput(runId, messages) {
+        const { index } = this.context.addInputData(this.connection, [[{
+                    json: {
+                        messages: JSON.parse(JSON.stringify(messages)),
+                    },
+                }]]);
+        this.runs.set(runId, index);
+    }
+    handleChatModelStart(_model, messages, runId) {
+        this.recordInput(runId, messages);
+    }
+    handleLLMStart(_model, prompts, runId) {
+        this.recordInput(runId, prompts);
+    }
+    handleLLMEnd(output, runId) {
+        const index = this.runs.get(runId);
+        if (index === undefined)
+            return;
+        const generations = output.generations.map(group => group.map(generation => ({
+            text: generation.text,
+            message: 'message' in generation
+                ? JSON.parse(JSON.stringify(generation.message))
+                : undefined,
+            generationInfo: generation.generationInfo,
+        })));
+        const usage = output.llmOutput?.tokenUsage
+            ?? output.generations[0]?.[0]?.message?.usage_metadata;
+        this.context.addOutputData(this.connection, index, [[{
+                    json: {
+                        response: { generations },
+                        ...(usage ? { tokenUsage: usage } : {}),
+                    },
+                }]]);
+        this.runs.delete(runId);
+    }
+    handleLLMError(error, runId) {
+        const index = this.runs.get(runId);
+        if (index === undefined)
+            return;
+        this.context.addOutputData(this.connection, index, new n8n_workflow_1.NodeOperationError(this.context.getNode(), error));
+        this.runs.delete(runId);
+    }
+}
+exports.N8nModelTracing = N8nModelTracing;

package/dist/nodes/CodingStreamChatModel/reasoningFallback.d.ts

@@ -0,0 +1 @@
+export declare function createReasoningFallbackFetch(): typeof fetch;

package/dist/nodes/CodingStreamChatModel/reasoningFallback.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReasoningFallbackFetch = createReasoningFallbackFetch;
+const MARKER = ' response';
+function extractAnswer(reasoning) {
+    const position = reasoning.indexOf(MARKER);
+    if (position === -1)
+        return '';
+    return reasoning.slice(position + MARKER.length).trimStart();
+}
+function hasContent(content) {
+    if (typeof content === 'string')
+        return content.length > 0;
+    if (Array.isArray(content))
+        return content.length > 0;
+    return content != null;
+}
+function hasToolCalls(message) {
+    return Boolean((Array.isArray(message.tool_calls) && message.tool_calls.length) ||
+        message.function_call);
+}
+function rewriteCompletion(data) {
+    for (const choice of data.choices ?? []) {
+        const message = choice.message;
+        if (!message || hasContent(message.content))
+            continue;
+        if (choice.finish_reason === 'tool_calls')
+            continue;
+        if (hasToolCalls(message))
+            continue;
+        const reasoning = message.reasoning_content;
+        if (typeof reasoning !== 'string')
+            continue;
+        const answer = extractAnswer(reasoning);
+        if (answer)
+            message.content = answer;
+    }
+    return data;
+}
+function rewriteEventStream(body) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const states = new Map();
+    let buffer = '';
+    const getState = (index) => {
+        let state = states.get(index);
+        if (!state) {
+            state = {
+                reasoning: '',
+                contentSeen: false,
+                toolsSeen: false,
+                finished: false,
+            };
+            states.set(index, state);
+        }
+        return state;
+    };
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            buffer = buffer.replace(/\r\n/g, '\n');
+            const send = (value) => {
+                controller.enqueue(encoder.encode(value));
+            };
+            const sendFallback = (index, state) => {
+                if (state.finished)
+                    return;
+                state.finished = true;
+                if (state.contentSeen || state.toolsSeen || !state.template)
+                    return;
+                const answer = extractAnswer(state.reasoning);
+                if (!answer)
+                    return;
+                const fallback = {
+                    ...state.template,
+                    choices: [{
+                            index,
+                            delta: { content: answer },
+                            finish_reason: null,
+                        }],
+                };
+                send(`data: ${JSON.stringify(fallback)}\n\n`);
+            };
+            let separator;
+            while ((separator = buffer.indexOf('\n\n')) !== -1) {
+                const event = buffer.slice(0, separator);
+                buffer = buffer.slice(separator + 2);
+                const dataLines = event.split('\n')
+                    .filter(line => line.startsWith('data:'))
+                    .map(line => line.slice(5).trimStart());
+                if (dataLines.length === 0) {
+                    send(`${event}\n\n`);
+                    continue;
+                }
+                const payload = dataLines.join('\n');
+                if (payload === '[DONE]') {
+                    for (const [index, state] of states) {
+                        sendFallback(index, state);
+                    }
+                    send(`${event}\n\n`);
+                    continue;
+                }
+                let parsed;
+                try {
+                    parsed = JSON.parse(payload);
+                }
+                catch {
+                    send(`${event}\n\n`);
+                    continue;
+                }
+                for (const choice of parsed.choices ?? []) {
+                    const index = choice.index ?? 0;
+                    const state = getState(index);
+                    const delta = choice.delta ?? {};
+                    state.template = parsed;
+                    if (hasContent(delta.content)) {
+                        state.contentSeen = true;
+                    }
+                    if (typeof delta.reasoning_content === 'string') {
+                        state.reasoning += delta.reasoning_content;
+                    }
+                    if (hasToolCalls(delta) || choice.finish_reason === 'tool_calls') {
+                        state.toolsSeen = true;
+                    }
+                    if (choice.finish_reason != null) {
+                        sendFallback(index, state);
+                    }
+                }
+                // Keep the original SSE event unchanged.
+                send(`${event}\n\n`);
+            }
+        },
+        flush(controller) {
+            buffer += decoder.decode();
+            if (buffer) {
+                controller.enqueue(encoder.encode(buffer));
+            }
+        },
+    }));
+}
+function createReasoningFallbackFetch() {
+    return async (input, init) => {
+        const response = await fetch(input, init);
+        if (!response.ok)
+            return response;
+        const contentType = response.headers.get('content-type') ?? '';
+        const headers = new Headers(response.headers);
+        headers.delete('content-length');
+        headers.delete('content-encoding');
+        if (contentType.includes('text/event-stream') && response.body) {
+            return new Response(rewriteEventStream(response.body), {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            });
+        }
+        if (!contentType.includes('application/json'))
+            return response;
+        const text = await response.text();
+        try {
+            const data = JSON.parse(text);
+            return new Response(JSON.stringify(rewriteCompletion(data)), {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            });
+        }
+        catch {
+            return new Response(text, {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            });
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-coding-stream",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "private": false,
   "description": "OpenAI-compatible n8n Chat Model with native SSE streaming and dynamic Bearer + X-Request-By",
   "license": "MIT",
@@ -27,6 +27,7 @@
     ]
   },
   "dependencies": {
+    "@langchain/core": "^1.2.18",
     "@langchain/openai": "^1.4.6"
   },
   "devDependencies": {