n8n-nodes-dopomogai 0.1.0

package/README.md

@@ -0,0 +1,28 @@
+# n8n-nodes-dopomogai
+
+Community nodes for DopomogAI.
+
+## Base URL
+Use:
+- `https://api.dopomogai.com`
+
+The node will call:
+- `${apiBaseUrl}/api/v1/...`
+
+## Auth
+Use an API key (`pk_...` or `sk_...`) via:
+- `Authorization: Bearer <key>` (default)
+or
+- `X-API-Key: <key>`
+
+## Included
+- Agents CRUD
+- Conversations management
+- Chat (blocking, SSE internally)
+- Files upload + metadata
+
+## Dev
+```bash
+npm i
+npm run build
+```

package/dist/credentials/DopomogaiApiKey.credentials.d.ts

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

package/dist/credentials/DopomogaiApiKey.credentials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DopomogaiApiKey = void 0;
+class DopomogaiApiKey {
+    name = 'dopomogaiApiKey';
+    displayName = 'DopomogAI API Key';
+    documentationUrl = 'https://api.dopomogai.com/api/docs';
+    properties = [
+        {
+            displayName: 'API Base URL',
+            name: 'apiBaseUrl',
+            type: 'string',
+            default: 'https://api.dopomogai.com',
+            placeholder: 'https://api.dopomogai.com',
+            required: true,
+            description: 'Base URL of DopomogAI API (no trailing slash).',
+        },
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            description: 'Your DopomogAI API key (pk_... or sk_...).',
+        },
+        {
+            displayName: 'Send API Key As',
+            name: 'sendAs',
+            type: 'options',
+            default: 'authorizationBearer',
+            options: [
+                { name: 'Authorization: Bearer <key>', value: 'authorizationBearer' },
+                { name: 'X-API-Key: <key>', value: 'xApiKey' },
+            ],
+        },
+    ];
+}
+exports.DopomogaiApiKey = DopomogaiApiKey;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,18 @@
+"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/Dopomogai/Dopomogai.node"), exports);
+__exportStar(require("./credentials/DopomogaiApiKey.credentials"), exports);

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

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Dopomogai implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Dopomogai/Dopomogai.node.js

