n8n-nodes-rooyai-chat 0.1.0

package/README.md

@@ -0,0 +1,202 @@
+# n8n-nodes-rooyai-chat
+
+Custom n8n node for Rooyai Chat API - A supply node that provides Rooyai language models for use with Basic LLM Chain, AI Agent, and other AI nodes in n8n.
+
+## Description
+
+This n8n custom node provides a **Rooyai Chat Model** supply node that can be connected to the **Basic LLM Chain** node, **AI Agent**, **Better AI Agent**, and other AI processing nodes in n8n.
+
+## Features
+
+- ✅ **Supply Node**: Provides Rooyai language models as a supply node (compatible with Basic LLM Chain, AI Agent)
+- ✅ **16 Available Models**: Support for Gemini, Llama, DeepSeek, GPT-OSS, and more
+- ✅ **Cost Tracking**: Tracks API costs per request (unique to Rooyai)
+- ✅ **Configurable Parameters**: Temperature, max tokens, and other model options
+- ✅ **Custom Headers**: Support for additional API headers
+- ✅ **Real-time API**: Direct HTTP integration with Rooyai API
+
+## Installation
+
+### Via npm (Recommended)
+
+```bash
+npm install n8n-nodes-rooyai-chat
+```
+
+Then restart your n8n instance. The node will appear in the node palette under **AI → Language Models**.
+
+### Manual Installation
+
+1. Clone or download this repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the node:
+   ```bash
+   npm run build
+   ```
+4. Copy to your n8n custom nodes location:
+   ```bash
+   # Windows
+   cp -r dist/* %USERPROFILE%\.n8n\custom\
+   
+   # Linux/Mac
+   cp -r dist/* ~/.n8n/custom/
+   ```
+
+## Configuration
+
+### 1. Create Rooyai API Credentials
+
+1. Go to **Credentials** in n8n
+2. Click **Add Credential**
+3. Search for **"Rooyai API"** and select it
+4. Enter your credentials:
+   - **API Key**: Your Rooyai API key (required)
+   - **Base URL**: `https://rooyai.com/api/v1` (default)
+   - **Optional Headers**: Additional headers as JSON (optional)
+5. Click **Save**
+
+### 2. Add Rooyai Chat Model Node
+
+1. In your workflow, click **+** to add a node
+2. Search for **"Rooyai Chat Model"**
+3. Select the node to add it to your workflow
+
+### 3. Configure the Node
+
+1. **Select Credentials**: Choose your Rooyai API credentials
+2. **Choose Model**: Select a model from the dropdown
+3. **Configure Options** (optional):
+   - **Temperature**: Controls randomness (0-1, default: 0.7)
+   - **Max Tokens**: Maximum number of tokens to generate (default: 4096)
+
+### 4. Connect to AI Nodes
+
+Connect the **Model** output from **Rooyai Chat Model** to:
+- **Basic LLM Chain**
+- **AI Agent**
+- **Better AI Agent**
+- Any other n8n AI node that accepts a Language Model
+
+## Available Models
+
+- **Gemini 2.0 Flash** (gemini-2.0-flash) - Default
+- **Llama 3.3 70B** (llama-3.3-70b)
+- **DeepSeek R1** (deepseek-r1)
+- **DeepSeek V3.1 NeX** (deepseek-v3.1-nex)
+- **Qwen3 Coder** (qwen3-coder)
+- **GPT-OSS 120B** (gpt-oss-120b)
+- **GPT-OSS 20B** (gpt-oss-20b)
+- **TNG R1T Chimera** (tng-r1t-chimera)
+- **TNG DeepSeek Chimera** (tng-deepseek-chimera)
+- **Kimi K2** (kimi-k2)
+- **GLM 4.5 Air** (glm-4.5-air)
+- **Devstral** (devstral)
+- **Mimo V2 Flash** (mimo-v2-flash)
+- **Gemma 3 27B** (gemma-3-27b)
+- **Gemma 3 12B** (gemma-3-12b)
+- **Gemma 3 4B** (gemma-3-4b)
+
+## Usage Example
+
+```
+┌──────────────────┐
+│ Rooyai Chat Model│
+│  (Supply Node)   │
+└─────────┬────────┘
+          │ Model
+          ▼
+┌──────────────────┐
+│ Basic LLM Chain  │
+│  (AI Node)       │
+└──────────────────┘
+```
+
+The Rooyai Chat Model node provides the language model instance that the Basic LLM Chain or AI Agent uses to process prompts and generate responses.
+
+## API Endpoint Configuration
+
+### Current Endpoint
+
+The node uses the following endpoint:
+- **Base URL**: `https://rooyai.com/api/v1`
+- **Chat Endpoint**: `/chat`
+- **Full URL**: `https://rooyai.com/api/v1/chat`
+
+### How to Change the Endpoint
+
+If you need to update the API endpoint:
+
+1. **Change Base URL**:
+   - Edit: `credentials/RooyaiApi.credentials.ts`
+   - Find the `baseUrl` property default value
+   - Update: `default: 'https://your-new-url.com/api/v1'`
+
+2. **Change Chat Path**:
+   - Edit: `nodes/Rooyai/RooyaiLangChainWrapper.ts`
+   - Find the `callRooyaiAPI()` method
+   - Update the line: `const url = \`\${this.baseUrl}/chat\`;`
+   - Change `/chat` to your new endpoint path
+
+3. **Rebuild**:
+   ```bash
+   npm run build
+   ```
+
+## Development
+
+### Scripts
+
+- `npm install` - Install dependencies
+- `npm run build` - Build the node (TypeScript + copy icons)
+- `npm run dev` - Watch mode for development
+- `npm run lint` - Run linter
+- `npm run format` - Format code
+
+### Project Structure
+
+```
+n8n-nodes-rooyai-chat/
+├── credentials/
+│   └── RooyaiApi.credentials.ts    # API credentials definition
+├── nodes/
+│   └── Rooyai/
+│       ├── Rooyai.node.ts          # Main node definition
+│       ├── RooyaiLangChainWrapper.ts  # LangChain integration
+│       ├── N8nLlmTracing.ts        # Event tracing
+│       └── rooyai.svg              # Node icon
+├── package.json
+├── tsconfig.json
+└── gulpfile.js
+```
+
+## Troubleshooting
+
+### "Rooyai API key not found"
+- Verify your API key is entered correctly in credentials
+- Make sure you've selected the correct credential in the node
+
+### "Failed to call Rooyai API"
+- Check your internet connection
+- Verify the base URL is correct
+- Check if the Rooyai API is accessible
+
+### Node doesn't appear in n8n
+- Make sure you've restarted n8n after installation
+- Verify the dist folder was copied to `~/.n8n/custom/`
+- Check n8n logs for any errors
+
+## License
+
+MIT
+
+## Author
+
+Rooyai
+
+## Resources
+
+- [n8n Documentation](https://docs.n8n.io/)
+- [n8n AI Nodes](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain/)

package/dist/credentials/RooyaiApi.credentials.d.ts

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

package/dist/credentials/RooyaiApi.credentials.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RooyaiApi = void 0;
+class RooyaiApi {
+    constructor() {
+        this.name = 'rooyaiApi';
+        this.displayName = 'Rooyai API';
+        this.documentationUrl = 'https://rooyai.com/dashboard/llm/docs';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Your Rooyai API key',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://rooyai.com/api/v1',
+                required: true,
+                description: 'Rooyai API base URL',
+            },
+            {
+                displayName: 'Optional Headers',
+                name: 'optionalHeaders',
+                type: 'string',
+                default: '',
+                placeholder: '{"X-Custom-Header": "value"}',
+                description: 'Additional headers as JSON object (optional)',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.baseUrl}}',
+                url: '/chat',
+                method: 'POST',
+                body: {
+                    model: 'gemini-2.0-flash',
+                    messages: [{ role: 'user', content: 'Hi' }],
+                    max_tokens: 10,
+                },
+            },
+        };
+    }
+}
+exports.RooyaiApi = RooyaiApi;

