n8n-nodes-berget-mk 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# n8n-nodes-berget-mk
+
+n8n community nodes for [Berget AI](https://berget.ai). Fork of the upstream `@bergetai/n8n-nodes-all` maintained by Micke Kring, packaged as a single installable module.
+
+Includes six nodes: **Chat**, **Agent** (with tool calling), **Embeddings**, **OCR**, **Speech-to-Text**, and **Rerank**.
+
+## Install
+
+In n8n: **Settings → Community Nodes → Install** and enter:
+
+```text
+n8n-nodes-berget-mk
+```
+
+Then add a **Berget AI API** credential with your API key from [berget.ai](https://berget.ai).
+
+## Compatibility
+
+Uses the same internal node type names as the upstream package (`bergetAiChat`, `bergetAiAgent`, etc.), so workflows built against `@bergetai/n8n-nodes-all` continue to work after switching.
+
+## License
+
+MIT

package/dist/credentials/BergetAiApi.credentials.d.ts

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

package/dist/credentials/BergetAiApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BergetAiApi = void 0;
+class BergetAiApi {
+    constructor() {
+        this.name = 'bergetAiApi';
+        this.displayName = 'Berget AI API';
+        this.documentationUrl = 'https://api.berget.ai/docs';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Your Berget AI API key. Get it from https://berget.ai',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://api.berget.ai/v1',
+                url: '/models',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.BergetAiApi = BergetAiApi;

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

@@ -0,0 +1,10 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class BergetAiAgent implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/BergetAiAgent/BergetAiAgent.node.js

@@ -0,0 +1,365 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BergetAiAgent = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const axios_1 = __importDefault(require("axios"));
+class BergetAiAgent {
+    constructor() {
+        this.description = {
+            displayName: 'Berget AI Agent',
+            name: 'bergetAiAgent',
+            icon: 'file:bergetai.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["model"]}}',
+            description: 'AI Agent with tool calling capabilities using Berget AI models',
+            defaults: {
+                name: 'Berget AI Agent',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bergetAiApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                ignoreHttpStatusErrors: true,
+                baseURL: 'https://api.berget.ai/v1',
+            },
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Agent',
+                            value: 'agent',
+                            description: 'Run agent with tool calling',
+                            action: 'Run agent with tool calling',
+                        },
+                    ],
+                    default: 'agent',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                    },
+                    default: '',
+                    description: 'Model to use for the agent',
+                    required: true,
+                },
+                {
+                    displayName: 'System Prompt',
+                    name: 'systemPrompt',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: 'You are a helpful AI assistant with access to tools. Use the tools when necessary to help the user accomplish their tasks.',
+                    description: 'System prompt that defines the agent\'s behavior and capabilities',
+                },
+                {
+                    displayName: 'User Message',
+                    name: 'userMessage',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 2,
+                    },
+                    default: '',
+                    description: 'The user\'s message or task for the agent',
+                    required: true,
+                },
+                {
+                    displayName: 'Tools',
+                    name: 'tools',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {
+                        values: [],
+                    },
+                    description: 'Tools available to the agent',
+                    options: [
+                        {
+                            displayName: 'Tool',
+                            name: 'values',
+                            values: [
+                                {
+                                    displayName: 'Tool Name',
+                                    name: 'name',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Name of the tool',
+                                    required: true,
+                                },
+                                {
+                                    displayName: 'Tool Description',
+                                    name: 'description',
+                                    type: 'string',
+                                    typeOptions: {
+                                        rows: 2,
+                                    },
+                                    default: '',
+                                    description: 'Description of what the tool does',
+                                    required: true,
+                                },
+                                {
+                                    displayName: 'Parameters',
+                                    name: 'parameters',
+                                    type: 'json',
+                                    default: '{\n  "type": "object",\n  "properties": {},\n  "required": []\n}',
+                                    description: 'JSON Schema for tool parameters',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add options',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Temperature',
+                            name: 'temperature',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 0,
+                                maxValue: 2,
+                                numberStepSize: 0.1,
+                            },
+                            default: 0.7,
+                            description: 'Controls randomness in responses. Lower values = more deterministic.',
+                        },
+                        {
+                            displayName: 'Max Tokens',
+                            name: 'max_tokens',
+                            type: 'number',
+                            default: 2000,
+                            description: 'Maximum number of tokens to generate',
+                        },
+                        {
+                            displayName: 'Max Iterations',
+                            name: 'max_iterations',
+                            type: 'number',
+                            default: 5,
+                            description: 'Maximum number of agent iterations (tool calls)',
+                        },
+                        {
+                            displayName: 'Tool Choice',
+                            name: 'tool_choice',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Auto',
+                                    value: 'auto',
+                                    description: 'Model decides when to use tools',
+                                },
+                                {
+                                    name: 'Required',
+                                    value: 'required',
+                                    description: 'Model must use a tool',
+                                },
+                                {
+                                    name: 'None',
+                                    value: 'none',
+                                    description: 'Model will not use tools',
+                                },
+                            ],
+                            default: 'auto',
+                            description: 'Control how the model uses tools',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getModels() {
+                    try {
+                        const credentials = await this.getCredentials('bergetAiApi');
+                        const response = await axios_1.default.get('https://api.berget.ai/v1/models', {
+                            headers: {
+                                'Authorization': `Bearer ${credentials.apiKey}`,
+                                'Content-Type': 'application/json',
+                            },
+                        });
+                        if (response.status !== 200) {
+                            throw new Error(`API error: ${response.statusText}`);
+                        }
+                        // Filter models that support chat completions and tool calling
+                        const models = response.data.data || [];
+                        const chatModels = models.filter((model) => {
+                            // Use API metadata: filter for text models with function calling capability
+                            return model.model_type === 'text' &&
+                                model.capabilities &&
+                                model.capabilities.function_calling === true;
+                        });
+                        return chatModels.map((model) => ({
+                            name: model.id,
+                            value: model.id,
+                            description: `${model.id}${model.owned_by ? ` (${model.owned_by})` : ''}`,
+                        })).sort((a, b) => a.name.localeCompare(b.name));
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to load models from Berget AI API. Please check your API key and network connection. Error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e;
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('bergetAiApi');
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const model = this.getNodeParameter('model', i);
+                const systemPrompt = this.getNodeParameter('systemPrompt', i);
+                const userMessage = this.getNodeParameter('userMessage', i);
+                const toolsConfig = this.getNodeParameter('tools.values', i, []);
+                const options = this.getNodeParameter('options', i, {});
+                if (operation === 'agent') {
+                    // Parse and validate tools
+                    const tools = toolsConfig.map(tool => {
+                        if (!tool.name || !tool.description) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tool name and description are required', { itemIndex: i });
+                        }
+                        try {
+                            const parameters = typeof tool.parameters === 'string'
+                                ? JSON.parse(tool.parameters)
+                                : tool.parameters;
+                            // Validate that parameters is a valid JSON Schema object
+                            if (typeof parameters !== 'object' || parameters === null) {
+                                throw new Error('Parameters must be a valid JSON Schema object');
+                            }
+                            return {
+                                type: 'function',
+                                function: {
+                                    name: tool.name.trim(),
+                                    description: tool.description.trim(),
+                                    parameters,
+                                },
+                            };
+                        }
+                        catch (error) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON Schema in parameters for tool "${tool.name}": ${error instanceof Error ? error.message : String(error)}`, { itemIndex: i });
+                        }
+                    });
+                    // Initialize conversation
+                    const messages = [
+                        { role: 'system', content: systemPrompt },
+                        { role: 'user', content: userMessage },
+                    ];
+                    const maxIterations = options.max_iterations || 5;
+                    let iteration = 0;
+                    let finalResponse = null;
+                    const toolCalls = [];
+                    // Agent loop
+                    while (iteration < maxIterations) {
+                        iteration++;
+                        const body = {
+                            model,
+                            messages,
+                            temperature: (_a = options.temperature) !== null && _a !== void 0 ? _a : 0.7,
+                            max_tokens: (_b = options.max_tokens) !== null && _b !== void 0 ? _b : 2000,
+                        };
+                        // Add tools if available
+                        if (tools.length > 0) {
+                            body.tools = tools;
+                            if (options.tool_choice) {
+                                body.tool_choice = options.tool_choice;
+                            }
+                        }
+                        const response = await axios_1.default.post('https://api.berget.ai/v1/chat/completions', body, {
+                            headers: {
+                                'Authorization': `Bearer ${credentials.apiKey}`,
+                                'Content-Type': 'application/json',
+                            },
+                        });
+                        if (response.status !== 200) {
+                            const errorMessage = ((_d = (_c = response.data) === null || _c === void 0 ? void 0 : _c.error) === null || _d === void 0 ? void 0 : _d.message) ||
+                                ((_e = response.data) === null || _e === void 0 ? void 0 : _e.message) ||
+                                response.statusText ||
+                                'Unknown API error';
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Berget AI API error (${response.status}): ${errorMessage}. Check your API key and model availability`, {
+                                itemIndex: i
+                            });
+                        }
+                        const choice = response.data.choices[0];
+                        const message = choice.message;
+                        // Add assistant's response to messages
+                        messages.push(message);
+                        // Check if there are tool calls
+                        if (message.tool_calls && message.tool_calls.length > 0) {
+                            // Process each tool call
+                            for (const toolCall of message.tool_calls) {
+                                toolCalls.push({
+                                    id: toolCall.id,
+                                    name: toolCall.function.name,
+                                    arguments: toolCall.function.arguments,
+                                    iteration,
+                                });
+                                // Tool execution is not implemented in this node
+                                // This node only handles the AI conversation flow and tool call detection
+                                // Actual tool execution should be handled by subsequent nodes in the workflow
+                                // The tool calls are returned in the output for further processing
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Tool execution is not supported in this node. The AI model requested to call tool "${toolCall.function.name}" but this node only handles conversation flow. Use the tool calls in the output to implement actual tool execution in your workflow.`, {
+                                    itemIndex: i,
+                                    description: 'Connect this node to other nodes that can execute the requested tools, then feed the results back to continue the conversation.'
+                                });
+                            }
+                        }
+                        else {
+                            // No tool calls, agent is done
+                            finalResponse = message.content;
+                            break;
+                        }
+                        // Check finish reason
+                        if (choice.finish_reason === 'stop') {
+                            finalResponse = message.content;
+                            break;
+                        }
+                    }
+                    returnData.push({
+                        json: {
+                            response: finalResponse,
+                            tool_calls: toolCalls,
+                            iterations: iteration,
+                            messages: messages,
+                            model,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error instanceof Error ? error.message : String(error) },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.BergetAiAgent = BergetAiAgent;

package/dist/nodes/BergetAiAgent/bergetai.svg

@@ -0,0 +1,8 @@
+<svg width="463" height="419" viewBox="0 0 463 419" fill="none" xmlns="http://www.w3.org/2000/svg">
+<defs>
+<filter id="invertFilter">
+<feColorMatrix type="matrix" values="-1 0 0 0 1 0 -1 0 0 1 0 0 -1 0 1 0 0 0 1 0"/>
+</filter>
+</defs>
+<path d="M208.739 17L255.261 17L446 403L398 403L313.5 255L261.5 176L233.163 96.1677L237.815 98.6522H226.185L230.837 96.1677L113 331L64.5 403L18 403L208.739 17Z" fill="black" filter="url(#invertFilter)"/>
+</svg>

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

@@ -0,0 +1,10 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class BergetAiChat implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}