n8n-nodes-lifespace 0.2.0 → 0.2.2

package/dist/nodes/LifeSpaceAgentTool/LifeSpaceAgentTool.node.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LifeSpaceAgentTool = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const lifeSpaceMultiMutationTool_1 = require("../agent/lifeSpaceMultiMutationTool");
+const lifeSpacePersonTool_1 = require("../agent/lifeSpacePersonTool");
 const lifeSpaceToolSnapshot_1 = require("../agent/lifeSpaceToolSnapshot");
 const LifeSpaceTool_node_1 = require("../LifeSpaceTool/LifeSpaceTool.node");
+const lifeSpaceExecutionAuthority_1 = require("../shared/lifeSpaceExecutionAuthority");
 const LEGACY_AUTH_PARAMETERS = new Set([
     'authorityMode',
     'principalUserId',
     'delegationId',
     'readDelegationId',
-    'batchDelegationIds',
 ]);
 const USER_AUTH_RECOVERABLE_CODES = new Set([
     'DELEGATION_REQUIRED',
@@ -16,6 +19,7 @@ const USER_AUTH_RECOVERABLE_CODES = new Set([
     'DELEGATION_SCOPE_INSUFFICIENT',
     'PRINCIPAL_AUTHORITY_INSUFFICIENT',
 ]);
+const FROM_AI_KEY = /\$fromAI\s*\(\s*(['"])([A-Za-z0-9_-]{1,64})\1/u;
 function internalOnly(property) {
     if (!LEGACY_AUTH_PARAMETERS.has(property.name))
         return property;
@@ -47,13 +51,107 @@ function authorizationProperties() {
         },
     ];
 }
+function toolResourceProperty() {
+    return {
+        displayName: 'Resource',
+        name: 'toolResource',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+            {
+                name: 'Record',
+                value: 'record',
+                description: 'Use one ordinary metadata-driven LifeSpace model through Runtime Discovery',
+            },
+            {
+                name: 'Person',
+                value: 'person',
+                description: 'Use the Kernel first-class Space Person Directory',
+            },
+        ],
+        default: 'record',
+    };
+}
+function personOperationProperty() {
+    return {
+        displayName: 'Operation',
+        name: 'personOperation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: { show: { toolResource: ['person'] } },
+        options: [
+            { name: 'Create Person', value: 'create', action: 'Create a person', description: 'Create an unlinked Space Person' },
+            { name: 'Delete Person', value: 'delete', action: 'Delete a person', description: 'Delete an unlinked Space Person using current optimistic concurrency' },
+            { name: 'Get Person', value: 'get', action: 'Get a person', description: 'Get one Space Person by stable per_* ID' },
+            { name: 'List / Search People', value: 'list', action: 'List or search people', description: 'Search canonical and alternate Person names with bounded cursor pagination' },
+            { name: 'Update Person', value: 'update', action: 'Update a person', description: 'Update canonical or alternate Person names using current optimistic concurrency' },
+        ],
+        default: 'list',
+    };
+}
+function recordOptionsProperty() {
+    return {
+        displayName: 'Options',
+        name: 'recordOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: { batchProcessing: true },
+        displayOptions: {
+            show: {
+                toolResource: ['record'],
+                operation: ['create', 'update', 'delete'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Batch Processing',
+                name: 'batchProcessing',
+                type: 'boolean',
+                default: true,
+                noDataExpression: true,
+                description: 'Whether to group 1-20 Tool items into one LifeSpace request. Defaults on. When enabled without Atomic Consistency, items succeed or fail independently and partial success is preserved.',
+            },
+            {
+                displayName: 'Atomic Consistency',
+                name: 'atomicConsistency',
+                type: 'boolean',
+                default: false,
+                description: 'Whether all items must commit together or roll back together. Leave off for normal independent Bulk processing. In an AI Agent workflow, use n8n\'s “Let the model define this parameter” control only when the Agent should decide per Tool call whether the user\'s intent requires all-or-none semantics.',
+            },
+        ],
+    };
+}
+function withRecordOnly(property) {
+    var _a;
+    if (property.name === 'operation') {
+        return {
+            ...property,
+            options: ((_a = property.options) !== null && _a !== void 0 ? _a : []).filter((option) => !('value' in option) || option.value !== 'batchCreate'),
+            displayOptions: { show: { toolResource: ['record'] } },
+        };
+    }
+    if (property.name === 'recordType') {
+        return { ...property, displayOptions: { show: { toolResource: ['record'] } } };
+    }
+    if (property.name === 'actionKey') {
+        return {
+            ...property,
+            displayOptions: { show: { toolResource: ['record'], operation: ['action'] } },
+        };
+    }
+    return property;
+}
 function agentProperties(properties) {
     const projected = properties
-        .filter((property) => property.name !== 'queryMode' && property.name !== 'capabilityQueryKey')
-        .map(internalOnly);
+        .filter((property) => !['queryMode', 'capabilityQueryKey', 'batchDelegationIds'].includes(property.name))
+        .map(internalOnly)
+        .map(withRecordOnly);
     const spaceIndex = projected.findIndex((property) => property.name === 'spaceId');
     const insertAt = spaceIndex >= 0 ? spaceIndex : 0;
-    projected.splice(insertAt, 0, ...authorizationProperties());
+    projected.splice(insertAt, 0, ...authorizationProperties(), toolResourceProperty());
+    const actualSpaceIndex = projected.findIndex((property) => property.name === 'spaceId');
+    projected.splice(actualSpaceIndex + 1, 0, personOperationProperty());
+    projected.push(recordOptionsProperty());
     return projected;
 }
 function agentExecutionContext(context, itemIndex, principalUserId, delegationId) {
@@ -68,8 +166,6 @@ function agentExecutionContext(context, itemIndex, principalUserId, delegationId
                     return delegationId ? principalUserId : '';
                 if (name === 'delegationId' || name === 'readDelegationId')
                     return delegationId;
-                if (name === 'batchDelegationIds')
-                    return '[]';
                 return target.getNodeParameter(name, requestedItemIndex !== null && requestedItemIndex !== void 0 ? requestedItemIndex : itemIndex, fallback, options);
             };
         },
@@ -100,29 +196,84 @@ function requiredAccess(operation, actionKey, snapshot) {
     var _a;
     if (operation === 'query')
         return 'read';
-    if (['create', 'batchCreate', 'update', 'delete'].includes(operation))
+    if (['create', 'update', 'delete'].includes(operation))
         return 'write';
     if (operation !== 'action' || !snapshot)
         return null;
     const access = (_a = snapshot.model.actions.find((action) => action.key === actionKey)) === null || _a === void 0 ? void 0 : _a.access;
     return access === 'read' || access === 'write' || access === 'manage' ? access : null;
 }
+function currentRecordOperation(context, itemIndex) {
+    var _a;
+    const operation = String((_a = context.getNodeParameter('operation', itemIndex, 'query')) !== null && _a !== void 0 ? _a : 'query');
+    if (operation === 'batchCreate') {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Legacy Agent Tool operation batchCreate is no longer supported. Select Create and configure Batch Processing / Atomic Consistency under Options.');
+    }
+    return operation;
+}
+function rawRecordOptions(context) {
+    var _a;
+    const node = context.getNode();
+    const raw = (_a = node.parameters) === null || _a === void 0 ? void 0 : _a.recordOptions;
+    return raw && typeof raw === 'object' && !Array.isArray(raw)
+        ? raw
+        : {};
+}
+function fromAiKey(value) {
+    var _a, _b;
+    if (typeof value !== 'string')
+        return null;
+    return (_b = (_a = FROM_AI_KEY.exec(value)) === null || _a === void 0 ? void 0 : _a[2]) !== null && _b !== void 0 ? _b : null;
+}
+function recordBatchSettings(context, itemIndex) {
+    var _a;
+    const raw = rawRecordOptions(context);
+    const atomicFromAiKey = fromAiKey(raw.atomicConsistency);
+    const evaluated = atomicFromAiKey
+        ? {}
+        : context.getNodeParameter('recordOptions', itemIndex, {});
+    const batchValue = (_a = raw.batchProcessing) !== null && _a !== void 0 ? _a : evaluated.batchProcessing;
+    return {
+        batchProcessing: batchValue === undefined ? true : batchValue === true,
+        atomicConsistency: atomicFromAiKey
+            ? false
+            : raw.atomicConsistency === true || evaluated.atomicConsistency === true,
+        atomicFromAiKey,
+    };
+}
 function authorizationScope(context, itemIndex, semantic) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const spaceId = String((_a = context.getNodeParameter('spaceId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    if (!spaceId)
+        return null;
+    const resource = String((_b = context.getNodeParameter('toolResource', itemIndex, 'record')) !== null && _b !== void 0 ? _b : 'record');
+    if (resource === 'person') {
+        const operation = String((_c = context.getNodeParameter('personOperation', itemIndex, 'list')) !== null && _c !== void 0 ? _c : 'list');
+        return {
+            spaceId,
+            scopes: [{
+                    target: { type: 'space', id: spaceId },
+                    maxAccess: (0, lifeSpacePersonTool_1.personToolRequiredAccess)(operation),
+                }],
+        };
+    }
     const snapshot = (0, lifeSpaceToolSnapshot_1.decodeAgentToolSemanticSnapshot)(context.getNodeParameter('recordType', itemIndex, ''));
-    if (!spaceId || !snapshot)
+    if (!snapshot)
         return null;
-    const operation = String((_b = context.getNodeParameter('operation', itemIndex, '')) !== null && _b !== void 0 ? _b : '');
-    const actionKey = String((_c = context.getNodeParameter('actionKey', itemIndex, '')) !== null && _c !== void 0 ? _c : '').trim();
+    const operation = currentRecordOperation(context, itemIndex);
+    const actionKey = String((_d = context.getNodeParameter('actionKey', itemIndex, '')) !== null && _d !== void 0 ? _d : '').trim();
     const access = requiredAccess(operation, actionKey, snapshot);
     if (!access)
         return null;
+    const batchProcessing = ['create', 'update', 'delete'].includes(operation)
+        ? recordBatchSettings(context, itemIndex).batchProcessing
+        : false;
     const input = semantic && typeof semantic === 'object' && !Array.isArray(semantic)
         ? semantic
         : {};
-    const recordId = String((_d = input.recordId) !== null && _d !== void 0 ? _d : '').trim();
-    const recordScoped = ['update', 'delete', 'action'].includes(operation)
+    const recordId = String((_e = input.recordId) !== null && _e !== void 0 ? _e : '').trim();
+    const recordScoped = !batchProcessing
+        && ['update', 'delete', 'action'].includes(operation)
         && /^rec_[A-Za-z0-9_-]+$/u.test(recordId);
     const scope = recordScoped
         ? { target: { type: 'record', id: recordId }, maxAccess: access }
@@ -161,6 +312,330 @@ function withAuthorizationRequired(output, required) {
         authorizationRequired: required,
     });
 }
+function parseJsonCandidate(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function structuredFailure(error) {
+    var _a;
+    const queue = [error];
+    const seen = new Set();
+    while (queue.length) {
+        const current = parseJsonCandidate(queue.shift());
+        if (!current || typeof current !== 'object' || Array.isArray(current) || seen.has(current))
+            continue;
+        seen.add(current);
+        const object = current;
+        const nested = object.error;
+        if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+            const apiError = nested;
+            const code = String((_a = apiError.code) !== null && _a !== void 0 ? _a : '');
+            if (code) {
+                return JSON.stringify({
+                    ok: false,
+                    error: {
+                        code,
+                        message: typeof apiError.message === 'string' ? apiError.message : 'LifeSpace Tool call failed',
+                        retryable: false,
+                        nextAction: USER_AUTH_RECOVERABLE_CODES.has(code) ? 'request_authorization' : 'report_failure',
+                    },
+                });
+            }
+        }
+        for (const key of ['body', 'data', 'response', 'cause', 'description', 'message']) {
+            if (object[key] !== undefined)
+                queue.push(object[key]);
+        }
+    }
+    return JSON.stringify({
+        ok: false,
+        error: {
+            code: 'LIFESPACE_TOOL_CALL_FAILED',
+            message: error instanceof Error ? error.message : 'LifeSpace Tool call failed',
+            retryable: false,
+            nextAction: 'report_failure',
+        },
+    });
+}
+function stringifyToolOutput(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined)
+        return JSON.stringify({ success: true });
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function requestOptions(baseUrl, request) {
+    const options = {
+        method: request.method,
+        url: `${baseUrl}${request.path}`,
+        json: true,
+    };
+    if (request.qs && Object.keys(request.qs).length)
+        options.qs = request.qs;
+    if (request.body)
+        options.body = request.body;
+    if (request.repeatQueryArrays)
+        options.arrayFormat = 'repeat';
+    return options;
+}
+function currentVersion(context, response) {
+    if (!response || typeof response !== 'object' || Array.isArray(response)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace current-resource lookup returned an invalid response');
+    }
+    const data = response.data;
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace current-resource lookup returned an invalid data envelope');
+    }
+    const version = data.version;
+    if (typeof version !== 'number' || !Number.isInteger(version) || version < 1) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace current-resource lookup did not expose a usable version');
+    }
+    return version;
+}
+async function agentBaseUrl(context, itemIndex) {
+    return (0, lifeSpaceExecutionAuthority_1.delegatedAgentCoreBaseUrl)(context, await context.getCredentials('lifeSpaceAgentExecutionApi', itemIndex));
+}
+function inputForLog(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { value: String(value !== null && value !== void 0 ? value : '') };
+}
+function semanticToolInput(schema, value) {
+    if (typeof value.toolCallId !== 'string')
+        return value;
+    const input = {};
+    for (const key of Object.keys(schema.properties)) {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            input[key] = value[key];
+    }
+    if (Object.prototype.hasOwnProperty.call(value, 'delegationId'))
+        input.delegationId = value.delegationId;
+    return input;
+}
+async function invokePerson(context, itemIndex, semantic, delegationId) {
+    var _a, _b;
+    const operation = String((_a = context.getNodeParameter('personOperation', itemIndex, 'list')) !== null && _a !== void 0 ? _a : 'list');
+    const spaceId = String((_b = context.getNodeParameter('spaceId', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim();
+    const executionContext = agentExecutionContext(context, itemIndex, '', delegationId);
+    const authority = await (0, lifeSpaceExecutionAuthority_1.executionAuthority)(executionContext, itemIndex, (0, lifeSpacePersonTool_1.personToolRequiredAccess)(operation), { requireDelegation: false });
+    const baseUrl = await agentBaseUrl(executionContext, itemIndex);
+    let request = (0, lifeSpacePersonTool_1.buildPersonToolRequest)(spaceId, operation, semantic);
+    if (request.needsCurrentVersion) {
+        const current = await (0, lifeSpaceExecutionAuthority_1.lifeSpaceRequest)(executionContext, authority, {
+            method: 'GET',
+            url: `${baseUrl}${request.path}`,
+            json: true,
+        });
+        request = (0, lifeSpacePersonTool_1.buildPersonToolRequest)(spaceId, operation, semantic, currentVersion(context, current));
+    }
+    const response = await (0, lifeSpaceExecutionAuthority_1.lifeSpaceRequest)(executionContext, authority, requestOptions(baseUrl, request));
+    return stringifyToolOutput(response);
+}
+async function personRuntime(context, itemIndex) {
+    var _a, _b, _c;
+    const spaceId = String((_a = context.getNodeParameter('spaceId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    const operation = String((_b = context.getNodeParameter('personOperation', itemIndex, 'list')) !== null && _b !== void 0 ? _b : 'list');
+    const descriptionOverride = String((_c = context.getNodeParameter('descriptionOverride', itemIndex, '')) !== null && _c !== void 0 ? _c : '').trim();
+    const definition = (0, lifeSpacePersonTool_1.buildPersonToolDefinition)(spaceId, null, operation, descriptionOverride);
+    return {
+        baseUrl: await agentBaseUrl(context, itemIndex),
+        spaceId,
+        schema: definition.schema,
+        name: definition.name,
+        description: definition.description,
+        metadata: { lifeSpaceResource: 'person', lifeSpacePersonOperation: operation },
+        requiredAccess: definition.requiredAccess,
+    };
+}
+function dynamicAtomicDescription(model, config, operation, key) {
+    var _a, _b, _c, _d;
+    const plural = ((_a = model.display.plural) === null || _a === void 0 ? void 0 : _a.trim()) || `${((_b = model.display.singular) === null || _b === void 0 ? void 0 : _b.trim()) || model.key}s`;
+    const verb = operation === 'create' ? 'Create' : operation === 'update' ? 'Update' : 'Delete';
+    const base = ((_c = config.descriptionOverride) === null || _c === void 0 ? void 0 : _c.trim())
+        || `${verb} 1-20 ${plural} in Space "${((_d = config.spaceName) === null || _d === void 0 ? void 0 : _d.trim()) || config.spaceId}".`;
+    const recordGuidance = operation === 'create'
+        ? ''
+        : ' Versions are resolved when omitted. Use stable record IDs; never guess them.';
+    return `${base} "${key}" defaults false: non-atomic Bulk; items commit independently and partial success is possible. Set true only when the user requires all items in this Tool call to commit or roll back together. Item count alone is not a reason to choose atomic. Atomicity never spans Tool calls, operations, models, or Spaces. After Bulk partial failure, retry only failed items; never resend succeeded items.${recordGuidance}`;
+}
+async function multiRuntime(context, itemIndex) {
+    var _a, _b;
+    const spaceId = String((_a = context.getNodeParameter('spaceId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    const snapshot = (0, lifeSpaceToolSnapshot_1.decodeAgentToolSemanticSnapshot)(context.getNodeParameter('recordType', itemIndex, ''));
+    if (!snapshot || snapshot.spaceId !== spaceId) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'This LifeSpace Agent Tool has no valid saved semantic contract. Reselect Record Type and save the workflow.');
+    }
+    const operation = currentRecordOperation(context, itemIndex);
+    if (!['create', 'update', 'delete'].includes(operation)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Batch Processing is supported only for create/update/delete');
+    }
+    const batchSettings = recordBatchSettings(context, itemIndex);
+    if (!batchSettings.batchProcessing) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace multi-mutation requires Batch Processing to be enabled');
+    }
+    const mode = batchSettings.atomicConsistency ? 'atomic' : 'bulk';
+    const config = {
+        spaceId,
+        spaceName: snapshot.spaceName,
+        operation,
+        queryMode: 'generic',
+        actionKey: '',
+        capabilityQueryKey: '',
+        descriptionOverride: String((_b = context.getNodeParameter('descriptionOverride', itemIndex, '')) !== null && _b !== void 0 ? _b : '').trim(),
+        viewingTimezone: context.getTimezone(),
+    };
+    const definition = (0, lifeSpaceMultiMutationTool_1.buildMultiMutationDefinition)(snapshot.model, config, operation, mode);
+    const atomicFromAiKey = batchSettings.atomicFromAiKey;
+    const schema = atomicFromAiKey
+        ? {
+            ...definition.schema,
+            properties: {
+                ...definition.schema.properties,
+                [atomicFromAiKey]: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'All-or-none for this Tool call. Defaults false. Set true only when the user requires every item to commit together; item count alone does not imply atomicity.',
+                },
+            },
+        }
+        : definition.schema;
+    return {
+        baseUrl: await agentBaseUrl(context, itemIndex),
+        spaceId,
+        schema,
+        name: definition.name,
+        description: atomicFromAiKey
+            ? dynamicAtomicDescription(snapshot.model, config, operation, atomicFromAiKey)
+            : definition.description,
+        metadata: {
+            lifeSpaceModelVersion: snapshot.model.version,
+            lifeSpaceSchemaHash: snapshot.model.schemaHash,
+            lifeSpaceMutationMode: atomicFromAiKey ? 'agent-controlled' : mode,
+            ...(atomicFromAiKey ? { lifeSpaceAtomicConsistencyArgument: atomicFromAiKey } : {}),
+        },
+        requiredAccess: 'write',
+        model: snapshot.model,
+        config,
+        operation,
+        mode,
+        atomicFromAiKey,
+    };
+}
+function selectedMultiMode(context, runtime, semantic) {
+    if (!runtime.atomicFromAiKey)
+        return { mode: runtime.mode, semantic };
+    if (!semantic || typeof semantic !== 'object' || Array.isArray(semantic)) {
+        return { mode: 'bulk', semantic };
+    }
+    const input = { ...semantic };
+    const rawAtomic = input[runtime.atomicFromAiKey];
+    delete input[runtime.atomicFromAiKey];
+    if (rawAtomic !== undefined && typeof rawAtomic !== 'boolean') {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `LifeSpace Atomic Consistency Tool argument ${runtime.atomicFromAiKey} must be boolean`);
+    }
+    return { mode: rawAtomic === true ? 'atomic' : 'bulk', semantic: input };
+}
+async function invokeMulti(context, itemIndex, semantic, delegationId) {
+    var _a;
+    const runtime = await multiRuntime(context, itemIndex);
+    const selected = selectedMultiMode(context, runtime, semantic);
+    const executionContext = agentExecutionContext(context, itemIndex, '', delegationId);
+    const authority = await (0, lifeSpaceExecutionAuthority_1.executionAuthority)(executionContext, itemIndex, 'write', { requireDelegation: false });
+    const requester = async (options) => (0, lifeSpaceExecutionAuthority_1.lifeSpaceRequest)(executionContext, authority, options);
+    const prepared = await (0, lifeSpaceMultiMutationTool_1.prepareMultiMutationInput)(executionContext, runtime.baseUrl, runtime.model, runtime.config, runtime.operation, runtime.schema, selected.semantic, requester);
+    const request = (0, lifeSpaceMultiMutationTool_1.buildMultiMutationRequest)(runtime.model, runtime.config, runtime.operation, selected.mode, prepared, authority.mode === 'delegatedAgent' ? (_a = authority.delegationId) !== null && _a !== void 0 ? _a : '' : '');
+    const outerAuthority = authority.mode === 'delegatedAgent'
+        ? { ...authority, delegationId: null }
+        : authority;
+    const response = await (0, lifeSpaceExecutionAuthority_1.lifeSpaceRequest)(executionContext, outerAuthority, requestOptions(runtime.baseUrl, request));
+    return stringifyToolOutput(response);
+}
+function customTool(context, itemIndex, runtime, invoke) {
+    return {
+        name: (0, n8n_workflow_1.nodeNameToToolName)(context.getNode()),
+        description: runtime.description,
+        schema: runtime.schema,
+        metadata: {
+            lifeSpaceSemanticToolName: runtime.name,
+            ...runtime.metadata,
+        },
+        invoke: async (query) => {
+            const { index } = context.addInputData(n8n_workflow_1.NodeConnectionTypes.AiTool, [[{ json: { query: inputForLog(query) } }]]);
+            let output;
+            try {
+                output = await invoke(query);
+            }
+            catch (error) {
+                output = structuredFailure(error);
+            }
+            void context.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, [[{ json: { response: output } }]]);
+            return output;
+        },
+    };
+}
+function authorizationSettings(context, itemIndex) {
+    var _a;
+    const enabled = Boolean(context.getNodeParameter('enableUserAuthorization', itemIndex, false));
+    return {
+        enabled,
+        principalUserId: enabled
+            ? String((_a = context.getNodeParameter('authorizationPrincipalUserId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim()
+            : '',
+    };
+}
+function wrapOptionalAuthorization(context, itemIndex, baseTool, principalUserId, invokeWithDelegation) {
+    const schema = {
+        ...baseTool.schema,
+        properties: {
+            ...baseTool.schema.properties,
+            delegationId: {
+                type: 'string',
+                description: 'Optional LifeSpace dlg_* returned by a successful authorization confirmation. Omit it to execute with the Agent\'s own Authority.',
+            },
+        },
+    };
+    return {
+        ...baseTool,
+        description: `${baseTool.description} When user authorization is required, pass the dlg_* returned by LifeSpace Confirm Authorization as delegationId. Omit delegationId to use the Agent's own Authority.`,
+        schema,
+        metadata: { ...baseTool.metadata, lifeSpaceUserAuthorization: 'optional' },
+        invoke: async (query) => {
+            const { semantic, delegationId } = toolInput(query);
+            if (delegationId && !/^dlg_[A-Za-z0-9_-]+$/u.test(delegationId))
+                return invalidDelegationOutput();
+            if (delegationId && !/^usr_[A-Za-z0-9_-]+$/u.test(principalUserId)) {
+                return JSON.stringify({
+                    ok: false,
+                    error: {
+                        code: 'USER_CONTEXT_REQUIRED',
+                        message: 'A trusted Principal User ID is required to use delegationId',
+                        retryable: false,
+                        nextAction: 'report_failure',
+                    },
+                });
+            }
+            let output;
+            try {
+                output = await invokeWithDelegation(semantic, delegationId);
+            }
+            catch (error) {
+                output = structuredFailure(error);
+            }
+            return withAuthorizationRequired(output, authorizationScope(context, itemIndex, semantic));
+        },
+    };
+}
 class LifeSpaceAgentTool extends LifeSpaceTool_node_1.LifeSpaceTool {
     constructor() {
         super();
@@ -170,7 +645,7 @@ class LifeSpaceAgentTool extends LifeSpaceTool_node_1.LifeSpaceTool {
                 light: 'file:lifespace.svg',
                 dark: 'file:lifespace.dark.svg',
             },
-            description: 'Expose one scoped LifeSpace operation to an AI Agent',
+            description: 'Expose one scoped LifeSpace Record or Person operation to an AI Agent',
             credentials: [
                 {
                     name: 'lifeSpaceAgentExecutionApi',
@@ -182,57 +657,87 @@ class LifeSpaceAgentTool extends LifeSpaceTool_node_1.LifeSpaceTool {
     }
     async supplyData(itemIndex) {
         var _a;
-        const enableUserAuthorization = Boolean(this.getNodeParameter('enableUserAuthorization', itemIndex, false));
-        const principalUserId = enableUserAuthorization
-            ? String((_a = this.getNodeParameter('authorizationPrincipalUserId', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim()
-            : '';
+        const resource = String((_a = this.getNodeParameter('toolResource', itemIndex, 'record')) !== null && _a !== void 0 ? _a : 'record');
+        const auth = authorizationSettings(this, itemIndex);
+        if (resource === 'person') {
+            const runtime = await personRuntime(this, itemIndex);
+            const direct = customTool(this, itemIndex, runtime, async (query) => invokePerson(this, itemIndex, query, ''));
+            if (!auth.enabled)
+                return { response: direct };
+            return {
+                response: wrapOptionalAuthorization(this, itemIndex, direct, auth.principalUserId, async (semantic, delegationId) => invokePerson(this, itemIndex, semantic, delegationId)),
+            };
+        }
+        const operation = currentRecordOperation(this, itemIndex);
+        const batchSettings = ['create', 'update', 'delete'].includes(operation)
+            ? recordBatchSettings(this, itemIndex)
+            : null;
+        if (batchSettings === null || batchSettings === void 0 ? void 0 : batchSettings.batchProcessing) {
+            const runtime = await multiRuntime(this, itemIndex);
+            const direct = customTool(this, itemIndex, runtime, async (query) => invokeMulti(this, itemIndex, query, ''));
+            if (!auth.enabled)
+                return { response: direct };
+            return {
+                response: wrapOptionalAuthorization(this, itemIndex, direct, auth.principalUserId, async (semantic, delegationId) => invokeMulti(this, itemIndex, semantic, delegationId)),
+            };
+        }
         const directContext = agentExecutionContext(this, itemIndex, '', '');
         const supplied = await LifeSpaceTool_node_1.LifeSpaceTool.prototype.supplyData.call(directContext, itemIndex);
-        if (!enableUserAuthorization)
+        if (!auth.enabled)
             return supplied;
         const baseTool = supplied.response;
-        const schema = {
-            ...baseTool.schema,
-            properties: {
-                ...baseTool.schema.properties,
-                delegationId: {
-                    type: 'string',
-                    description: 'Optional LifeSpace dlg_* returned by a successful authorization confirmation. Omit it to execute with the Agent\'s own Authority.',
-                },
-            },
-        };
-        const tool = {
-            ...baseTool,
-            description: `${baseTool.description} When user authorization is required, pass the dlg_* returned by LifeSpace Confirm Authorization as delegationId. Omit delegationId to use the Agent's own Authority.`,
-            schema,
-            metadata: {
-                ...baseTool.metadata,
-                lifeSpaceUserAuthorization: 'optional',
-            },
-            invoke: async (query) => {
-                const { semantic, delegationId } = toolInput(query);
-                if (delegationId && !/^dlg_[A-Za-z0-9_-]+$/u.test(delegationId)) {
-                    return invalidDelegationOutput();
-                }
-                if (delegationId && !/^usr_[A-Za-z0-9_-]+$/u.test(principalUserId)) {
-                    return JSON.stringify({
-                        ok: false,
-                        error: {
-                            code: 'USER_CONTEXT_REQUIRED',
-                            message: 'A trusted Principal User ID is required to use delegationId',
-                            retryable: false,
-                            nextAction: 'report_failure',
-                        },
-                    });
-                }
-                const executionContext = agentExecutionContext(this, itemIndex, principalUserId, delegationId);
+        return {
+            response: wrapOptionalAuthorization(this, itemIndex, baseTool, auth.principalUserId, async (semantic, delegationId) => {
+                const executionContext = agentExecutionContext(this, itemIndex, auth.principalUserId, delegationId);
                 const runtimeSupply = await LifeSpaceTool_node_1.LifeSpaceTool.prototype.supplyData.call(executionContext, itemIndex);
                 const runtimeTool = runtimeSupply.response;
-                const output = await runtimeTool.invoke(semantic);
-                return withAuthorizationRequired(output, authorizationScope(this, itemIndex, semantic));
-            },
+                return await runtimeTool.invoke(semantic);
+            }),
         };
-        return { response: tool };
+    }
+    async execute() {
+        var _a;
+        const items = this.getInputData();
+        if (!items.length)
+            return [[]];
+        const resource = String((_a = this.getNodeParameter('toolResource', 0, 'record')) !== null && _a !== void 0 ? _a : 'record');
+        const operation = resource === 'person' ? 'query' : currentRecordOperation(this, 0);
+        const batchSettings = resource === 'record' && ['create', 'update', 'delete'].includes(operation)
+            ? recordBatchSettings(this, 0)
+            : null;
+        const custom = resource === 'person' || (batchSettings === null || batchSettings === void 0 ? void 0 : batchSettings.batchProcessing) === true;
+        if (!custom)
+            return await LifeSpaceTool_node_1.LifeSpaceTool.prototype.execute.call(this);
+        const output = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+            const item = items[itemIndex];
+            if (!item)
+                continue;
+            const runtime = resource === 'person'
+                ? await personRuntime(this, itemIndex)
+                : await multiRuntime(this, itemIndex);
+            const projected = semanticToolInput(runtime.schema, item.json);
+            const { semantic, delegationId } = toolInput(projected);
+            let response;
+            if (delegationId && !/^dlg_[A-Za-z0-9_-]+$/u.test(delegationId)) {
+                response = invalidDelegationOutput();
+            }
+            else {
+                try {
+                    response = resource === 'person'
+                        ? await invokePerson(this, itemIndex, semantic, delegationId)
+                        : await invokeMulti(this, itemIndex, semantic, delegationId);
+                }
+                catch (error) {
+                    response = structuredFailure(error);
+                }
+                if (authorizationSettings(this, itemIndex).enabled) {
+                    response = withAuthorizationRequired(response, authorizationScope(this, itemIndex, semantic));
+                }
+            }
+            output.push({ json: { response }, pairedItem: { item: itemIndex } });
+        }
+        return [output];
     }
 }
 exports.LifeSpaceAgentTool = LifeSpaceAgentTool;