package/dist/nodes/Rooyai/N8nLlmTracing.d.ts

@@ -0,0 +1,11 @@
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { Serialized } from '@langchain/core/load/serializable';
+import { ISupplyDataFunctions } from 'n8n-workflow';
+export declare class N8nLlmTracing extends BaseCallbackHandler {
+    name: string;
+    supplyDataFunctions: ISupplyDataFunctions;
+    constructor(supplyDataFunctions: ISupplyDataFunctions);
+    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>): Promise<void>;
+    handleLLMEnd(output: any, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+    handleLLMError(error: Error, runId: string, parentRunId?: string, tags?: string[]): Promise<void>;
+}

package/dist/nodes/Rooyai/N8nLlmTracing.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nLlmTracing = void 0;
+const base_1 = require("@langchain/core/callbacks/base");
+class N8nLlmTracing extends base_1.BaseCallbackHandler {
+    constructor(supplyDataFunctions) {
+        super();
+        this.name = 'n8n_llm_tracing';
+        this.supplyDataFunctions = supplyDataFunctions;
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata) {
+        if (this.supplyDataFunctions.logger) {
+            this.supplyDataFunctions.logger.debug('Rooyai LLM started', {
+                runId,
+                parentRunId,
+                prompts,
+            });
+        }
+    }
+    async handleLLMEnd(output, runId, parentRunId, tags) {
+        if (this.supplyDataFunctions.logger) {
+            this.supplyDataFunctions.logger.debug('Rooyai LLM finished', {
+                runId,
+                parentRunId,
+            });
+        }
+    }
+    async handleLLMError(error, runId, parentRunId, tags) {
+        if (this.supplyDataFunctions.logger) {
+            this.supplyDataFunctions.logger.error('Rooyai LLM error', {
+                runId,
+                parentRunId,
+                error: error.message,
+            });
+        }
+    }
+}
+exports.N8nLlmTracing = N8nLlmTracing;

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

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

