n8n-nodes-lifespace 0.1.22 → 0.1.24

package/README.md

@@ -44,25 +44,26 @@ Restart n8n afterwards. In queue mode, install the package anywhere that may exe
 
 ## Quick start
 
-Create a **LifeSpace API** credential for Runtime Discovery and LifeSpace API calls.
+LifeSpace has two explicit execution modes in n8n.
 
-It contains:
+For **Service Principal（服务主体）automation**, create a **LifeSpace API** credential with the Core **API Base URL** and an opaque `lsp_pat_*` **Service API Token**. This remains the default for scheduled/system workflows where `Principal = Actor = Service`.
 
-- **API Base URL**, for example:
+For a user-initiated **Delegated Agent（委托智能体）** Tool or Batch, create a separate **LifeSpace Delegated Agent API** credential containing:
 
-  ```text
-  https://api.example.com/api/v1
-  ```
+- **Core API Base URL**;
+- **Identity API Base URL**;
+- the server-only Application credential `lsa_*`;
+- the registered LifeSpace `agt_*` Agent ID.
 
-- **Service API Token**, an opaque LifeSpace `lsp_pat_*` token.
+Delegated mode does **not** require or fall back to a Service PAT. The adapter uses the Application credential only to mint a short-lived `User Principal → Agent Actor` execution token from LifeSpace Identity, then calls Core with that token plus explicit Delegation selectors.
 
-The API Base URL is the LifeSpace Core API root. Do not include a Space ID or Record Type path.
+`Principal User ID`, `Delegation ID`, `Read Delegation ID` and per-item Batch Delegation IDs are execution/control context, never LLM Tool arguments. `Read Delegation ID` is intentionally separate: it covers delegated design-time Discovery and only the runtime calls that actually need relation-name lookup or optimistic-concurrency pre-reads, so those helper reads cannot accidentally consume a single-use Delegation reserved for the actual query/mutation/action. A pure runtime mutation with no helper read does not exercise the Read Delegation.
 
-The token is shown only when it is created or rotated. Store it in n8n immediately; do not put it in workflow fields, URLs, source files, or workflow exports.
+Credentials are secrets. Store them only in n8n credentials; do not put `lsp_pat_*`, `lsa_*`, Agent JWTs or other secrets in workflow fields, URLs, source files or workflow exports.
 
 A **LifeSpace Trigger** additionally uses a **LifeSpace Webhook Signing** credential containing the endpoint-scoped HMAC signing secret. This is deliberately separate from the API credential: the Service API Token authenticates outbound n8n → LifeSpace calls, while the signing secret verifies inbound LifeSpace → n8n deliveries and rotates with its Webhook Endpoint. The Trigger still reuses the LifeSpace API credential for Space/Record Type discovery, so API context is not duplicated.
 
-Runtime Discovery determines which Spaces, Record Types, fields, queries, Actions and relation lookup capabilities the current API credential can use. The adapter starts from the compact current-principal inventory, then loads static semantic detail only for the selected Space/Record Type. Relation target lookup remains lazy and field-scoped. Execution authorization is still enforced by LifeSpace from the current principal, credential scope, Application × Model Access and current Space/Data Grant authority.
+Runtime Discovery determines which Spaces, Record Types, fields, queries, Actions and relation lookup capabilities the current execution context can use. Service mode uses the Service PAT. Delegated Agent mode uses the short-lived Agent token; progressive semantic detail uses the configured Read Delegation selector. Relation target lookup remains lazy and field-scoped. Execution authorization is always enforced by LifeSpace from verified Application / Principal / Actor, credential scope, Application × Model Access, current Space/Data Grant authority and the explicitly selected Delegation when Principal and Actor differ.
 
 ## Generated Record UX
 
