n8n-nodes-lifespace 0.1.23 → 0.1.25

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,15 @@ 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. **Create / Update / Delete expose an optional Batch Mode under Record Options, default Off.** When enabled, the node consumes the incoming n8n `items[]` directly, requires 1-20 items resolving to one Space and one Record Type, and sends exactly one atomic Core Batch request. The response is expanded back to one n8n output item per input item with preserved pairing and a shared `changeSetId`.
+
+Update/Delete `Version` remains optional in both modes. In single mode, omission keeps the historical behavior of reading the current record immediately before mutation. In Batch Mode, omission is delegated to the LifeSpace Batch contract: Core resolves current versions set-wise during Batch preparation and still commits conditionally, so there is no N-read HTTP waterfall and no blind write.
+
+**Advanced Mixed Batch** remains available for workflows that deliberately need mixed create/update/delete or cross-Record-Type operations in one atomic ChangeSet. It uses the explicit JSON operations surface and is not the primary Batch UX.
+
+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 not exposed by this workflow-UX change; they can be added separately against the same upstream optional-version Batch semantics without reintroducing N pre-read HTTP calls.
+
+Ordinary Record operations remain:
 
 - **Create**;
 - **Get**;
@@ -333,13 +343,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 Agent Execution 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 Agent business requests and Delegation creation',
+            },
+            {
+                displayName: 'Identity API Base URL',
+                name: 'identityBaseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://identity.example.com',
+                required: true,
+                description: 'LifeSpace Identity origin. Do not include an /internal/v1 token route.',
+            },
+            {
+                displayName: 'Application Credential',
+                name: 'applicationSecret',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                placeholder: 'lsa_...',
+                required: true,
+                description: 'Server-only trusted LifeSpace Application credential used to mint short-lived User and 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,iFAAiF;aAC/F;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,wEAAwE;aACtF;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,+GAA+G;aAC7H;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,86 @@ 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 rawVersion = input.version;
+        let version;
+        if (rawVersion !== undefined && rawVersion !== null && rawVersion !== '') {
+            const parsedVersion = Number(rawVersion);
+            if (!Number.isInteger(parsedVersion) || parsedVersion < 1) {
+                throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Batch operation ${index} version must be a positive integer when supplied`, { itemIndex });
+            }
+            version = parsedVersion;
+        }
+        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 (operation === 'delete') {
+            return {
+                operation: 'delete',
+                modelKey,
+                recordId,
+                ...(version === undefined ? {} : { 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 === undefined ? {} : { 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 : {};
@@ -464,13 +545,120 @@ async function currentRecord(context, itemIndex, baseUrl, recordPath) {
 async function currentRecordVersion(context, itemIndex, baseUrl, recordPath) {
     return recordVersion(context, itemIndex, await currentRecord(context, itemIndex, baseUrl, recordPath));
 }
-async function mutationVersion(context, itemIndex, baseUrl, recordPath) {
+function configuredMutationVersion(context, itemIndex) {
     const options = context.getNodeParameter('mutationOptions', itemIndex, {});
     const configuredVersion = options.version;
+    if (configuredVersion === undefined || configuredVersion === null || configuredVersion === '') {
+        return undefined;
+    }
     if (typeof configuredVersion === 'number' && Number.isInteger(configuredVersion) && configuredVersion >= 1) {
         return configuredVersion;
     }
-    return currentRecordVersion(context, itemIndex, baseUrl, recordPath);
+    throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Version must be a positive integer when supplied', { itemIndex });
+}
+async function mutationVersion(context, itemIndex, baseUrl, recordPath) {
+    var _a;
+    return (_a = configuredMutationVersion(context, itemIndex)) !== null && _a !== void 0 ? _a : currentRecordVersion(context, itemIndex, baseUrl, recordPath);
+}
+function recordBatchMode(context, itemIndex) {
+    const options = context.getNodeParameter('recordOptions', itemIndex, {});
+    return options.batchMode === true;
+}
+function configuredRecordModelKey(context, itemIndex) {
+    var _a, _b;
+    const recordType = (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(context.getNodeParameter('recordType', itemIndex, ''));
+    const legacyModelRoute = String((_a = context.getNodeParameter('modelRoute', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    const modelKey = (_b = recordType === null || recordType === void 0 ? void 0 : recordType.modelKey) !== null && _b !== void 0 ? _b : LEGACY_MODEL_ROUTE_TO_KEY[legacyModelRoute];
+    if (!modelKey) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Record Type selector is invalid. Choose a Record Type from Discovery or pass a Trigger recordType value.', { itemIndex });
+    }
+    return modelKey;
+}
+async function executeNativeRecordBatch(context, items) {
+    var _a, _b, _c, _d, _e;
+    if (items.length < 1)
+        return [];
+    if (items.length > 20) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Batch Mode accepts at most 20 input items and never auto-chunks an atomic Batch');
+    }
+    const operation = String(context.getNodeParameter('operation', 0, ''));
+    if (!['create', 'update', 'delete'].includes(operation)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Batch Mode is available only for Create, Update, or Delete');
+    }
+    let sourceSpaceId = '';
+    let sourceModelKey = '';
+    const operations = [];
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+        const itemOperation = String(context.getNodeParameter('operation', itemIndex, operation));
+        if (itemOperation !== operation) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'All input items in LifeSpace Batch Mode must use the same operation', { itemIndex });
+        }
+        const rawSpaceId = String((_a = context.getNodeParameter('spaceId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+        if (!rawSpaceId) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Batch Mode requires a Space ID', { itemIndex });
+        }
+        const modelKey = configuredRecordModelKey(context, itemIndex);
+        if (!sourceSpaceId)
+            sourceSpaceId = rawSpaceId;
+        if (!sourceModelKey)
+            sourceModelKey = modelKey;
+        if (rawSpaceId !== sourceSpaceId || modelKey !== sourceModelKey) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'All input items in LifeSpace Batch Mode must resolve to the same Space and Record Type', { itemIndex });
+        }
+        if (operation === 'create') {
+            operations.push({
+                operation: 'create',
+                modelKey,
+                data: mutationMappedValues(context, itemIndex),
+            });
+            continue;
+        }
+        const recordId = String((_b = context.getNodeParameter('recordId', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim();
+        if (!/^rec_[A-Za-z0-9_-]+$/u.test(recordId)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Record ID must be a valid rec_* identifier in Batch Mode', { itemIndex });
+        }
+        const version = configuredMutationVersion(context, itemIndex);
+        if (operation === 'delete') {
+            operations.push({
+                operation: 'delete',
+                modelKey,
+                recordId,
+                ...(version === undefined ? {} : { version }),
+            });
+            continue;
+        }
+        operations.push({
+            operation: 'update',
+            modelKey,
+            recordId,
+            ...(version === undefined ? {} : { version }),
+            data: mutationMappedValues(context, itemIndex),
+        });
+    }
+    const baseUrl = (0, lifespaceDiscovery_1.normalizeBaseUrl)((await context.getCredentials('lifeSpaceApi', 0)).baseUrl);
+    const response = await context.helpers.httpRequestWithAuthentication.call(context, 'lifeSpaceApi', {
+        method: 'POST',
+        url: `${baseUrl}/spaces/${encodeURIComponent(sourceSpaceId)}/models/batch`,
+        body: { operations },
+        json: true,
+    });
+    const changeSetId = String((_d = (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.changeSetId) !== null && _d !== void 0 ? _d : '').trim();
+    const results = (_e = response === null || response === void 0 ? void 0 : response.data) === null || _e === void 0 ? void 0 : _e.items;
+    if (!/^cgs_[A-Za-z0-9_-]+$/u.test(changeSetId) || !Array.isArray(results) || results.length !== items.length) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Batch response did not match the input item count or ChangeSet contract');
+    }
+    return results.map((result, itemIndex) => {
+        if (!result || typeof result !== 'object' || Array.isArray(result)) {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `LifeSpace Batch result ${itemIndex} is invalid`, { itemIndex });
+        }
+        return {
+            json: {
+                ...result,
+                changeSetId,
+            },
+            pairedItem: { item: itemIndex },
+        };
+    });
 }
 async function actionBodyWithConcurrency(context, itemIndex, baseUrl, recordPath, action, semanticInput) {
     const normalizedInput = normalizeActionInput(context, itemIndex, semanticInput, action.input.fields);
@@ -565,7 +753,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 +765,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 +794,10 @@ class LifeSpace {
                             name: 'Record',
                             value: 'modelRecord',
                         },
+                        {
+                            name: 'Advanced Mixed Batch',
+                            value: 'batchMutation',
+                        },
                         {
                             name: 'API Request',
                             value: 'apiRequest',
@@ -597,6 +805,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: 'Advanced JSON surface for one atomic mixed/cross-model Batch. Update/delete require recordId; version is optional when the current Core Batch contract supports server-resolved concurrency. Delegated Agent mode requires delegationId on every item.',
+                },
                 {
                     displayName: 'Operation',
                     name: 'operation',
@@ -613,10 +865,26 @@ class LifeSpace {
                     ],
                     default: 'list',
                 },
+                {
+                    displayName: 'Options',
+                    name: 'recordOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['create', 'update', 'delete'] } },
+                    options: [{
+                            displayName: 'Batch Mode',
+                            name: 'batchMode',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to send all incoming n8n items as one atomic LifeSpace Batch. Limited to 20 items in one Space and Record Type; the node never auto-chunks because that would weaken atomic semantics.',
+                        }],
+                },
                 {
                     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>',
                 },
                 {
@@ -821,7 +1089,7 @@ class LifeSpace {
                 {
                     displayName: 'Concurrency Options', name: 'mutationOptions', type: 'collection', placeholder: 'Add Option', default: {},
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['update', 'delete'] } },
-                    options: [{ displayName: 'Version', name: 'version', type: 'number', typeOptions: { minValue: 1, numberPrecision: 0 }, default: 1, description: 'Optional known record version. If omitted, the node reads the current record version immediately before the mutation.' }],
+                    options: [{ displayName: 'Version', name: 'version', type: 'number', typeOptions: { minValue: 1, numberPrecision: 0 }, default: 1, description: 'Optional known record version. In single mode, omission makes the node read the current version immediately before mutation. In Batch Mode, omission is sent to Core for set-wise current-version resolution before atomic commit.' }],
                 },
                 {
                     displayName: 'Action Name or ID', name: 'actionKey', type: 'options', noDataExpression: true,
@@ -1087,30 +1355,67 @@ class LifeSpace {
         };
     }
     async execute() {
-        var _a, _b, _c;
+        var _a, _b;
         const items = this.getInputData();
+        if (items.length > 0) {
+            const resource = this.getNodeParameter('resource', 0);
+            const operation = this.getNodeParameter('operation', 0, '');
+            if (resource === 'modelRecord'
+                && ['create', 'update', 'delete'].includes(operation)
+                && recordBatchMode(this, 0)) {
+                try {
+                    return [await executeNativeRecordBatch(this, items)];
+                }
+                catch (error) {
+                    if (this.continueOnFail()) {
+                        return [items.map((_item, itemIndex) => ({
+                                json: { error: error instanceof Error ? error.message : String(error) },
+                                pairedItem: { item: itemIndex },
+                            }))];
+                    }
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error);
+                }
+            }
+        }
         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];
-                    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 });
-                    }
+                    const rawModelKey = configuredRecordModelKey(this, itemIndex);
                     const spaceId = encodeURIComponent(rawSpaceId);
                     const modelKey = encodeURIComponent(rawModelKey);
                     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((_b = this.getNodeParameter('queryMode', itemIndex, '')) !== null && _b !== void 0 ? _b : '') === 'canonical';
                         const queryPageRequest = (limit, cursor) => {
                             if (canonical) {
                                 return {
@@ -1203,6 +1508,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 = {