@alephantai/n8n-nodes-alephant-analytics-ai 0.1.2 → 0.1.4

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

@@ -1,5 +1,6 @@
-import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from 'n8n-workflow';
 export declare class AlephantAnalyticsAi implements INodeType {
     description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

package/dist/nodes/AlephantAnalyticsAi/AlephantAnalyticsAi.node.js

@@ -1,8 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AlephantAnalyticsAi = void 0;
+const tools_1 = require("@langchain/core/tools");
 const n8n_workflow_1 = require("n8n-workflow");
 const usage_1 = require("../../shared/usage");
+function toSafeToolName(nodeName) {
+    const normalized = (0, n8n_workflow_1.nodeNameToToolName)(nodeName)
+        .replace(/[^A-Za-z0-9_]/g, '_')
+        .replace(/^[^A-Za-z_]+/, '');
+    return normalized || 'Alephant_Analytics_AI';
+}
+function readToolInput(input) {
+    return typeof input === 'object' && input !== null ? input : {};
+}
+function readString(value, fallback) {
+    return typeof value === 'string' && value.trim() !== '' ? value : fallback;
+}
+function readNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+const analyticsToolSchema = {
+    type: 'object',
+    properties: {
+        operation: {
+            type: 'string',
+            enum: [
+                'scope',
+                'budgetStatus',
+                'usageSummary',
+                'dailyCosts',
+                'costByModel',
+                'recentRequests',
+                'requestLogDetail',
+            ],
+            description: 'Alephant analytics operation to run.',
+            default: 'usageSummary',
+        },
+        period: {
+            type: 'string',
+            enum: ['24h', '7d', '30d', '90d'],
+            description: 'Time period for budget, usage, daily cost, and cost-by-model operations.',
+            default: '7d',
+        },
+        limit: {
+            type: 'integer',
+            minimum: 1,
+            description: 'Maximum recent requests to return.',
+        },
+        offset: {
+            type: 'integer',
+            minimum: 0,
+            description: 'Recent requests offset.',
+        },
+        requestLogId: {
+            type: 'string',
+            description: 'Request log ID for requestLogDetail.',
+        },
+        workspaceId: {
+            type: 'string',
+            description: 'Workspace ID for request log detail lookups when credentials do not include one.',
+        },
+    },
+    additionalProperties: false,
+};
 class AlephantAnalyticsAi {
     constructor() {
         this.description = {
@@ -101,6 +161,37 @@ class AlephantAnalyticsAi {
             ],
         };
     }
+    async supplyData(itemIndex) {
+        const name = toSafeToolName(this.getNode().name);
+        try {
+            (0, n8n_workflow_1.tryToParseAlphanumericString)(name);
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The name of this tool is not a valid alphanumeric string', {
+                itemIndex,
+                description: "Only alphanumeric characters and underscores are allowed in the tool's name, and the name cannot start with a number",
+            });
+        }
+        return {
+            response: new tools_1.DynamicStructuredTool({
+                name,
+                description: 'Query Alephant AI analytics for usage, cost, latency, model/provider performance, budget status, recent requests, and request log detail.',
+                schema: analyticsToolSchema,
+                func: async (input) => {
+                    const toolInput = readToolInput(input);
+                    const data = await (0, usage_1.runUsageRequest)(this, {
+                        operation: readString(toolInput.operation, 'usageSummary'),
+                        period: readString(toolInput.period, '7d'),
+                        limit: readNumber(toolInput.limit, 50),
+                        offset: readNumber(toolInput.offset, 0),
+                        requestLogId: readString(toolInput.requestLogId, ''),
+                        workspaceId: readString(toolInput.workspaceId, ''),
+                    }, itemIndex);
+                    return JSON.stringify(data);
+                },
+            }),
+        };
+    }
     async execute() {
         return usage_1.executeUsageNode.call(this);
     }

package/dist/shared/errors.d.ts

@@ -1,3 +1,3 @@
 import { NodeApiError } from 'n8n-workflow';
