n8n-nodes-tembory-agent-memory-v2 2.0.0-rc.2

package/README.md

@@ -0,0 +1,28 @@
+# Tembory Agent Memory for n8n
+
+Release candidate público: `2.0.0-rc.2`. Instale-o lado a lado com o pacote legado para validação controlada, sem migrar workflows existentes automaticamente.
+
+O node tem identidade exclusiva `temboryAgentMemoryV2`, contrato fixo `agent-context/2`, persistência PostgreSQL obrigatória por padrão, revisão otimista e recibos de gravação. Ele não substitui nem migra o node antigo.
+
+O pacote reutiliza o runtime testado por meio de `npm run sync:standalone` no pacote canônico. Durante o canário, referencia a credencial `temboryApi` já registrada pelo pacote antigo, sem duplicar definição nem copiar segredos.
+
+This is a public side-by-side release candidate, not a GA release.
+
+Install it only beside `n8n-nodes-tembory`; the old package supplies the shared credential type while both node identities remain distinct.
+
+## Package identity
+
+- npm package: `n8n-nodes-tembory-agent-memory-v2`
+- n8n node display name: `Tembory Agent Memory v2 (Canary)`
+- n8n node internal name: `temboryAgentMemoryV2`
+- guard internal name: `temboryActionGuardV2`
+- credential dependency: `temboryApi` from the legacy package
+
+## Why separate
+
+The legacy package remains available as `n8n-nodes-tembory`.
+This package is the opt-in ElefAI LAB path for the next Agent Memory experience without changing existing workflows.
+
+## Release candidate use
+
+Use this release candidate only in explicitly selected workflows. Do not migrate customer workflows during this validation phase.

package/dist/credentials/TemboryAgentApi.credentials.d.ts

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

package/dist/credentials/TemboryAgentApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemboryAgentApi = void 0;
+class TemboryAgentApi {
+    constructor() {
+        this.name = 'temboryAgentApi';
+        this.displayName = 'Tembory Agent API';
+        this.documentationUrl = 'https://tembory.com';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'API key generated in the Tembory SaaS dashboard. It already identifies the account and project.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'x-tembory-api-key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://api.tembory.com',
+                url: '/healthz',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.TemboryAgentApi = TemboryAgentApi;

package/dist/nodes/Tembory/GenericFunctions.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, IHookFunctions, IWebhookFunctions, IHttpRequestMethods } from 'n8n-workflow';
+export declare function temboryApiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions | IWebhookFunctions, method: IHttpRequestMethods, endpoint: string, body?: any, qs?: any): Promise<any>;

package/dist/nodes/Tembory/GenericFunctions.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.temboryApiRequest = temboryApiRequest;
+exports.assertTemboryCredentials = assertTemboryCredentials;
+const n8n_workflow_1 = require("n8n-workflow");
+async function getTemboryCredentials(ctx) {
+    try {
+        return await ctx.getCredentials('temboryApi');
+    }
+    catch { }
+    try {
+        return await ctx.getCredentials('mem0Api');
+    }
+    catch { }
+    throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Credentials for Tembory are not set. Select a Tembory API credential and save the workflow.');
+}
+async function assertTemboryCredentials(ctx) {
+    await getTemboryCredentials(ctx);
+}
+async function temboryApiRequest(method, endpoint, body = {}, qs = {}) {
+    const credentials = await getTemboryCredentials(this);
+    const baseUrl = 'https://api.tembory.com';
+    const operation = resolveGatewayOperation(method, endpoint);
+    const payload = {
+        ...(qs && typeof qs === 'object' ? qs : {}),
+        ...(body && typeof body === 'object' ? body : {}),
+        operation,
+        nodePackage: 'n8n-nodes-tembory-agent-memory-v2/2.0.0-rc.2',
+        contextContract: 'agent-context/2',
+    };
+    const options = {
+        method: 'POST',
+        body: payload,
+        url: `${baseUrl}/api/tembory/memory`,
+        json: true,
+    };
+    if (credentials.apiKey) {
+        options.headers = {
+            'x-tembory-api-key': credentials.apiKey,
+        };
+    }
+    try {
+        const response = await this.helpers.request(options);
+        return unwrapGatewayResponse(response);
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+function resolveGatewayOperation(method, endpoint) {
+    const normalizedMethod = String(method || '').toUpperCase();
+    const path = String(endpoint || '').toLowerCase();
+    if (path.includes('capabilities'))
+        return 'system.capabilities';
+    if (path.includes('action-manifests'))
+        return 'action.manifest.put';
+    if (path.includes('/actions/validate'))
+        return 'action.validate';
+    if (path.includes('/actions/reserve'))
+        return 'action.reserve';
+    if (path.includes('/actions/commit'))
+        return 'action.commit';
+    if (path.includes('/actions/fail'))
+        return 'action.fail';
+    if (path.includes('thread-state') && (normalizedMethod === 'GET' || path.includes('load')))
+        return 'thread-state.load';
+    if (path.includes('thread-state'))
+        return 'thread-state.save';
+    if (path.includes('search') || normalizedMethod === 'GET')
+        return 'memory.search';
+    if (path.includes('delete'))
+        return 'memory.delete';
+    if (path.includes('relation'))
+        return 'memory.search';
+    return 'memory.add';
+}
+function unwrapGatewayResponse(response) {
+    if (response && typeof response === 'object' && response.memoryCore && typeof response.memoryCore === 'object' && 'response' in response.memoryCore) {
+        return response.memoryCore.response;
+    }
+    return response;
+}

package/dist/nodes/Tembory/TemboryMemory.node.d.ts

@@ -0,0 +1,14 @@
+import type { ISupplyDataFunctions, IExecuteFunctions, INodeType, INodeTypeDescription, INodeExecutionData } from 'n8n-workflow';
+export declare class TemboryMemory implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<{
+        response: any;
+    }>;
+    saveContextForItem(this: ISupplyDataFunctions, itemIndex: number, inputValues?: Record<string, unknown>, outputValues?: Record<string, unknown>): Promise<void>;
+    loadMemoryVariablesForItem(this: ISupplyDataFunctions, itemIndex: number, inputValues?: Record<string, unknown>): Promise<{
+        response: {
+            [x: string]: unknown;
+        };
+    }>;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}