package/dist/nodes/Rooyai/Rooyai.node.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rooyai = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const RooyaiLangChainWrapper_1 = require("./RooyaiLangChainWrapper");
+const N8nLlmTracing_1 = require("./N8nLlmTracing");
+class Rooyai {
+    constructor() {
+        this.description = {
+            displayName: 'Rooyai Chat Model',
+            name: 'rooyaiChatModel',
+            icon: 'file:rooyai.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Language Model Rooyai',
+            defaults: {
+                name: 'Rooyai Chat Model',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Language Models', 'Root Nodes'],
+                    'Language Models': ['Chat Models (Recommended)'],
+                },
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiLanguageModel],
+            outputNames: ['Model'],
+            credentials: [
+                {
+                    name: 'rooyaiApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Gemini 2.0 Flash',
+                            value: 'gemini-2.0-flash',
+                        },
+                        {
+                            name: 'Llama 3.3 70B',
+                            value: 'llama-3.3-70b',
+                        },
+                        {
+                            name: 'DeepSeek R1',
+                            value: 'deepseek-r1',
+                        },
+                        {
+                            name: 'DeepSeek V3.1 NeX',
+                            value: 'deepseek-v3.1-nex',
+                        },
+                        {
+                            name: 'Qwen3 Coder',
+                            value: 'qwen3-coder',
+                        },
+                        {
+                            name: 'GPT-OSS 120B',
+                            value: 'gpt-oss-120b',
+                        },
+                        {
+                            name: 'GPT-OSS 20B',
+                            value: 'gpt-oss-20b',
+                        },
+                        {
+                            name: 'TNG R1T Chimera',
+                            value: 'tng-r1t-chimera',
+                        },
+                        {
+                            name: 'TNG DeepSeek Chimera',
+                            value: 'tng-deepseek-chimera',
+                        },
+                        {
+                            name: 'Kimi K2',
+                            value: 'kimi-k2',
+                        },
+                        {
+                            name: 'GLM 4.5 Air',
+                            value: 'glm-4.5-air',
+                        },
+                        {
+                            name: 'Devstral',
+                            value: 'devstral',
+                        },
+                        {
+                            name: 'Mimo V2 Flash',
+                            value: 'mimo-v2-flash',
+                        },
+                        {
+                            name: 'Gemma 3 27B',
+                            value: 'gemma-3-27b',
+                        },
+                        {
+                            name: 'Gemma 3 12B',
+                            value: 'gemma-3-12b',
+                        },
+                        {
+                            name: 'Gemma 3 4B',
+                            value: 'gemma-3-4b',
+                        },
+                    ],
+                    default: 'gemini-2.0-flash',
+                    description: 'The model which will generate the completion',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    placeholder: 'Add Option',
+                    description: 'Additional options to add',
+                    type: 'collection',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Maximum Number of Tokens',
+                            name: 'maxTokensToSample',
+                            default: 4096,
+                            description: 'The maximum number of tokens to generate in the completion',
+                            type: 'number',
+                        },
+                        {
+                            displayName: 'Sampling Temperature',
+                            name: 'temperature',
+                            default: 0.7,
+                            typeOptions: { maxValue: 1, minValue: 0, numberPrecision: 1 },
+                            description: 'Controls randomness: Lowering results in less random completions. As the temperature approaches zero, the model will become deterministic and repetitive.',
+                            type: 'number',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const credentials = await this.getCredentials('rooyaiApi');
+        const apiKey = credentials.apiKey;
+        const baseUrl = credentials.baseUrl;
+        const optionalHeaders = credentials.optionalHeaders;
+        if (!apiKey) {
+            throw new Error('Rooyai API key not found in credentials.');
+        }
+        if (!baseUrl) {
+            throw new Error('Rooyai base URL not found in credentials.');
+        }
+        const modelName = this.getNodeParameter('model', itemIndex);
+        const options = this.getNodeParameter('options', itemIndex, {});
+        let parsedHeaders;
+        if (optionalHeaders) {
+            try {
+                parsedHeaders = JSON.parse(optionalHeaders);
+            }
+            catch (error) {
+                throw new Error(`Invalid JSON in optional headers: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (this.logger) {
+            this.logger.info('Rooyai Chat Model initialized', {
+                model: modelName,
+                temperature: options.temperature ?? 0.7,
+                maxTokens: options.maxTokensToSample,
+            });
+        }
+        const model = new RooyaiLangChainWrapper_1.RooyaiLangChainWrapper({
+            apiKey,
+            baseUrl,
+            optionalHeaders: parsedHeaders,
+            model: modelName,
+            maxTokens: options.maxTokensToSample,
+            temperature: options.temperature ?? 0.7,
+            supplyDataFunctions: this,
+            callbacks: [new N8nLlmTracing_1.N8nLlmTracing(this)],
+        });
+        return {
+            response: model,
+        };
+    }
+}
+exports.Rooyai = Rooyai;

package/dist/nodes/Rooyai/RooyaiLangChainWrapper.d.ts

@@ -0,0 +1,32 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { BaseMessage } from '@langchain/core/messages';
+import { ChatResult, ChatGenerationChunk } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { ISupplyDataFunctions } from 'n8n-workflow';
+interface RooyaiLangChainWrapperParams {
+    apiKey: string;
+    baseUrl: string;
+    optionalHeaders?: Record<string, string>;
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    supplyDataFunctions?: ISupplyDataFunctions;
+    callbacks?: any[];
+}
+export declare class RooyaiLangChainWrapper extends BaseChatModel {
+    lc_namespace: string[];
+    private apiKey;
+    private baseUrl;
+    private optionalHeaders?;
+    private model;
+    private temperature;
+    private maxTokens?;
+    private supplyDataFunctions?;
+    constructor(params: RooyaiLangChainWrapperParams);
+    _llmType(): string;
+    _modelType(): string;
+    private callRooyaiAPI;
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+}
+export {};

package/dist/nodes/Rooyai/RooyaiLangChainWrapper.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RooyaiLangChainWrapper = void 0;
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const messages_1 = require("@langchain/core/messages");
+const axios_1 = __importDefault(require("axios"));
+class RooyaiLangChainWrapper extends chat_models_1.BaseChatModel {
+    constructor(params) {
+        const callbacks = params.callbacks ?? [];
+        super({
+            ...params,
+            callbacks,
+        });
+        this.lc_namespace = ['n8n', 'rooyai', 'chat'];
+        this.apiKey = params.apiKey;
+        this.baseUrl = params.baseUrl;
+        this.optionalHeaders = params.optionalHeaders;
+        this.model = params.model;
+        this.temperature = params.temperature ?? 0.7;
+        this.maxTokens = params.maxTokens;
+        this.supplyDataFunctions = params.supplyDataFunctions;
+    }
+    _llmType() {
+        return 'rooyai';
+    }
+    _modelType() {
+        return 'rooyai';
+    }
+    async callRooyaiAPI(body) {
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+        };
+        if (this.optionalHeaders) {
+            Object.assign(headers, this.optionalHeaders);
+        }
+        const url = `${this.baseUrl}/chat`;
+        try {
+            const response = await axios_1.default.post(url, body, {
+                headers,
+                validateStatus: () => true,
+            });
+            if (response.status !== 200) {
+                const errorText = typeof response.data === 'string'
+                    ? response.data
+                    : JSON.stringify(response.data);
+                throw new Error(`Rooyai API error (${response.status}): ${errorText}`);
+            }
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to call Rooyai API: ${error.message}`);
+            }
+            throw new Error(`Failed to call Rooyai API: ${String(error)}`);
+        }
+    }
+    async _generate(messages, options, runManager) {
+        const rooyaiMessages = messages.map((msg) => {
+            const msgType = msg._getType();
+            if (msgType === 'human') {
+                return { role: 'user', content: String(msg.content) };
+            }
+            if (msgType === 'ai') {
+                return { role: 'assistant', content: String(msg.content) };
+            }
+            if (msgType === 'system') {
+                return { role: 'system', content: String(msg.content) };
+            }
+            return { role: 'user', content: String(msg.content) };
+        });
+        const requestBody = {
+            model: this.model,
+            messages: rooyaiMessages,
+            temperature: this.temperature,
+        };
+        if (this.maxTokens) {
+            requestBody.max_tokens = this.maxTokens;
+        }
+        const response = await this.callRooyaiAPI(requestBody);
+        let assistantContent;
+        if (response.choices && response.choices.length > 0 && response.choices[0].message?.content) {
+            assistantContent = response.choices[0].message.content;
+        }
+        else if (response.reply) {
+            assistantContent = response.reply;
+        }
+        else {
+            throw new Error('No content found in Rooyai API response');
+        }
+        const aiMessage = new messages_1.AIMessage(assistantContent);
+        const tokenUsage = {};
+        if (response.usage?.prompt_tokens !== undefined) {
+            tokenUsage.promptTokens = response.usage.prompt_tokens;
+        }
+        if (response.usage?.completion_tokens !== undefined) {
+            tokenUsage.completionTokens = response.usage.completion_tokens;
+        }
+        if (response.usage?.total_tokens !== undefined) {
+            tokenUsage.totalTokens = response.usage.total_tokens;
+        }
+        const llmOutput = {
+            tokenUsage: Object.keys(tokenUsage).length > 0 ? tokenUsage : undefined,
+            modelName: this.model,
+        };
+        if (response.usage?.cost_usd !== undefined) {
+            llmOutput.costUsd = response.usage.cost_usd;
+        }
+        const generation = {
+            message: aiMessage,
+            text: assistantContent,
+        };
+        if (response.usage?.cost_usd !== undefined) {
+            generation.generationInfo = {
+                costUsd: response.usage.cost_usd,
+            };
+        }
+        return {
+            generations: [generation],
+            llmOutput,
+        };
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        throw new Error('Streaming is not yet supported for Rooyai Chat Model');
+    }
+}
+exports.RooyaiLangChainWrapper = RooyaiLangChainWrapper;