@@ -0,0 +1,496 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dopomogai = void 0;
+const http_1 = require("./helpers/http");
+const sse_1 = require("./helpers/sse");
+class Dopomogai {
+    description = {
+        displayName: 'DopomogAI',
+        name: 'dopomogai',
+        icon: 'file:dopomogai.svg',
+        group: ['transform'],
+        version: 1,
+        description: 'Interact with DopomogAI backend (Agents, Conversations, Chat, Files).',
+        defaults: { name: 'DopomogAI' },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [{ name: 'dopomogaiApiKey', required: true }],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                default: 'agents',
+                options: [
+                    { name: 'Agents', value: 'agents' },
+                    { name: 'Conversations', value: 'conversations' },
+                    { name: 'Chat', value: 'chat' },
+                    { name: 'Files', value: 'files' },
+                ],
+            },
+            // -------------------- Agents --------------------
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                default: 'list',
+                displayOptions: { show: { resource: ['agents'] } },
+                options: [
+                    { name: 'List', value: 'list' },
+                    { name: 'Create', value: 'create' },
+                    { name: 'Get', value: 'get' },
+                    { name: 'Update', value: 'update' },
+                    { name: 'Delete', value: 'delete' },
+                ],
+            },
+            {
+                displayName: 'Agent ID',
+                name: 'agentId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['agents'], operation: ['get', 'update', 'delete'] } },
+            },
+            {
+                displayName: 'Name',
+                name: 'agentName',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['agents'], operation: ['create'] } },
+                required: true,
+            },
+            {
+                displayName: 'LLM Model',
+                name: 'llmModel',
+                type: 'string',
+                default: 'openrouter:openai/gpt-4o',
+                displayOptions: { show: { resource: ['agents'], operation: ['create'] } },
+                required: true,
+            },
+            {
+                displayName: 'Description',
+                name: 'agentDescription',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['agents'], operation: ['create', 'update'] } },
+            },
+            {
+                displayName: 'Is Public',
+                name: 'agentIsPublic',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['agents'], operation: ['create', 'update'] } },
+            },
+            {
+                displayName: 'Agent Settings (JSON)',
+                name: 'agentSettingsJson',
+                type: 'string',
+                default: '{}',
+                description: 'JSON for agent_settings. For update we replace/merge in backend depending on your API behavior.',
+                displayOptions: { show: { resource: ['agents'], operation: ['create', 'update'] } },
+            },
+            // -------------------- Conversations --------------------
+            {
+                displayName: 'Operation',
+                name: 'conversationOperation',
+                type: 'options',
+                noDataExpression: true,
+                default: 'list',
+                displayOptions: { show: { resource: ['conversations'] } },
+                options: [
+                    { name: 'List', value: 'list' },
+                    { name: 'Get', value: 'get' },
+                    { name: 'Rename', value: 'rename' },
+                    { name: 'Delete', value: 'delete' },
+                ],
+            },
+            {
+                displayName: 'Conversation ID',
+                name: 'conversationId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['conversations'], conversationOperation: ['get', 'rename', 'delete'] } },
+                required: true,
+            },
+            {
+                displayName: 'Title',
+                name: 'conversationTitle',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['conversations'], conversationOperation: ['rename'] } },
+                required: true,
+            },
+            {
+                displayName: 'List Options',
+                name: 'conversationListOptions',
+                type: 'collection',
+                placeholder: 'Add option',
+                default: {},
+                displayOptions: { show: { resource: ['conversations'], conversationOperation: ['list'] } },
+                options: [
+                    { displayName: 'Limit', name: 'limit', type: 'number', default: 20 },
+                    { displayName: 'Offset', name: 'offset', type: 'number', default: 0 },
+                    { displayName: 'Agent ID', name: 'agent_id', type: 'string', default: '' },
+                    { displayName: 'Search Query', name: 'search_query', type: 'string', default: '' },
+                    { displayName: 'Sort By', name: 'sort_by', type: 'string', default: 'updated_at' },
+                    { displayName: 'Sort Order', name: 'sort_order', type: 'options', default: 'desc', options: [
+                            { name: 'Desc', value: 'desc' },
+                            { name: 'Asc', value: 'asc' },
+                        ] },
+                ],
+            },
+            // -------------------- Chat --------------------
+            {
+                displayName: 'Operation',
+                name: 'chatOperation',
+                type: 'options',
+                noDataExpression: true,
+                default: 'chatBlocking',
+                displayOptions: { show: { resource: ['chat'] } },
+                options: [
+                    { name: 'Chat (Blocking)', value: 'chatBlocking' },
+                ],
+            },
+            {
+                displayName: 'Agent ID',
+                name: 'chatAgentId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+                required: true,
+                description: 'Agent UUID',
+            },
+            {
+                displayName: 'Conversation ID',
+                name: 'chatConversationId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+                description: 'Optional. If omitted, backend will create one and return it via X-Conversation-Id.',
+            },
+            {
+                displayName: 'User Message',
+                name: 'chatUserMessage',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+                description: 'Text message to send to the agent.',
+            },
+            {
+                displayName: 'Initial Context',
+                name: 'chatInitialContext',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+            },
+            {
+                displayName: 'Turn Prompt Override',
+                name: 'chatTurnPromptOverride',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+            },
+            {
+                displayName: 'Parts (JSON)',
+                name: 'chatPartsJson',
+                type: 'string',
+                default: '[]',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+                description: 'Optional parts array JSON (ConversationMessagePartInput). Example: [{"type":"file","file_id":"...","media_type":"application/pdf"}]',
+            },
+            {
+                displayName: 'Run Overrides (JSON)',
+                name: 'chatRunOverridesJson',
+                type: 'string',
+                default: '{}',
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+                description: 'Optional run_overrides JSON.',
+            },
+            {
+                displayName: 'Return Full Event Log',
+                name: 'chatReturnEvents',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['chat'], chatOperation: ['chatBlocking'] } },
+            },
+            // -------------------- Files --------------------
+            {
+                displayName: 'Operation',
+                name: 'fileOperation',
+                type: 'options',
+                noDataExpression: true,
+                default: 'upload',
+                displayOptions: { show: { resource: ['files'] } },
+                options: [
+                    { name: 'Upload', value: 'upload' },
+                    { name: 'Get Metadata', value: 'getMetadata' },
+                ],
+            },
+            {
+                displayName: 'Binary Property',
+                name: 'binaryProperty',
+                type: 'string',
+                default: 'data',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['upload'] } },
+                description: 'Name of the binary property on the incoming item (default: data).',
+            },
+            {
+                displayName: 'Purpose',
+                name: 'filePurpose',
+                type: 'string',
+                default: 'agent_input',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['upload'] } },
+                description: 'E.g. agent_input, knowledge_source, user_upload, general, ...',
+            },
+            {
+                displayName: 'Agent ID (Query)',
+                name: 'fileAgentId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['upload'] } },
+                description: 'Optional query param agent_id for optimized processing.',
+            },
+            {
+                displayName: 'Logical Path',
+                name: 'fileLogicalPath',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['upload'] } },
+            },
+            {
+                displayName: 'SHA256',
+                name: 'fileSha256',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['upload'] } },
+            },
+            {
+                displayName: 'File ID',
+                name: 'fileId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['files'], fileOperation: ['getMetadata'] } },
+                required: true,
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        for (let i = 0; i < items.length; i++) {
+            const resource = this.getNodeParameter('resource', i);
+            // -------- Agents --------
+            if (resource === 'agents') {
+                const op = this.getNodeParameter('operation', i);
+                if (op === 'list') {
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, { method: 'GET', path: '/api/v1/agents' });
+                    out.push({ json: data });
+                }
+                if (op === 'create') {
+                    const name = this.getNodeParameter('agentName', i);
+                    const llm_model = this.getNodeParameter('llmModel', i);
+                    const description = this.getNodeParameter('agentDescription', i, '');
+                    const is_public = this.getNodeParameter('agentIsPublic', i, false);
+                    const settingsJson = this.getNodeParameter('agentSettingsJson', i, '{}');
+                    let agent_settings = undefined;
+                    try {
+                        agent_settings = settingsJson ? JSON.parse(settingsJson) : undefined;
+                    }
+                    catch {
+                        throw new Error('Invalid Agent Settings JSON');
+                    }
+                    const body = { name, llm_model, description: description || null, agent_settings: agent_settings || null, is_public };
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, { method: 'POST', path: '/api/v1/agents', body });
+                    out.push({ json: data });
+                }
+                if (op === 'get') {
+                    const agentId = this.getNodeParameter('agentId', i);
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, { method: 'GET', path: `/api/v1/agents/${agentId}` });
+                    out.push({ json: data });
+                }
+                if (op === 'update') {
+                    const agentId = this.getNodeParameter('agentId', i);
+                    const description = this.getNodeParameter('agentDescription', i, '');
+                    const is_public = this.getNodeParameter('agentIsPublic', i, false);
+                    const settingsJson = this.getNodeParameter('agentSettingsJson', i, '{}');
+                    let agent_settings = undefined;
+                    try {
+                        agent_settings = settingsJson ? JSON.parse(settingsJson) : undefined;
+                    }
+                    catch {
+                        throw new Error('Invalid Agent Settings JSON');
+                    }
+                    const body = {};
+                    if (description !== '')
+                        body.description = description;
+                    body.is_public = is_public;
+                    if (agent_settings !== undefined)
+                        body.agent_settings = agent_settings;
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, { method: 'PUT', path: `/api/v1/agents/${agentId}`, body });
+                    out.push({ json: data });
+                }
+                if (op === 'delete') {
+                    const agentId = this.getNodeParameter('agentId', i);
+                    await (0, http_1.dopomogaiRequest)(this, { method: 'DELETE', path: `/api/v1/agents/${agentId}` });
+                    out.push({ json: { ok: true } });
+                }
+            }
+            // -------- Conversations --------
+            if (resource === 'conversations') {
+                const op = this.getNodeParameter('conversationOperation', i);
+                if (op === 'list') {
+                    const options = this.getNodeParameter('conversationListOptions', i, {});
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, {
+                        method: 'GET',
+                        path: '/api/v1/conversations',
+                        query: options,
+                    });
+                    out.push({ json: data });
+                }
+                if (op === 'get') {
+                    const conversationId = this.getNodeParameter('conversationId', i);
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, {
+                        method: 'GET',
+                        path: `/api/v1/conversations/${conversationId}`,
+                    });
+                    out.push({ json: data });
+                }
+                if (op === 'rename') {
+                    const conversationId = this.getNodeParameter('conversationId', i);
+                    const title = this.getNodeParameter('conversationTitle', i);
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, {
+                        method: 'PATCH',
+                        path: `/api/v1/conversations/${conversationId}/meta`,
+                        body: { title },
+                    });
+                    out.push({ json: data });
+                }
+                if (op === 'delete') {
+                    const conversationId = this.getNodeParameter('conversationId', i);
+                    await (0, http_1.dopomogaiRequest)(this, {
+                        method: 'DELETE',
+                        path: `/api/v1/conversations/${conversationId}`,
+                    });
+                    out.push({ json: { ok: true } });
+                }
+            }
+            // -------- Chat --------
+            if (resource === 'chat') {
+                const op = this.getNodeParameter('chatOperation', i);
+                if (op !== 'chatBlocking')
+                    throw new Error(`Unsupported chat operation: ${op}`);
+                const creds = (0, http_1.getCreds)(this);
+                const agentId = this.getNodeParameter('chatAgentId', i);
+                const conversationId = this.getNodeParameter('chatConversationId', i, '');
+                const user_message = this.getNodeParameter('chatUserMessage', i, '');
+                const initial_context = this.getNodeParameter('chatInitialContext', i, '');
+                const turn_prompt_override = this.getNodeParameter('chatTurnPromptOverride', i, '');
+                const partsJson = this.getNodeParameter('chatPartsJson', i, '[]');
+                const runOverridesJson = this.getNodeParameter('chatRunOverridesJson', i, '{}');
+                const returnEvents = this.getNodeParameter('chatReturnEvents', i, false);
+                let parts = undefined;
+                let run_overrides = undefined;
+                try {
+                    parts = partsJson ? JSON.parse(partsJson) : undefined;
+                }
+                catch {
+                    throw new Error('Invalid Parts JSON');
+                }
+                try {
+                    run_overrides = runOverridesJson ? JSON.parse(runOverridesJson) : undefined;
+                }
+                catch {
+                    throw new Error('Invalid Run Overrides JSON');
+                }
+                const body = {
+                    conversation_id: conversationId || undefined,
+                    user_message: user_message || undefined,
+                    parts: Array.isArray(parts) && parts.length ? parts : undefined,
+                    initial_context: initial_context || undefined,
+                    turn_prompt_override: turn_prompt_override || undefined,
+                    run_overrides: run_overrides && Object.keys(run_overrides).length ? run_overrides : undefined,
+                };
+                const url = `${creds.apiBaseUrl}/api/v1/agents/${agentId}/conversations/stream`;
+                const headers = (0, http_1.buildHeaders)(creds);
+                const sse = await (0, sse_1.postSseAndCollect)({
+                    url,
+                    headers,
+                    body,
+                    stopOn: { streamEnd: true, complete: false },
+                    timeoutMs: 10 * 60 * 1000,
+                });
+                const finalText = sse.finalResponse || sse.accumulatedText;
+                out.push({
+                    json: {
+                        conversation_id: sse.conversationId || conversationId || null,
+                        final_response: finalText || '',
+                        usage: sse.usage,
+                        events: returnEvents ? sse.events : undefined,
+                    },
+                });
+            }
+            // -------- Files --------
+            if (resource === 'files') {
+                const op = this.getNodeParameter('fileOperation', i);
+                const creds = (0, http_1.getCreds)(this);
+                if (op === 'getMetadata') {
+                    const fileId = this.getNodeParameter('fileId', i);
+                    const { data } = await (0, http_1.dopomogaiRequest)(this, { method: 'GET', path: `/api/v1/files/${fileId}` });
+                    out.push({
+                        json: {
+                            ...data,
+                            download_url: `${creds.apiBaseUrl}/api/v1/files/${fileId}/download`,
+                        },
+                    });
+                }
+                if (op === 'upload') {
+                    const binaryProperty = this.getNodeParameter('binaryProperty', i, 'data');
+                    const purpose = this.getNodeParameter('filePurpose', i, 'agent_input');
+                    const agentId = this.getNodeParameter('fileAgentId', i, '');
+                    const logicalPath = this.getNodeParameter('fileLogicalPath', i, '');
+                    const sha256 = this.getNodeParameter('fileSha256', i, '');
+                    const bin = this.helpers.assertBinaryData(i, binaryProperty);
+                    const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                    const filename = bin.fileName || 'upload.bin';
+                    const mimeType = bin.mimeType || 'application/octet-stream';
+                    const form = new FormData();
+                    const bytes = new Uint8Array(buffer);
+                    const file = new File([bytes], filename, { type: mimeType });
+                    form.append('file', file);
+                    form.append('purpose', purpose);
+                    if (logicalPath)
+                        form.append('logical_path', logicalPath);
+                    if (sha256)
+                        form.append('sha256', sha256);
+                    const url = new URL(`${creds.apiBaseUrl}/api/v1/files/upload`);
+                    if (agentId)
+                        url.searchParams.set('agent_id', agentId);
+                    const headers = (0, http_1.buildHeaders)(creds, {
+                        // Let fetch set correct multipart boundary automatically; do not set Content-Type manually.
+                        Accept: 'application/json',
+                    });
+                    const res = await fetch(url.toString(), {
+                        method: 'POST',
+                        headers,
+                        body: form,
+                    });
+                    const payload = await res.json().catch(() => null);
+                    if (!res.ok) {
+                        const msg = payload?.detail || payload?.message || `HTTP ${res.status}`;
+                        throw new Error(`Upload failed (${res.status}): ${msg}`);
+                    }
+                    const fileId = payload?.id;
+                    out.push({
+                        json: {
+                            ...payload,
+                            download_url: fileId ? `${creds.apiBaseUrl}/api/v1/files/${fileId}/download` : null,
+                        },
+                    });
+                }
+            }
+        }
+        return [out];
+    }
+}
+exports.Dopomogai = Dopomogai;

