@happyvertical/smrt-core 0.40.61 → 0.40.63

package/dist/generators/mcp.js

@@ -2,6 +2,7 @@ import { SMRT_CUSTOM_ACTION_ERROR_METADATA_KEY, buildCustomActionInvocationArgs,
 import { ObjectRegistry } from "../registry.js";
 import { SmrtCollection } from "../collection.js";
 import { runWithTenantGate } from "./tenant-gate.js";
+import { generatedSiblingExtension, renderGeneratedSource, resolveGeneratedSourceLanguage } from "./mcp-emit.js";
 import { generateClaudeConfig, generateMCPDocumentation, generateMCPScript, generateRuntimeBootstrap } from "./mcp-runtime-template.js";
 import { buildToolInputSchema, fieldTypeToJsonSchema, finalizeMcpJsonSchema } from "./tool-schema.js";
 import { dirname, resolve } from "node:path";
@@ -12,6 +13,19 @@ import { mkdir, writeFile } from "node:fs/promises";
 *
 * Exposes smrt objects as AI tools for Claude, GPT, and other AI models
 */
+/**
+* Write one generated module, rendering it for the requested output language.
+*
+* Every generator in this file produces TypeScript source; a JavaScript target
+* is transpiled on the way out so the written file is runnable as-is (#2279).
+*
+* @param targetPath - Absolute path of the file to write
+* @param source - Generated TypeScript source
+* @param language - Language the file must be written in
+*/
+async function writeGeneratedFile(targetPath, source, language) {
+	await writeFile(targetPath, await renderGeneratedSource(source, language, targetPath), "utf-8");
+}
 var MCP_STABLE_CATALOG_TTL_MS = 864e5;
 /**
 * Resolve the generated tools/list cache policy at generation time.
@@ -53,6 +67,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 +496,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);
@@ -805,13 +899,14 @@ var MCPGenerator = class {
 		const { outputPath = ".smrt/mcp-server/index.js", serverName = this.config.name || "smrt-mcp-server", serverVersion = this.config.version || "1.0.0", debug = false, generateClaudeConfigFile = false, generateReadme = false, modular = false } = options;
 		const resolvedPath = resolve(process.cwd(), outputPath);
 		const outputDir = dirname(resolvedPath);
+		const language = resolveGeneratedSourceLanguage(resolvedPath);
 		await mkdir(outputDir, { recursive: true });
-		if (modular) await this.generateModularServer(outputDir, serverName, serverVersion, debug);
+		if (modular) await this.generateModularServer(resolvedPath, serverName, serverVersion, debug, language);
 		else {
 			const tools = await this.generateTools();
 			const tenantScopedObjects = await this.tenantScopedObjectNames(tools);
 			const hasTenantScopedTools = tenantScopedObjects.length > 0 || await this.hasTenantScopedTools(tools);
-			await writeFile(resolvedPath, generateRuntimeBootstrap({
+			await writeGeneratedFile(resolvedPath, generateRuntimeBootstrap({
 				name: serverName,
 				version: serverVersion,
 				description: this.config.description,
@@ -820,10 +915,11 @@ 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)
-			}), "utf-8");
+			}), language);
 			console.log(`✅ Generated MCP server: ${resolvedPath}`);
 		}
 		if (generateClaudeConfigFile) {
@@ -877,6 +973,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
@@ -905,30 +1021,36 @@ var MCPGenerator = class {
 	* Creates separate files for tools, handlers, configuration, and main entry point.
 	* This makes the generated server easier to customize and extend.
 	*
-	* @param outputDir - Directory to generate files in
+	* The sibling modules use the entry point's own extension and the entry
+	* emits matching relative specifiers, so its imports resolve to files that
+	* exist and load with the same module semantics (#2279).
+	*
+	* @param indexPath - Absolute path of the entry point to generate
 	* @param serverName - Server name
 	* @param serverVersion - Server version
 	* @param debug - Enable debug logging
+	* @param language - Language the generated files are written in
 	*/
-	async generateModularServer(outputDir, serverName, serverVersion, debug) {
+	async generateModularServer(indexPath, serverName, serverVersion, debug, language) {
+		const outputDir = dirname(indexPath);
+		const extension = generatedSiblingExtension(indexPath);
 		const toolsDir = resolve(outputDir, "tools");
 		const handlersDir = resolve(outputDir, "handlers");
 		await mkdir(toolsDir, { recursive: true });
 		await mkdir(handlersDir, { recursive: true });
-		const configPath = resolve(outputDir, "config.ts");
-		await writeFile(configPath, this.generateConfigFile(serverName, serverVersion, debug), "utf-8");
+		const configPath = resolve(outputDir, `config${extension}`);
+		await writeGeneratedFile(configPath, this.generateConfigFile(serverName, serverVersion, debug), language);
 		console.log(`✅ Generated config: ${configPath}`);
 		const generatedTools = await this.generateTools();
-		const toolsPath = resolve(toolsDir, "index.ts");
-		await writeFile(toolsPath, this.generateToolsFile(generatedTools), "utf-8");
+		const toolsPath = resolve(toolsDir, `index${extension}`);
+		await writeGeneratedFile(toolsPath, this.generateToolsFile(generatedTools), language);
 		console.log(`✅ Generated tools: ${toolsPath}`);
-		const handlersPath = resolve(handlersDir, "index.ts");
+		const handlersPath = resolve(handlersDir, `index${extension}`);
 		const tenantScopedObjects = await this.tenantScopedObjectNames(generatedTools);
 		const hasTenantScopedTools = tenantScopedObjects.length > 0 || await this.hasTenantScopedTools(generatedTools);
-		await writeFile(handlersPath, await this.generateHandlersFile(tenantScopedObjects), "utf-8");
+		await writeGeneratedFile(handlersPath, await this.generateHandlersFile(tenantScopedObjects), language);
 		console.log(`✅ Generated handlers: ${handlersPath}`);
-		const indexPath = resolve(outputDir, "index.js");
-		await writeFile(indexPath, this.generateModularIndex(resolveMCPToolListCacheHint(this.config.cache?.toolsList, hasTenantScopedTools)), "utf-8");
+		await writeGeneratedFile(indexPath, this.generateModularIndex(resolveMCPToolListCacheHint(this.config.cache?.toolsList, hasTenantScopedTools), extension), language);
 		console.log(`✅ Generated MCP server: ${indexPath}`);
 	}
 	/**
@@ -1147,6 +1269,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(',')
@@ -1250,11 +1373,11 @@ function errorResult(structuredContent: any, text: string, _meta?: Record<string
  */
 export async function handleToolCall(
   name: string,
-  arguments: any = {},
+  toolArguments: any = {},
   aiConfig: any = {}
 ) {
   try {
-    const args = arguments;
+    const args = toolArguments;
 
     const runToolBody = async () => {
       switch (name) {
@@ -1290,8 +1413,11 @@ ${hasTenantScoped ? `
 	}
 	/**
 	* Generate modular index file (main entry point)
+	*
+	* @param toolListCacheHint - Cache hint emitted for `tools/list` results
+	* @param extension - Extension of the sibling modules this entry imports
 	*/
-	generateModularIndex(toolListCacheHint) {
+	generateModularIndex(toolListCacheHint, extension = ".js") {
 		return `#!/usr/bin/env node
 /**
  * Auto-generated MCP Server
@@ -1307,12 +1433,10 @@ import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { ObjectRegistry } from '@happyvertical/smrt-core';
 import { loadConfig } from '@happyvertical/smrt-config';
-import { getDatabase } from '@happyvertical/sql';
-import { getAI } from '@happyvertical/ai';
 
-import { SERVER_NAME, SERVER_VERSION, DEBUG } from './config.js';
-import { tools } from './tools/index.js';
-import { handleToolCall } from './handlers/index.js';
+import { SERVER_NAME, SERVER_VERSION, DEBUG } from './config${extension}';
+import { tools } from './tools/index${extension}';
+import { handleToolCall } from './handlers/index${extension}';
 
 const TOOL_LIST_CACHE_HINT = ${JSON.stringify(toolListCacheHint)};