-import type { IExecuteFunctions, IHttpRequestMethods } from 'n8n-workflow';
-export declare function toNodeApiError(ctx: IExecuteFunctions, error: unknown, method: IHttpRequestMethods, url: string, itemIndex?: number): NodeApiError;
+import type { IExecuteFunctions, IHttpRequestMethods, ISupplyDataFunctions } from 'n8n-workflow';
+export declare function toNodeApiError(ctx: IExecuteFunctions | ISupplyDataFunctions, error: unknown, method: IHttpRequestMethods, url: string, itemIndex?: number): NodeApiError;

package/dist/shared/http.d.ts

@@ -1,4 +1,4 @@
-import type { IDataObject, IExecuteFunctions, IHttpRequestMethods } from 'n8n-workflow';
+import type { IDataObject, IExecuteFunctions, IHttpRequestMethods, ISupplyDataFunctions } from 'n8n-workflow';
 export interface AlephantRequestOptions {
     method: IHttpRequestMethods;
     baseUrl: string;
@@ -10,4 +10,4 @@ export interface AlephantRequestOptions {
     body?: IDataObject;
     itemIndex?: number;
 }
-export declare function alephantRequest<T>(ctx: IExecuteFunctions, options: AlephantRequestOptions): Promise<T>;
+export declare function alephantRequest<T>(ctx: IExecuteFunctions | ISupplyDataFunctions, options: AlephantRequestOptions): Promise<T>;

package/dist/shared/usage.d.ts

@@ -1,4 +1,4 @@
-import type { IDataObject, IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+import type { IDataObject, IExecuteFunctions, INodeExecutionData, ISupplyDataFunctions } from 'n8n-workflow';
 export type UsageOperation = 'scope' | 'budgetStatus' | 'usageSummary' | 'dailyCosts' | 'costByModel' | 'recentRequests' | 'requestLogDetail';
 export interface UsageRequestParams {
     period?: string | null;
@@ -6,10 +6,17 @@ export interface UsageRequestParams {
     offset?: number | null;
     requestLogId?: string | null;
 }
+export interface UsageToolInput extends UsageRequestParams {
+    operation: UsageOperation;
+    requestLogMaxAttempts?: number | null;
+    workspaceId?: string | null;
+    inputJson?: IDataObject;
+}
 export interface UsageRequest {
     host?: 'saas' | 'analytics';
     path: string;
     qs?: IDataObject;
 }
 export declare function buildUsageRequest(operation: UsageOperation, params: UsageRequestParams): UsageRequest;
+export declare function runUsageRequest(ctx: IExecuteFunctions | ISupplyDataFunctions, params: UsageToolInput, itemIndex?: number): Promise<IDataObject>;
 export declare function executeUsageNode(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

package/dist/shared/usage.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildUsageRequest = buildUsageRequest;
+exports.runUsageRequest = runUsageRequest;
 exports.executeUsageNode = executeUsageNode;
 const n8n_workflow_1 = require("n8n-workflow");
 const constants_1 = require("./constants");
@@ -111,56 +112,62 @@ function buildUsageRequest(operation, params) {
             };
     }
 }
+async function runUsageRequest(ctx, params, itemIndex = 0) {
+    const credentials = (0, credentials_1.resolveVirtualKeyCredentials)((await ctx.getCredentials('alephantVirtualKeyApi')));
+    let request;
+    try {
+        request = buildUsageRequest(params.operation, params);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), error instanceof Error ? error.message : 'Invalid Alephant Usage input', { itemIndex });
+    }
+    let workspaceId = request.host === 'analytics'
+        ? normalizeOptionalString(params.workspaceId) ||
+            normalizeOptionalString(params.inputJson?.workspaceId) ||
+            normalizeOptionalString(params.inputJson?.workspace_id) ||
+            normalizeOptionalString(params.inputJson?.xWorkspaceId) ||
+            credentials.workspaceId
+        : undefined;
+    if (request.host === 'analytics' && workspaceId === '') {
+        const scope = await (0, http_1.alephantRequest)(ctx, {
+            method: 'GET',
+            baseUrl: credentials.saasBaseUrl,
+            path: constants_1.ENDPOINTS.cockpitScope,
+            token: credentials.virtualKey,
+            itemIndex,
+        });
+        workspaceId = extractWorkspaceIdFromScope(scope);
+    }
+    if (request.host === 'analytics' && workspaceId === '') {
+        throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Workspace ID is required for request log detail lookups and could not be resolved from Alephant Scope', { itemIndex });
+    }
+    const requestOptions = {
+        method: 'GET',
+        baseUrl: request.host === 'analytics' ? credentials.analyticsBaseUrl : credentials.saasBaseUrl,
+        path: request.path,
+        token: credentials.virtualKey,
+        workspaceId,
+        qs: request.qs,
+        itemIndex,
+    };
+    return request.host === 'analytics'
+        ? await requestWithLogPolling(ctx, requestOptions, normalizeAttemptCount(params.requestLogMaxAttempts))
+        : await (0, http_1.alephantRequest)(ctx, requestOptions);
+}
 async function executeUsageNode() {
     const items = this.getInputData();
-    const credentials = (0, credentials_1.resolveVirtualKeyCredentials)((await this.getCredentials('alephantVirtualKeyApi')));
     const returnData = [];
     for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-        const operation = this.getNodeParameter('operation', itemIndex);
-        let request;
-        try {
-            request = buildUsageRequest(operation, {
-                period: this.getNodeParameter('period', itemIndex, '7d'),
-                limit: this.getNodeParameter('limit', itemIndex, 50),
-                offset: this.getNodeParameter('offset', itemIndex, 0),
-                requestLogId: this.getNodeParameter('requestLogId', itemIndex, ''),
-            });
-        }
-        catch (error) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), error instanceof Error ? error.message : 'Invalid Alephant Usage input', { itemIndex });
-        }
-        let workspaceId = request.host === 'analytics'
-            ? normalizeOptionalString(this.getNodeParameter('workspaceId', itemIndex, '')) ||
-                normalizeOptionalString(items[itemIndex]?.json?.workspaceId) ||
-                normalizeOptionalString(items[itemIndex]?.json?.workspace_id) ||
-                normalizeOptionalString(items[itemIndex]?.json?.xWorkspaceId) ||
-                credentials.workspaceId
-            : undefined;
-        if (request.host === 'analytics' && workspaceId === '') {
-            const scope = await (0, http_1.alephantRequest)(this, {
-                method: 'GET',
-                baseUrl: credentials.saasBaseUrl,
-                path: constants_1.ENDPOINTS.cockpitScope,
-                token: credentials.virtualKey,
-                itemIndex,
-            });
-            workspaceId = extractWorkspaceIdFromScope(scope);
-        }
-        if (request.host === 'analytics' && workspaceId === '') {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Workspace ID is required for request log detail lookups and could not be resolved from Alephant Scope', { itemIndex });
-        }
-        const requestOptions = {
-            method: 'GET',
-            baseUrl: request.host === 'analytics' ? credentials.analyticsBaseUrl : credentials.saasBaseUrl,
-            path: request.path,
-            token: credentials.virtualKey,
-            workspaceId,
-            qs: request.qs,
-            itemIndex,
-        };
-        const data = request.host === 'analytics'
-            ? await requestWithLogPolling(this, requestOptions, normalizeAttemptCount(this.getNodeParameter('requestLogMaxAttempts', itemIndex, 6)))
-            : await (0, http_1.alephantRequest)(this, requestOptions);
+        const data = await runUsageRequest(this, {
+            operation: this.getNodeParameter('operation', itemIndex),
+            period: this.getNodeParameter('period', itemIndex, '7d'),
+            limit: this.getNodeParameter('limit', itemIndex, 50),
+            offset: this.getNodeParameter('offset', itemIndex, 0),
+            requestLogId: this.getNodeParameter('requestLogId', itemIndex, ''),
+            workspaceId: this.getNodeParameter('workspaceId', itemIndex, ''),
+            requestLogMaxAttempts: this.getNodeParameter('requestLogMaxAttempts', itemIndex, 6),
+            inputJson: items[itemIndex]?.json,
+        }, itemIndex);
         returnData.push({
             json: data,
             pairedItem: { item: itemIndex },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephantai/n8n-nodes-alephant-analytics-ai",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "n8n AI tool node for Alephant analytics",
   "license": "MIT",
   "homepage": "https://alephant.io",
@@ -50,6 +50,9 @@
   "peerDependencies": {
     "n8n-workflow": "*"
   },
+  "dependencies": {
+    "@langchain/core": "^1.1.46"
+  },
   "devDependencies": {
     "n8n-workflow": "*",
     "typescript": "^5.6.3"