package/dist/nodes/Dopomogai/helpers/http.d.ts

@@ -0,0 +1,19 @@
+import type { IExecuteFunctions } from 'n8n-workflow';
+export type DopomogaiCreds = {
+    apiBaseUrl: string;
+    apiKey: string;
+    sendAs: 'authorizationBearer' | 'xApiKey';
+};
+export declare function getCreds(ctx: IExecuteFunctions): DopomogaiCreds;
+export declare function buildHeaders(creds: DopomogaiCreds, extra?: Record<string, string>): Record<string, string>;
+export declare function dopomogaiRequest<T>(ctx: IExecuteFunctions, opts: {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: Record<string, any>;
+    body?: any;
+    headers?: Record<string, string>;
+}): Promise<{
+    data: T;
+    status: number;
+    headers: Headers;
+}>;

package/dist/nodes/Dopomogai/helpers/http.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreds = getCreds;
+exports.buildHeaders = buildHeaders;
+exports.dopomogaiRequest = dopomogaiRequest;
+function getCreds(ctx) {
+    const c = ctx.getCredentials('dopomogaiApiKey');
+    if (!c?.apiBaseUrl)
+        throw new Error('Missing credentials.apiBaseUrl');
+    if (!c?.apiKey)
+        throw new Error('Missing credentials.apiKey');
+    return {
+        apiBaseUrl: String(c.apiBaseUrl).replace(/\/+$/, ''),
+        apiKey: String(c.apiKey),
+        sendAs: (c.sendAs || 'authorizationBearer'),
+    };
+}
+function buildHeaders(creds, extra) {
+    const headers = {
+        Accept: 'application/json',
+        ...(extra || {}),
+    };
+    if (creds.sendAs === 'xApiKey') {
+        headers['X-API-Key'] = creds.apiKey;
+    }
+    else {
+        headers['Authorization'] = `Bearer ${creds.apiKey}`;
+    }
+    return headers;
+}
+async function dopomogaiRequest(ctx, opts) {
+    const creds = getCreds(ctx);
+    const url = new URL(`${creds.apiBaseUrl}${opts.path}`);
+    if (opts.query) {
+        for (const [k, v] of Object.entries(opts.query)) {
+            if (v === undefined || v === null || v === '')
+                continue;
+            url.searchParams.set(k, String(v));
+        }
+    }
+    const headers = buildHeaders(creds, opts.headers);
+    const init = {
+        method: opts.method,
+        headers,
+    };
+    if (opts.body !== undefined) {
+        headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+        init.body = JSON.stringify(opts.body);
+    }
+    const res = await fetch(url.toString(), init);
+    let payload = null;
+    const contentType = res.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+        payload = await res.json().catch(() => null);
+    }
+    else {
+        payload = await res.text().catch(() => null);
+    }
+    if (!res.ok) {
+        const msg = (payload && typeof payload === 'object' && (payload.detail || payload.message)) ||
+            (typeof payload === 'string' ? payload : '') ||
+            `HTTP ${res.status}`;
+        throw new Error(`DopomogAI API error (${res.status}): ${msg}`);
+    }
+    return { data: payload, status: res.status, headers: res.headers };
+}

