@happyvertical/smrt-core 0.40.61 → 0.40.62

package/dist/generators/mcp.js

@@ -53,6 +53,29 @@ function resolveCustomActionMethod(methods, toolAction) {
 	for (const [methodName, method] of methods) if (methodName.toLowerCase() === toolAction.toLowerCase()) return [methodName, method];
 	return [toolAction, void 0];
 }
+/** Preserve a declared method's case when a runtime-only class has no manifest. */
+function resolveRuntimeMethodName(classConstructor, action) {
+	let prototype = classConstructor?.prototype;
+	while (prototype && prototype !== Object.prototype) {
+		const match = Object.getOwnPropertyNames(prototype).find((name) => name.toLowerCase() === action.toLowerCase());
+		if (match) return match;
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return action;
+}
+/**
+* Background task methods receive `JobExecutionContext` from TaskRunner, not
+* from untrusted MCP arguments. Keep that conventional trailing parameter out
+* of the persisted positional call so the runner can append its live context.
+*/
+function buildTaskActionInvocationArgs(metadata, args) {
+	const parameters = metadata.parameters;
+	if (parameters?.at(-1)?.name === "context") return buildCustomActionInvocationArgs({
+		...metadata,
+		parameters: parameters.slice(0, -1)
+	}, args);
+	return buildCustomActionInvocationArgs(metadata, args);
+}
 /**
 * Generate MCP server from smrt objects
 */
@@ -459,6 +482,63 @@ var MCPGenerator = class {
 			};
 		}
 	}
+	/** Whether a visible tool has explicitly opted into durable task execution. */
+	async supportsTaskTool(name) {
+		return await this.resolveTaskAction(name, { id: "__mcp_task_probe__" }) !== null;
+	}
+	/**
+	* Create a durable MCP task for an explicitly enabled item custom action.
+	* The caller is responsible for checking the client's extension capability
+	* before exposing this result on the wire.
+	*/
+	async createTask(request) {
+		if (!this.context.taskStore) throw new Error("MCP Tasks is enabled but no durable task store is configured");
+		const resolved = await this.resolveTaskAction(request.params.name, request.params.arguments);
+		if (!resolved) throw new Error(`MCP task execution is not enabled for tool: ${request.params.name}`);
+		return {
+			content: [],
+			structuredContent: {},
+			resultType: "task",
+			...await this.context.taskStore.createTask({
+				objectType: resolved.objectType,
+				objectId: resolved.objectId,
+				method: resolved.methodName,
+				invocationArgs: resolved.invocationArgs,
+				tenantId: this.context.tenantId ?? null
+			})
+		};
+	}
+	async resolveTaskAction(toolName, args) {
+		const separator = toolName.indexOf("_");
+		if (separator <= 0) return null;
+		const objectPrefix = toolName.slice(0, separator);
+		const action = toolName.slice(separator + 1);
+		if ([
+			"list",
+			"get",
+			"create",
+			"update",
+			"delete"
+		].includes(action)) return null;
+		const classEntry = Array.from(ObjectRegistry.getAllClasses().entries()).find(([key, info]) => (info.name || key).toLowerCase() === objectPrefix.toLowerCase());
+		if (!classEntry) return null;
+		const [key, classInfo] = classEntry;
+		const objectName = classInfo.name || key;
+		const mcpConfig = ObjectRegistry.getConfig(objectName).mcp;
+		const configuredTasks = typeof mcpConfig === "object" ? mcpConfig.tasks : void 0;
+		if (configuredTasks !== true && (!Array.isArray(configuredTasks) || !configuredTasks.some((method) => method.toLowerCase() === action.toLowerCase()))) return null;
+		if (!(await this.generateTools()).some((tool) => tool.name === toolName)) return null;
+		const [resolvedMethodName, method] = resolveCustomActionMethod(await ObjectRegistry.getAllMethods(objectName), action);
+		const methodName = method ? resolvedMethodName : resolveRuntimeMethodName(classInfo.constructor, action);
+		const metadata = this.resolveCustomActionMetadata(objectName, methodName, method, this.hasCollectionReceiver(classInfo));
+		if (!metadata.idRequired || metadata.isStatic || typeof args.id !== "string") return null;
+		return {
+			objectType: classInfo.qualifiedName || objectName,
+			objectId: args.id,
+			methodName,
+			invocationArgs: buildTaskActionInvocationArgs(metadata, args)
+		};
+	}
 	/** Convert runtime values to the JSON values MCP structuredContent permits. */
 	toJsonValue(value) {
 		const serialized = JSON.stringify(value);
@@ -820,6 +900,7 @@ var MCPGenerator = class {
 				debug,
 				tools,
 				customActions: await this.runtimeCustomActions(tools),
+				taskActions: await this.runtimeTaskActions(tools),
 				tenantScopedObjects,
 				stiTargets: this.runtimeStiTargets(tools),
 				toolListCacheHint: resolveMCPToolListCacheHint(this.config.cache?.toolsList, hasTenantScopedTools)
@@ -877,6 +958,26 @@ var MCPGenerator = class {
 		}
 		return metadata;
 	}
+	/** Emit only task-enabled item custom actions for the generated runtime. */
+	async runtimeTaskActions(tools) {
+		const actions = {};
+		const classes = ObjectRegistry.getAllClasses();
+		for (const tool of tools) {
+			if (!await this.supportsTaskTool(tool.name)) continue;
+			const separator = tool.name.indexOf("_");
+			if (separator <= 0) continue;
+			const objectPrefix = tool.name.slice(0, separator).toLowerCase();
+			const matched = Array.from(classes.entries()).find(([key, info]) => (info.name || key).toLowerCase() === objectPrefix);
+			if (!matched) continue;
+			const [key, classInfo] = matched;
+			const objectName = classInfo.name || key;
+			actions[tool.name] = {
+				objectName,
+				objectType: classInfo.qualifiedName || objectName
+			};
+		}
+		return actions;
+	}
 	/**
 	* Emit only the STI discriminator targets advertised by create-tool schemas.
 	* Generated processes start with an empty registry, so resolving the
@@ -1147,6 +1248,7 @@ const TENANT_SCOPED = new Set(${JSON.stringify(tenantScopedSet)});
 const MCP_TENANT_ID = process.env.SMRT_MCP_TENANT_ID || undefined;
 const MCP_ALLOW_CROSS_TENANT = process.env.SMRT_MCP_ALLOW_CROSS_TENANT === 'true';
 ` : ""}
+
 const PUBLIC_JSON_OPTIONS = {
   permissions: (process.env.SMRT_MCP_PERMISSIONS || '')
     .split(',')