@@ -89,7 +90,7 @@ Current Calendar models expose the canonical `capabilityBindings.calendar.rangeF
 
 ## LifeSpace contract compatibility
 
-This package follows the current LifeSpace Core Kernel `0.36.0` contract family. It consumes Runtime/Discovery semantics only; Eventing configuration and webhook delivery semantics are owned independently by Integration/Eventing `0.1.0`.
+This package follows the current LifeSpace Core Kernel `0.40.0` contract family. Integration/Eventing is independently versioned at `0.3.0`. Authority v2 requires an explicit Delegation selector whenever `Principal != Actor`, and Model Contracts expose the first-class atomic Generic Runtime Batch surface.
 
 The UX depends on these Kernel capabilities:
 
@@ -112,6 +113,7 @@ The UX depends on these Kernel capabilities:
 - `0.34.0`: explicit `eq/lt/lte/gt/gte` comparison transports, first-class `createdAt` / `updatedAt` envelope comparisons and Core-owned datetime local-date-window conversion become discoverable.
 - `0.35.0`: grouped `query.capabilityQueries` introduced capability-owned compatibility queries.
 - `0.36.0`: `query.canonical` unifies Search, typed Boolean Filter, multi-Sort and cursor Pagination behind `POST .../records/query`; Runtime Discovery also exposes canonical `instant`, `range<date>`, `range<instant>`, `temporal_range` field types and the Calendar `rangeField` binding. The human Workflow node consumes those current semantics while retaining historical Discovery spellings only for compatibility.
+- `0.40.0`: Authority v2 separates verified Application / Principal / Actor from the explicit opaque Delegation selector; one Delegation has one Space/Model/Record scope; first-class `POST /spaces/{spaceId}/models/batch` atomically commits 1-20 create/update/delete operations and returns one `changeSetId`.
 
 The adapter prefers the `0.27+` progressive flow while configuring a node:
 
@@ -181,7 +183,11 @@ Credentials are intentionally static secure configuration and are not workflow-e
 
 The normal n8n-facing resource is **Record**. LifeSpace still owns **Model** semantics internally; the adapter uses **Record Type** for the workflow-facing selection.
 
-Supported operations:
+Supported human Workflow operations include ordinary Record CRUD/Query/Action plus **Batch Mutation**. Batch Mutation accepts 1-20 create/update/delete operations, may mix Record Types in one Space, and sends exactly one atomic Core request. Update/Delete items carry their already-known optimistic-concurrency `version`; the adapter does not turn Batch into N pre-read + CRUD calls.
+
+The native Agent Tool supports Query/Create/Update/Delete/Action plus **Create Records (Batch)** for 1-20 records of its pinned Record Type. Agent Batch Update/Delete are intentionally not synthesized in this version: automatically resolving N current versions would reintroduce an N-read waterfall. Use the human Batch surface with known versions, or add a future set-based version-resolution contract before exposing those Agent operations.
+
+Ordinary Record operations remain:
 
 - **Create**;
 - **Get**;
@@ -333,13 +339,16 @@ Webhook Endpoint / Event Subscription creation is intentionally not performed by
 
 ## What the package provides
 
-- **LifeSpace API** credential for API authentication and Runtime Discovery;
+- **LifeSpace API** credential for Service Principal authentication and Runtime Discovery;
+- **LifeSpace Delegated Agent API** credential for server-only Application authentication, short-lived Agent token minting, and delegated Core execution without a Service PAT;
 - **LifeSpace Webhook Signing** credential for endpoint-scoped inbound HMAC verification;
-- **LifeSpace** human workflow node with Discovery-driven Record operations plus advanced API Request;
-- **LifeSpace Agent Tool** native AiTool with Discovery-driven semantic schemas;
+- **LifeSpace** human workflow node with Discovery-driven Record operations, first-class 1-20 atomic Batch create/update/delete, plus advanced API Request;
+- **LifeSpace Agent Tool** native AiTool with Discovery-driven semantic schemas and bounded same-model Batch Create;
 - **LifeSpace Trigger** with signed multi-Record-Type Domain Event filtering;
 - shared thin adapter projection from LifeSpace Runtime Discovery into human n8n controls and model-facing Tool schemas.
 
+The human Batch surface is the generic cross-model atomic transport. The Agent Tool deliberately exposes only same-model Batch Create in this release: Agent Update/Delete continue to resolve optimistic concurrency through a read before mutation, and the adapter does not turn multiple such reads into an N+1 pseudo-Batch. Cross-model or mutation-mixed Agent Batch should be added only when its full input contract can remain deterministic and bounded without reintroducing per-item Runtime round trips.
+
 LifeSpace remains authoritative for validation, authorization, defaults, Mutation Authority, Action semantics, query/time semantics, relation semantics and event contracts. Runtime Discovery and Relation Target Lookup are current capability/reference projections, not execution-authorization proofs.
 
 ## Architecture boundary

package/dist/credentials/LifeSpaceAgentExecutionApi.credentials.d.ts

@@ -0,0 +1,13 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class LifeSpaceAgentExecutionApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: {
+        readonly light: "file:lifespace.svg";
+        readonly dark: "file:lifespace.dark.svg";
+    };
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/LifeSpaceAgentExecutionApi.credentials.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifeSpaceAgentExecutionApi = void 0;
+class LifeSpaceAgentExecutionApi {
+    constructor() {
+        this.name = 'lifeSpaceAgentExecutionApi';
+        this.displayName = 'LifeSpace Delegated Agent API';
+        this.icon = {
+            light: 'file:lifespace.svg',
+            dark: 'file:lifespace.dark.svg',
+        };
+        this.documentationUrl = 'https://github.com/huangshirui/LifeSpace/blob/main/docs/application-authentication.md';
+        this.properties = [
+            {
+                displayName: 'Core API Base URL',
+                name: 'coreBaseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://core.example.com/api/v1',
+                required: true,
+                description: 'LifeSpace Core API root used by delegated Agent business requests',
+            },
+            {
+                displayName: 'Identity API Base URL',
+                name: 'identityBaseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://identity.example.com',
+                required: true,
+                description: 'LifeSpace Identity origin. Do not include /internal/v1/agent-tokens',
+            },
+            {
+                displayName: 'Application Credential',
+                name: 'applicationSecret',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                placeholder: 'lsa_...',
+                required: true,
+                description: 'Server-only trusted LifeSpace Application credential used only to mint short-lived delegated Agent execution tokens',
+            },
+            {
+                displayName: 'Agent ID',
+                name: 'agentId',
+                type: 'string',
+                default: '',
+                placeholder: 'agt_...',
+                required: true,
+                description: 'LifeSpace Agent identity bound to this registered Application',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.applicationSecret}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.identityBaseUrl.endsWith("/") ? $credentials.identityBaseUrl.slice(0, -1) : $credentials.identityBaseUrl}}',
+                url: '/internal/v1/agents',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.LifeSpaceAgentExecutionApi = LifeSpaceAgentExecutionApi;
+//# sourceMappingURL=LifeSpaceAgentExecutionApi.credentials.js.map

package/dist/credentials/LifeSpaceAgentExecutionApi.credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LifeSpaceAgentExecutionApi.credentials.js","sourceRoot":"","sources":["../../credentials/LifeSpaceAgentExecutionApi.credentials.ts"],"names":[],"mappings":";;;AAOA,MAAa,0BAA0B;IAAvC;QACE,SAAI,GAAG,4BAA4B,CAAC;QAEpC,gBAAW,GAAG,+BAA+B,CAAC;QAE9C,SAAI,GAAG;YACL,KAAK,EAAE,oBAAoB;YAC3B,IAAI,EAAE,yBAAyB;SACvB,CAAC;QAEX,qBAAgB,GAAG,uFAAuF,CAAC;QAE3G,eAAU,GAAsB;YAC9B;gBACE,WAAW,EAAE,mBAAmB;gBAChC,IAAI,EAAE,aAAa;gBACnB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,iCAAiC;gBAC9C,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,mEAAmE;aACjF;YACD;gBACE,WAAW,EAAE,uBAAuB;gBACpC,IAAI,EAAE,iBAAiB;gBACvB,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,8BAA8B;gBAC3C,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,qEAAqE;aACnF;YACD;gBACE,WAAW,EAAE,wBAAwB;gBACrC,IAAI,EAAE,mBAAmB;gBACzB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,SAAS;gBACtB,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,qHAAqH;aACnI;YACD;gBACE,WAAW,EAAE,UAAU;gBACvB,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,SAAS;gBACtB,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,+DAA+D;aAC7E;SACF,CAAC;QAEF,iBAAY,GAAyB;YACnC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACV,OAAO,EAAE;oBACP,aAAa,EAAE,4CAA4C;iBAC5D;aACF;SACF,CAAC;QAEF,SAAI,GAA2B;YAC7B,OAAO,EAAE;gBACP,OAAO,EAAE,4HAA4H;gBACrI,GAAG,EAAE,qBAAqB;gBAC1B,MAAM,EAAE,KAAK;aACd;SACF,CAAC;IACJ,CAAC;CAAA;AApED,gEAoEC"}

package/dist/nodes/LifeSpace/LifeSpace.node.js

@@ -4,6 +4,7 @@ exports.LifeSpace = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const lifespaceDiscovery_1 = require("../lifespaceDiscovery");
 const lifeSpaceActionSnapshot_1 = require("../shared/lifeSpaceActionSnapshot");
+const lifeSpaceExecutionAuthority_1 = require("../shared/lifeSpaceExecutionAuthority");
 const LEGACY_MODEL_ROUTE_TO_KEY = Object.freeze({
     tasks: 'task',
     wishes: 'wish',
@@ -86,6 +87,81 @@ function parseJsonObject(context, itemIndex, value, fieldName) {
     }
     return parsed;
 }
+function batchMutationOperations(context, itemIndex, value, delegated) {
+    let parsed;
+    try {
+        parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), error, { itemIndex });
+    }
+    if (!Array.isArray(parsed) || parsed.length < 1 || parsed.length > 20) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Batch Operations must be a JSON array containing 1 to 20 create/update/delete operations', { itemIndex });
+    }
+    return parsed.map((raw, index) => {
+        var _a, _b, _c, _d;
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} must be a JSON object`, { itemIndex });
+        }
+        const input = raw;
+        const operation = String((_a = input.operation) !== null && _a !== void 0 ? _a : '');
+        const modelKey = String((_b = input.modelKey) !== null && _b !== void 0 ? _b : '').trim();
+        if (!['create', 'update', 'delete'].includes(operation)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} must be create, update, or delete`, { itemIndex });
+        }
+        if (!/^[A-Za-z][A-Za-z0-9_]{0,99}$/u.test(modelKey)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} has an invalid modelKey`, { itemIndex });
+        }
+        const delegationId = String((_c = input.delegationId) !== null && _c !== void 0 ? _c : '').trim();
+        if (delegated && !/^dlg_[A-Za-z0-9_-]+$/u.test(delegationId)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} requires its own valid delegationId in Delegated Agent mode`, { itemIndex });
+        }
+        if (!delegated && delegationId) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} cannot use delegationId in Service Principal mode`, { itemIndex });
+        }
+        if (operation === 'create') {
+            const data = input.data;
+            if (!data || typeof data !== 'object' || Array.isArray(data)) {
+                throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch create ${index} requires an object data field`, { itemIndex });
+            }
+            return {
+                operation: 'create',
+                modelKey,
+                data: data,
+                ...(delegationId ? { delegationId } : {}),
+            };
+        }
+        const recordId = String((_d = input.recordId) !== null && _d !== void 0 ? _d : '').trim();
+        const version = Number(input.version);
+        if (!/^rec_[A-Za-z0-9_-]+$/u.test(recordId)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} has an invalid recordId`, { itemIndex });
+        }
+        if (!Number.isInteger(version) || version < 1) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} requires a positive integer version`, { itemIndex });
+        }
+        if (operation === 'delete') {
+            return {
+                operation: 'delete',
+                modelKey,
+                recordId,
+                version,
+                ...(delegationId ? { delegationId } : {}),
+            };
+        }
+        const data = input.data;
+        if (!data || typeof data !== 'object' || Array.isArray(data) || Object.keys(data).length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch update ${index} requires non-empty object data`, { itemIndex });
+        }
+        return {
+            operation: 'update',
+            modelKey,
+            recordId,
+            version,
+            data: data,
+            ...(delegationId ? { delegationId } : {}),
+        };
+    });
+}
 function mappedValue(context, itemIndex, parameterName) {
     const value = context.getNodeParameter(`${parameterName}.value`, itemIndex, {});
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
@@ -565,7 +641,7 @@ class LifeSpace {
             },
             group: ['transform'],
             version: 1,
-            subtitle: '={{$parameter["resource"] === "modelRecord" ? $parameter["operation"] : "API Request"}}',
+            subtitle: '={{$parameter["resource"] === "modelRecord" ? $parameter["operation"] : ($parameter["resource"] === "batchMutation" ? "Batch Mutation" : "API Request")}}',
             description: 'Use LifeSpace records and APIs in n8n workflows',
             defaults: {
                 name: 'LifeSpace',
@@ -577,6 +653,22 @@ class LifeSpace {
                 {
                     name: 'lifeSpaceApi',
                     required: true,
+                    displayOptions: {
+                        hide: {
+                            resource: ['batchMutation'],
+                            batchAuthorityMode: ['delegatedAgent'],
+                        },
+                    },
+                },
+                {
+                    name: 'lifeSpaceAgentExecutionApi',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['batchMutation'],
+                            batchAuthorityMode: ['delegatedAgent'],
+                        },
+                    },
                 },
             ],
             properties: [
@@ -590,6 +682,10 @@ class LifeSpace {
                             name: 'Record',
                             value: 'modelRecord',
                         },
+                        {
+                            name: 'Batch Mutation',
+                            value: 'batchMutation',
+                        },
                         {
                             name: 'API Request',
                             value: 'apiRequest',
@@ -597,6 +693,50 @@ class LifeSpace {
                     ],
                     default: 'modelRecord',
                 },
+                {
+                    displayName: 'Batch Authority Mode',
+                    name: 'batchAuthorityMode',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['batchMutation'] } },
+                    options: [
+                        {
+                            name: 'Service Principal',
+                            value: 'service',
+                            description: 'Use the existing LifeSpace Service API Token for the atomic Batch',
+                        },
+                        {
+                            name: 'Delegated Agent',
+                            value: 'delegatedAgent',
+                            description: 'Mint one short-lived User Principal -> Agent Actor token; every Batch item supplies its explicit Delegation selector',
+                        },
+                    ],
+                    default: 'service',
+                },
+                {
+                    displayName: 'Principal User ID',
+                    name: 'batchPrincipalUserId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    placeholder: 'usr_...',
+                    displayOptions: {
+                        show: {
+                            resource: ['batchMutation'],
+                            batchAuthorityMode: ['delegatedAgent'],
+                        },
+                    },
+                    description: 'Execution context for delegated Batch only. This value is not part of any AI Tool input.',
+                },
+                {
+                    displayName: 'Batch Operations',
+                    name: 'batchOperations',
+                    type: 'json',
+                    default: '[]',
+                    required: true,
+                    displayOptions: { show: { resource: ['batchMutation'] } },
+                    description: 'JSON array with 1-20 create/update/delete operations. Update/delete require recordId and version. Delegated Agent mode requires delegationId on every item. The adapter sends one atomic Core Batch request and performs no rollback logic itself.',
+                },
                 {
                     displayName: 'Operation',
                     name: 'operation',
@@ -616,7 +756,7 @@ class LifeSpace {
                 {
                     displayName: 'Space Name or ID', name: 'spaceId', type: 'options',
                     typeOptions: { loadOptionsMethod: 'getSpaces' }, options: [], default: '', required: true,
-                    displayOptions: { show: { resource: ['modelRecord'] } },
+                    displayOptions: { show: { resource: ['modelRecord', 'batchMutation'] } },
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
                 },
                 {
@@ -1087,21 +1227,43 @@ class LifeSpace {
         };
     }
     async execute() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const items = this.getInputData();
         const output = [];
-        const credentials = await this.getCredentials('lifeSpaceApi');
-        const baseUrl = (0, lifespaceDiscovery_1.normalizeBaseUrl)(credentials.baseUrl);
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             try {
                 const resource = this.getNodeParameter('resource', itemIndex);
                 let response;
-                if (resource === 'modelRecord') {
+                if (resource === 'batchMutation') {
+                    const rawSpaceId = String(this.getNodeParameter('spaceId', itemIndex)).trim();
+                    if (!rawSpaceId) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LifeSpace Batch Mutation requires a Space ID', { itemIndex });
+                    }
+                    const batchAuthorityMode = String((_a = this.getNodeParameter('batchAuthorityMode', itemIndex, 'service')) !== null && _a !== void 0 ? _a : 'service');
+                    const baseUrl = batchAuthorityMode === 'delegatedAgent'
+                        ? (0, lifeSpaceExecutionAuthority_1.delegatedAgentCoreBaseUrl)(this, await this.getCredentials('lifeSpaceAgentExecutionApi', itemIndex))
+                        : (0, lifespaceDiscovery_1.normalizeBaseUrl)((await this.getCredentials('lifeSpaceApi', itemIndex)).baseUrl);
+                    const operations = batchMutationOperations(this, itemIndex, this.getNodeParameter('batchOperations', itemIndex, '[]'), batchAuthorityMode === 'delegatedAgent');
+                    const authority = await (0, lifeSpaceExecutionAuthority_1.executionAuthority)(this, itemIndex, 'write', {
+                        modeParameter: 'batchAuthorityMode',
+                        principalParameter: 'batchPrincipalUserId',
+                        delegationParameter: 'batchDelegationId',
+                        requireDelegation: false,
+                    });
+                    response = await (0, lifeSpaceExecutionAuthority_1.lifeSpaceRequest)(this, authority, {
+                        method: 'POST',
+                        url: `${baseUrl}/spaces/${encodeURIComponent(rawSpaceId)}/models/batch`,
+                        body: { operations },
+                        json: true,
+                    });
+                }
+                else if (resource === 'modelRecord') {
+                    const baseUrl = (0, lifespaceDiscovery_1.normalizeBaseUrl)((await this.getCredentials('lifeSpaceApi', itemIndex)).baseUrl);
                     const operation = this.getNodeParameter('operation', itemIndex);
                     const rawSpaceId = String(this.getNodeParameter('spaceId', itemIndex));
                     const recordType = (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(this.getNodeParameter('recordType', itemIndex, ''));
-                    const legacyModelRoute = String((_a = this.getNodeParameter('modelRoute', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
-                    const rawModelKey = (_b = recordType === null || recordType === void 0 ? void 0 : recordType.modelKey) !== null && _b !== void 0 ? _b : LEGACY_MODEL_ROUTE_TO_KEY[legacyModelRoute];
+                    const legacyModelRoute = String((_b = this.getNodeParameter('modelRoute', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim();
+                    const rawModelKey = (_c = recordType === null || recordType === void 0 ? void 0 : recordType.modelKey) !== null && _c !== void 0 ? _c : LEGACY_MODEL_ROUTE_TO_KEY[legacyModelRoute];
                     if (!rawModelKey) {
                         throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LifeSpace Record Type selector is invalid. Choose a Record Type from Discovery or pass a Trigger recordType value.', { itemIndex });
                     }
@@ -1110,7 +1272,7 @@ class LifeSpace {
                     const collectionPath = `/spaces/${spaceId}/models/${modelKey}/records`;
                     if (operation === 'list') {
                         const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
-                        const canonical = String((_c = this.getNodeParameter('queryMode', itemIndex, '')) !== null && _c !== void 0 ? _c : '') === 'canonical';
+                        const canonical = String((_d = this.getNodeParameter('queryMode', itemIndex, '')) !== null && _d !== void 0 ? _d : '') === 'canonical';
                         const queryPageRequest = (limit, cursor) => {
                             if (canonical) {
                                 return {
@@ -1203,6 +1365,7 @@ class LifeSpace {
                     }
                 }
                 else {
+                    const baseUrl = (0, lifespaceDiscovery_1.normalizeBaseUrl)((await this.getCredentials('lifeSpaceApi', itemIndex)).baseUrl);
                     const method = this.getNodeParameter('method', itemIndex);
                     const path = String(this.getNodeParameter('path', itemIndex));
                     const options = {