package/dist/nodes/Dopomogai/helpers/sse.d.ts

@@ -0,0 +1,18 @@
+export type DopomogaiSseEvent = Record<string, any>;
+export declare function postSseAndCollect(opts: {
+    url: string;
+    headers: Record<string, string>;
+    body: any;
+    stopOn?: {
+        streamEnd?: boolean;
+        complete?: boolean;
+    };
+    maxEvents?: number;
+    timeoutMs?: number;
+}): Promise<{
+    conversationId?: string | null;
+    finalResponse?: string | null;
+    accumulatedText: string;
+    events: DopomogaiSseEvent[];
+    usage?: any;
+}>;

package/dist/nodes/Dopomogai/helpers/sse.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postSseAndCollect = postSseAndCollect;
+function splitSseBlocks(buffer) {
+    // SSE events are separated by a blank line
+    const parts = buffer.split(/\r\n\r\n|\r\r|\n\n/);
+    const rest = parts.pop() ?? '';
+    return { blocks: parts, rest };
+}
+function parseSseDataBlock(block) {
+    const lines = block.split(/\r\n|\r|\n/);
+    let data = '';
+    for (const line of lines) {
+        if (line.startsWith('data:'))
+            data += line.replace(/^data:\s?/, '');
+    }
+    return data.trim() ? data : null;
+}
+async function postSseAndCollect(opts) {
+    const controller = new AbortController();
+    const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+    const t = setTimeout(() => controller.abort(), timeoutMs);
+    const res = await fetch(opts.url, {
+        method: 'POST',
+        headers: {
+            Accept: 'text/event-stream',
+            'Content-Type': 'application/json',
+            ...opts.headers,
+        },
+        body: JSON.stringify(opts.body),
+        signal: controller.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`SSE request failed (${res.status}): ${text}`);
+    }
+    const conversationId = res.headers.get('x-conversation-id') || res.headers.get('X-Conversation-Id');
+    if (!res.body)
+        throw new Error('SSE response has no body');
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let accumulatedText = '';
+    let finalResponse = null;
+    let usage = undefined;
+    const events = [];
+    const maxEvents = opts.maxEvents ?? 10_000;
+    const stopOnStreamEnd = opts.stopOn?.streamEnd ?? true;
+    const stopOnComplete = opts.stopOn?.complete ?? false;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const { blocks, rest } = splitSseBlocks(buffer);
+            buffer = rest;
+            for (const block of blocks) {
+                const dataStr = parseSseDataBlock(block);
+                if (!dataStr)
+                    continue;
+                let evt;
+                try {
+                    evt = JSON.parse(dataStr);
+                }
+                catch {
+                    continue;
+                }
+                events.push(evt);
+                if (events.length > maxEvents)
+                    throw new Error(`Too many SSE events (> ${maxEvents})`);
+                if (evt?.type === 'response_chunk' && typeof evt.content === 'string') {
+                    accumulatedText += evt.content;
+                }
+                if (evt?.type === 'complete' && typeof evt.final_response === 'string') {
+                    finalResponse = evt.final_response;
+                    if (stopOnComplete) {
+                        controller.abort();
+                        break;
+                    }
+                }
+                if (evt?.type === 'stream_end') {
+                    // some backends include usage here
+                    if (evt?.usage)
+                        usage = evt.usage;
+                    if (stopOnStreamEnd) {
+                        controller.abort();
+                        break;
+                    }
+                }
+                if (evt?.type === 'error') {
+                    const msg = evt?.message || 'Unknown streaming error';
+                    throw new Error(`Streaming error: ${msg}`);
+                }
+            }
+        }
+    }
+    finally {
+        clearTimeout(t);
+        try {
+            controller.abort();
+        }
+        catch { }
+    }
+    return {
+        conversationId,
+        finalResponse,
+        accumulatedText,
+        events,
+        usage,
+    };
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "n8n-nodes-dopomogai",
+  "version": "0.1.0",
+  "description": "n8n community nodes for DopomogAI (agents, conversations, chat, files).",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.json",
+    "dev": "tsc -w -p tsconfig.json"
+  },
+  "dependencies": {
+    "n8n-workflow": "^2.2.3",
+    "n8n-core": "^2.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.5.4"
+  },
+  "keywords": ["n8n-community-node-package", "n8n"],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": ["dist/credentials/DopomogaiApiKey.credentials.js"],
+    "nodes": ["dist/nodes/Dopomogai/Dopomogai.node.js"]
+  }
+}