package/dist/nodes/Rooyai/rooyai.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <defs>
+    <linearGradient id="rooyaiGradient" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  <circle cx="50" cy="50" r="45" fill="url(#rooyaiGradient)" />
+  <text x="50" y="70" font-family="Arial, sans-serif" font-size="50" font-weight="bold" fill="white" text-anchor="middle">R</text>
+</svg>

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "n8n-nodes-rooyai-chat",
+	"version": "0.1.0",
+	"description": "n8n supply node for Rooyai Chat API - Provides Rooyai language models for use with Basic LLM Chain, AI Agent, and other AI nodes.",
+	"keywords": [
+		"n8n-community-node-package",
+		"n8n",
+		"rooyai",
+		"ai",
+		"llm",
+		"language-model",
+		"chat-completion"
+	],
+	"license": "MIT",
+	"author": {
+		"name": "Rooyai"
+	},
+	"main": "index.js",
+	"scripts": {
+		"build": "tsc && gulp build:icons",
+		"dev": "tsc --watch",
+		"format": "prettier nodes credentials --write",
+		"lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json",
+		"lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json --fix",
+		"prepublishOnly": "npm run build"
+	},
+	"files": [
+		"dist"
+	],
+	"n8n": {
+		"n8nNodesApiVersion": 1,
+		"nodes": [
+			"dist/nodes/Rooyai/Rooyai.node.js"
+		],
+		"credentials": [
+			"dist/credentials/RooyaiApi.credentials.js"
+		]
+	},
+	"devDependencies": {
+		"@types/node": "^25.0.3",
+		"@typescript-eslint/parser": "^5.45.0",
+		"eslint-plugin-n8n-nodes-base": "~1.11.0",
+		"gulp": "^4.0.2",
+		"n8n-workflow": "*",
+		"prettier": "^2.7.1",
+		"typescript": "~5.2.0"
+	},
+	"dependencies": {
+		"@langchain/core": "^0.1.0",
+		"axios": "^1.13.2",
+		"n8n-workflow": "*"
+	},
+	"peerDependencies": {
+		"n8n-workflow": "*"
+	}
+}