@fastgpt-plugin/cli 0.1.0-beta.7 → 0.1.0-beta.9

package/dist/index.js

@@ -166,6 +166,7 @@ const ToolManifestSchema = z.object({
 
 //#endregion
 //#region src/build/index.ts
+const SDK_FACTORY_PACKAGE = "@fastgpt-plugin/sdk-factory";
 /**
 * 核心构建逻辑：给定入口目录和输出目录，完成一次工具构建。
 *
@@ -196,11 +197,11 @@ async function buildToolPackage(options) {
 		const tempIndexPath = path.join(tempDir, "index.ts");
 		const tBuildStart = Date.now();
 		await build({
-			deps: { alwaysBundle: [
-				"*",
-				"*/*",
-				"@*/*"
-			] },
+			config: false,
+			deps: {
+				alwaysBundle: (id) => !isSdkFactoryImport(id),
+				neverBundle: [SDK_FACTORY_PACKAGE, `${SDK_FACTORY_PACKAGE}/*`]
+			},
 			entry: { index: tempIndexPath },
 			outDir: outputDir,
 			format: [options.format],
@@ -378,6 +379,9 @@ function pickToolDescription$1(explicitDescription, fallbackSource) {
 function getOptionalString$1(value) {
 	return typeof value === "string" ? value : void 0;
 }
+function isSdkFactoryImport(id) {
+	return id === SDK_FACTORY_PACKAGE || id.startsWith(`${SDK_FACTORY_PACKAGE}/`);
+}
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -539,7 +543,7 @@ var CheckCommand = class extends BaseCommand {
 //#endregion
 //#region package.json
 var name = "@fastgpt-plugin/cli";
-var version = "0.1.0-beta.7";
+var version = "0.1.0-beta.9";
 
 //#endregion
 //#region src/constants.ts
@@ -888,7 +892,10 @@ const InvokeUploadFileInputSchema = z.object({ ...FileCreateSchema.omit({
 	overwrite: true,
 	path: true
 }).shape });
-const InvokeUploadFileOutputSchema = z.object({ accessURL: z.string() });
+const InvokeUploadFileOutputSchema = z.object({
+	...FileMetaSchema.omit({ fileKey: true }).partial().shape,
+	accessURL: z.string()
+});
 const InvokeUserInfoOutputSchema = z.object({
 	username: z.string(),
 	contact: z.string().nullish(),
@@ -899,9 +906,17 @@ const InvokeUserInfoOutputSchema = z.object({
 	})),
 	groups: z.array(z.object({ name: z.string() }))
 });
-const InvokeMethodEnumSchema = z.enum(["uploadFile", "userInfo"]);
+const InvokeMethodEnumSchema = z.enum([
+	"uploadFile",
+	"userInfo",
+	"wecomCorpToken"
+]);
 const InvokeMethodEnum = InvokeMethodEnumSchema.enum;
 
+//#endregion
+//#region ../../packages/domain/src/value-objects/result.vo.ts
+const successResult = (data) => [data, null];
+
 //#endregion
 //#region ../../packages/domain/src/value-objects/stream.vo.ts
 var StreamData = class StreamData {
@@ -1020,58 +1035,328 @@ const ToolRunInputSchema = z.object({
 });
 
 //#endregion
-//#region ../../packages/infrastructure/src/plugin/plugin-runtime/drivers/local-pool/ipc-channel.ts
-const HOST_INVOKE_METHOD = "__host_invoke__";
+//#region ../../packages/infrastructure/src/plugin/plugin-runtime/ports/channel/event/client.ts
+/**
+* client -> host 的事件集合。
+*
+* client 是插件运行侧，host 是插件宿主侧。这里的 method 只能由 client 发送，
+* host 只能在 handler 中接收。
+*/
+const PluginChannelClientMethod = {
+	/**
+	* 插件 runtime 初始化完成，host 收到后可以把 pod 标记为 ready。
+	*/
+	ready: "client.ready",
+	/**
+	* 插件 runtime 的 stdout/stderr 输出。
+	*/
+	stdio: "client.stdio",
+	/**
+	* 插件 runtime 主动报告启动失败、运行失败或崩溃信息。
+	*/
+	fail: "client.fail",
+	/**
+	* 插件反向调用 host 能力，例如 uploadFile、userInfo。
+	*/
+	request: "client.request"
+};
+const PluginChannelClientMethodSchema = z.enum([
+	PluginChannelClientMethod.ready,
+	PluginChannelClientMethod.stdio,
+	PluginChannelClientMethod.fail,
+	PluginChannelClientMethod.request
+]);
+const PluginChannelReadyParamsSchema = z.object({
+	pid: z.number().optional(),
+	version: z.string().optional(),
+	runtimeMode: z.string().optional(),
+	capabilities: z.array(z.string()).optional(),
+	startedAt: z.number().optional(),
+	meta: z.unknown().optional()
+});
+const PluginChannelStdioParamsSchema = z.object({
+	stream: z.enum(["stdout", "stderr"]),
+	chunk: z.string(),
+	timestamp: z.number().optional()
+});
+const PluginChannelFailParamsSchema = z.object({
+	reason: z.enum([
+		"startup",
+		"runtime",
+		"crash",
+		"shutdown",
+		"unknown"
+	]),
+	error: z.object({
+		code: z.string(),
+		message: z.string(),
+		data: z.unknown().optional()
+	}).optional(),
+	exitCode: z.number().nullable().optional(),
+	signal: z.string().nullable().optional(),
+	timestamp: z.number().optional()
+});
+
+//#endregion
+//#region ../../packages/infrastructure/src/plugin/plugin-runtime/ports/channel/event/common.ts
+const PluginChannelCommonMethod = { 
+/**
+* 双向通用的流 frame 通道。
+*
+* 业务侧不直接调用这个 method；使用 `request({ input })`、`createReply({ output })`
+* 或 `pipeStream()` 时由底层 channel 自动发送。
+*/
+streamFrame: "channel.stream" };
+const PluginChannelCommonMethodSchema = z.enum([PluginChannelCommonMethod.streamFrame]);
+
+//#endregion
+//#region ../../packages/infrastructure/src/plugin/plugin-runtime/ports/channel/event/host.ts
+/**
+* host -> client 的事件集合。
+*
+* host 是插件宿主侧，client 是插件运行侧。这里的 method 只能由 host 发送，
+* client 只能在 handler 中接收。
+*/
+const PluginChannelHostMethod = {
+	/**
+	* 调用插件业务事件，例如 run。
+	*/
+	request: "host.request",
+	/**
+	* 健康检查。
+	*/
+	ping: "host.ping",
+	/**
+	* 通知插件 runtime 准备退出。
+	*/
+	shutdown: "host.shutdown"
+};
+const PluginChannelHostMethodSchema = z.enum([
+	PluginChannelHostMethod.request,
+	PluginChannelHostMethod.ping,
+	PluginChannelHostMethod.shutdown
+]);
+const PluginChannelPingParamsSchema = z.object({ timestamp: z.number() });
+const PluginChannelPingResultSchema = z.object({
+	timestamp: z.number(),
+	receivedAt: z.number().optional()
+});
+const PluginChannelShutdownParamsSchema = z.object({
+	reason: z.string().optional(),
+	timeoutMs: z.number().nonnegative().optional()
+});
+const PluginChannelShutdownResultSchema = z.object({
+	accepted: z.boolean(),
+	message: z.string().optional()
+});
+
+//#endregion
+//#region ../../packages/infrastructure/src/plugin/plugin-runtime/ports/channel/event/index.ts
+const PluginChannelKnownMethodSchema = z.union([
+	PluginChannelClientMethodSchema,
+	PluginChannelCommonMethodSchema,
+	PluginChannelHostMethodSchema
+]);
+
+//#endregion
+//#region ../../packages/infrastructure/src/plugin/plugin-runtime/ports/channel/message.ts
+/**
+* Channel 协议只描述可跨传输层传递的 JSON 数据。
+*
+* 它刻意不绑定 Node IPC、TCP、HTTP 等具体实现；不同 driver 只需要负责把这些
+* message 发给对端，并把收到的 message 重新交给 channel port 分发。
+*/
+const PluginChannelProtocolVersionSchema = z.literal("1.0");
+const PluginChannelMessageIdSchema = z.union([z.string(), z.number()]);
+const PluginChannelErrorSchema = z.object({
+	code: z.string(),
+	message: z.string(),
+	data: z.unknown().optional()
+});
+/**
+* request message：需要对端返回 success/error。
+*
+* `method` 的合法集合由 `event/` 里的方向化类型控制；这里保持 string 是为了让
+* 底层协议可以承载未来扩展的 method。
+*/
+const PluginChannelRequestMessageSchema = z.object({
+	protocol: PluginChannelProtocolVersionSchema,
+	id: PluginChannelMessageIdSchema,
+	method: z.string(),
+	params: z.unknown().optional(),
+	traceId: z.string().optional(),
+	timestamp: z.number().optional()
+});
+/**
+* notification message：单向事件，不产生响应。
+*
+* ready、stdio、fail 和 stream frame 都属于 notification。
+*/
+const PluginChannelNotificationMessageSchema = PluginChannelRequestMessageSchema.omit({ id: true });
+/**
+* success message：request 的成功响应。
+*
+* 流式输出不会直接塞进 `result`，而是先返回一个 stream descriptor/envelope，
+* 再通过 `channel.stream` notification 发送 chunk。
+*/
+const PluginChannelSuccessMessageSchema = z.object({
+	protocol: PluginChannelProtocolVersionSchema,
+	id: PluginChannelMessageIdSchema,
+	result: z.unknown().optional(),
+	traceId: z.string().optional(),
+	timestamp: z.number().optional()
+});
+/**
+* error message：request 的失败响应。
+*/
+const PluginChannelErrorMessageSchema = z.object({
+	protocol: PluginChannelProtocolVersionSchema,
+	id: PluginChannelMessageIdSchema,
+	error: PluginChannelErrorSchema,
+	traceId: z.string().optional(),
+	timestamp: z.number().optional()
+});
+const PluginChannelMessageSchema = z.union([
+	PluginChannelRequestMessageSchema,
+	PluginChannelNotificationMessageSchema,
+	PluginChannelSuccessMessageSchema,
+	PluginChannelErrorMessageSchema
+]);
+const PluginChannelTransportSchema = z.enum([
+	"ipc",
+	"tcp",
+	"http"
+]);
+/**
+* host：插件宿主侧，例如 local-pool 的主进程。
+* client：插件运行侧，例如 fork 出来的插件子进程或 debug runtime。
+*/
+const PluginChannelSideSchema = z.enum(["host", "client"]);
+const PluginChannelStreamDescriptorSchema = z.object({
+	streamId: z.string(),
+	streamName: z.string(),
+	meta: z.unknown().optional()
+});
+/**
+* 流数据统一通过 notification 发送 frame。
+*
+* 一个 stream 生命周期为 start -> chunk* -> end/error。chunk 的 payload 保持
+* unknown，由具体事件类型决定真实数据结构。
+*/
+const PluginChannelStreamFrameSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("start"),
+		streamId: z.string(),
+		streamName: z.string(),
+		meta: z.unknown().optional()
+	}),
+	z.object({
+		type: z.literal("chunk"),
+		streamId: z.string(),
+		chunk: z.unknown()
+	}),
+	z.object({
+		type: z.literal("end"),
+		streamId: z.string()
+	}),
+	z.object({
+		type: z.literal("error"),
+		streamId: z.string(),
+		error: PluginChannelErrorSchema
+	})
+]);
 
 //#endregion
 //#region src/debug/runtime.ts
 const LOCAL_DEBUG_RUNTIME_GLOBAL_KEY = "__FASTGPT_PLUGIN_LOCAL_DEBUG_RUNTIME__";
-const LOCAL_DEBUG_DUPLEX_REPLY_MARK = "__localDebugDuplexReply__";
+const LOCAL_DEBUG_REPLY_MARK = "__localDebugReply__";
 var LocalDebugChannel = class {
-	constructor(runtime) {
+	transport = "local-debug";
+	requestHandler = null;
+	notificationHandler = null;
+	errorHandlers = /* @__PURE__ */ new Set();
+	closeHandlers = /* @__PURE__ */ new Set();
+	constructor(side, runtime) {
+		this.side = side;
 		this.runtime = runtime;
 	}
+	async request(method, params, options) {
+		return this.runtime.dispatchFromSide(this.side, method, params, options);
+	}
+	async notify(method, params, options) {
+		await this.runtime.notifyFromSide(this.side, method, params, options);
+	}
 	setRequestHandler(handler) {
-		this.runtime.setPluginRequestHandler(handler);
+		this.requestHandler = handler;
 	}
-	async requestDuplex(method, params, options) {
-		return this.runtime.invokeHost(method, params, {
-			...options,
-			streamName: method
-		});
+	setNotificationHandler(handler) {
+		this.notificationHandler = handler;
+	}
+	async waitForStream() {
+		throw new Error("Local debug channel does not support detached stream waiters.");
+	}
+	async createWritableStream(streamName, options) {
+		const stream = StreamData.create();
+		return {
+			streamId: options?.streamId ?? randomUUID(),
+			streamName: options?.streamName ?? streamName,
+			...options?.meta !== void 0 ? { meta: options.meta } : {},
+			write: async (chunk) => stream.write(chunk),
+			end: async () => stream.end(),
+			fail: async (error) => stream.fail(error instanceof Error ? error : new Error(String(error)))
+		};
+	}
+	async pipeStream() {
+		throw new Error("Local debug channel does not support detached stream piping.");
 	}
-	replyDuplex(_message, result, options) {
+	createReply(result, options) {
 		return {
-			[LOCAL_DEBUG_DUPLEX_REPLY_MARK]: true,
+			[LOCAL_DEBUG_REPLY_MARK]: true,
 			...result !== void 0 ? { result } : {},
 			...options?.output !== void 0 ? { output: options.output } : {},
-			...options ? { options: {
-				traceId: options.traceId,
-				outputMeta: options.outputMeta,
-				outputStreamId: options.outputStreamId
-			} } : {}
+			...options?.outputStream !== void 0 ? { outputStream: options.outputStream } : {}
 		};
 	}
-	sendReady() {
-		this.runtime.markReady();
+	onError(handler) {
+		this.errorHandlers.add(handler);
+		return () => {
+			this.errorHandlers.delete(handler);
+		};
+	}
+	onClose(handler) {
+		this.closeHandlers.add(handler);
+		return () => {
+			this.closeHandlers.delete(handler);
+		};
+	}
+	async close(reason) {
+		this.closeHandlers.forEach((handler) => handler(reason));
+	}
+	async handleRequest(request) {
+		if (!this.requestHandler) throw new Error(`Local debug request handler is not configured: ${String(request.method)}`);
+		return this.requestHandler(request);
+	}
+	async handleNotification(notification) {
+		await this.notificationHandler?.(notification);
 	}
 };
 var LocalDebugRuntime = class {
-	pluginRequestHandler = null;
 	hostRequestHandler = null;
 	ready = false;
 	readyPromise;
 	resolveReady;
+	hostChannel;
 	pluginChannel;
 	constructor() {
-		this.pluginChannel = new LocalDebugChannel(this);
+		this.hostChannel = new LocalDebugChannel("host", this);
+		this.pluginChannel = new LocalDebugChannel("client", this);
+		this.hostChannel.setNotificationHandler(async (notification) => {
+			if (notification.method === PluginChannelClientMethod.ready) this.markReady();
+		});
 		this.readyPromise = new Promise((resolve) => {
 			this.resolveReady = resolve;
 		});
 	}
-	setPluginRequestHandler(handler) {
-		this.pluginRequestHandler = handler;
-	}
 	setHostRequestHandler(handler) {
 		this.hostRequestHandler = handler;
 	}
@@ -1084,27 +1369,59 @@ var LocalDebugRuntime = class {
 		await this.readyPromise;
 	}
 	async invokePlugin(method, params, options) {
-		if (!this.pluginRequestHandler) throw new Error("Plugin request handler is not initialized.");
-		return this.dispatch(this.pluginRequestHandler, method, params, {
-			...options,
-			streamName: method
-		});
-	}
-	async invokeHost(method, params, options) {
-		if (!this.hostRequestHandler) throw new Error(`Local debug host handler is not configured: ${method}`);
-		const message = createMessage(method, params, options);
-		return toDuplexResponse(message, await this.hostRequestHandler({
-			message,
+		return this.hostChannel.request(PluginChannelHostMethod.request, {
+			eventName: method,
+			payload: params,
+			returnStream: true
+		}, options);
+	}
+	async dispatchFromSide(side, method, params, options) {
+		const requestId = options?.id ?? randomUUID();
+		const target = side === "host" ? this.pluginChannel : this.hostChannel;
+		return toRequestResult(requestId, side === "client" && method === PluginChannelClientMethod.request ? await this.invokeHostRequest(params, options) : await target.handleRequest({
+			id: requestId,
 			method,
-			args: params,
-			traceId: options.traceId,
-			input: options.input,
-			replyDuplex: (result, replyOptions) => this.pluginChannel.replyDuplex(message, result, replyOptions)
+			params,
+			...options?.traceId !== void 0 ? { traceId: options.traceId } : {},
+			raw: {
+				protocol: "1.0",
+				id: requestId,
+				method: String(method),
+				params,
+				...options?.traceId !== void 0 ? { traceId: options.traceId } : {},
+				timestamp: Date.now()
+			},
+			waitForInputStream: async () => createIncomingStream({
+				source: options?.input ?? StreamData.create(),
+				streamName: String(method),
+				streamId: randomUUID(),
+				traceId: options?.traceId
+			})
 		}), options);
 	}
-	async dispatch(handler, method, params, options) {
-		const message = createMessage(method, params, options);
-		return toDuplexResponse(message, await handler(message), options);
+	async notifyFromSide(side, method, params, options) {
+		await (side === "host" ? this.pluginChannel : this.hostChannel).handleNotification({
+			method,
+			params,
+			...options?.traceId !== void 0 ? { traceId: options.traceId } : {},
+			raw: {
+				protocol: "1.0",
+				method: String(method),
+				params,
+				...options?.traceId !== void 0 ? { traceId: options.traceId } : {},
+				timestamp: Date.now()
+			}
+		});
+	}
+	async invokeHostRequest(params, options) {
+		if (!this.hostRequestHandler) throw new Error(`Local debug host handler is not configured: ${params.method}`);
+		return this.hostRequestHandler({
+			method: params.method,
+			args: params.args,
+			traceId: options?.traceId,
+			input: options?.input,
+			createReply: (result, replyOptions) => this.pluginChannel.createReply(result, replyOptions)
+		});
 	}
 };
 const createLocalDebugRuntime = () => new LocalDebugRuntime();
@@ -1116,35 +1433,25 @@ const setCurrentLocalDebugRuntime = (runtime) => {
 	}
 	store[LOCAL_DEBUG_RUNTIME_GLOBAL_KEY] = runtime;
 };
-function createMessage(method, params, options) {
-	return {
-		id: options?.requestId ?? randomUUID(),
-		messageType: "request",
-		method,
-		params,
-		traceId: options?.traceId,
-		timestamp: Date.now()
-	};
-}
 function isLocalDebugReplyDescriptor(value) {
-	return Boolean(value && typeof value === "object" && LOCAL_DEBUG_DUPLEX_REPLY_MARK in value && value[LOCAL_DEBUG_DUPLEX_REPLY_MARK] === true);
+	return Boolean(value && typeof value === "object" && LOCAL_DEBUG_REPLY_MARK in value && value[LOCAL_DEBUG_REPLY_MARK] === true);
 }
-function toDuplexResponse(message, response, options) {
+function toRequestResult(requestId, response, options) {
 	const inputDone = options?.input !== void 0 ? Promise.resolve() : void 0;
 	if (!isLocalDebugReplyDescriptor(response)) return {
-		requestId: message.id,
+		requestId,
 		result: response,
 		...inputDone ? { inputDone } : {}
 	};
 	const output = response.output !== void 0 ? createIncomingStream({
 		source: response.output,
-		streamName: response.options?.outputStreamId ?? options?.streamName ?? message.method ?? "stream",
-		streamId: response.options?.outputStreamId ?? randomUUID(),
-		traceId: response.options?.traceId ?? message.traceId,
-		meta: response.options?.outputMeta
+		streamName: response.outputStream?.streamName ?? "stream",
+		streamId: response.outputStream?.streamId ?? randomUUID(),
+		traceId: response.outputStream?.traceId,
+		meta: response.outputStream?.meta
 	}) : void 0;
 	return {
-		requestId: message.id,
+		requestId,
 		result: response.result,
 		...output ? { output } : {},
 		...inputDone ? { inputDone } : {}
@@ -1310,11 +1617,8 @@ function pickTargetTool(snapshot, toolId) {
 }
 function createVirtualHostHandler(uploadDir) {
 	return async ({ method, args, input }) => {
-		if (method !== "__host_invoke__") throw new Error(`本地虚拟环境暂不支持反向调用: ${method}`);
-		const payload = ensurePlainObject(args);
-		const invokeMethod = payload.method;
-		const invokeArgs = ensurePlainObject(payload.args);
-		switch (invokeMethod) {
+		const invokeArgs = ensurePlainObject(args);
+		switch (method) {
 			case InvokeMethodEnum.uploadFile: {
 				const buffer = await readSourceToBuffer(input);
 				const fileName = sanitizeFileName(typeof invokeArgs.fileName === "string" && invokeArgs.fileName.trim().length > 0 ? invokeArgs.fileName : "debug-upload.bin");
@@ -1323,16 +1627,16 @@ function createVirtualHostHandler(uploadDir) {
 				const outputPath = path.join(saveDir, `${Date.now()}-${randomUUID().slice(0, 8)}-${fileName}`);
 				await fs.mkdir(saveDir, { recursive: true });
 				await fs.writeFile(outputPath, buffer);
-				return {
+				return successResult({
 					fileName,
 					contentType,
 					size: buffer.length,
 					etag: createHash("md5").update(buffer).digest("hex"),
 					createTime: /* @__PURE__ */ new Date(),
 					accessURL: pathToFileURL(outputPath).href
-				};
+				});
 			}
-			default: throw new Error(`本地虚拟环境暂不支持反向调用: ${String(invokeMethod)}`);
+			default: throw new Error(`本地虚拟环境暂不支持反向调用: ${String(method)}`);
 		}
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastgpt-plugin/cli",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.9",
   "type": "module",
   "private": false,
   "publishConfig": {

package/templates/tool/index.tool.ts

@@ -1,11 +1,19 @@
-import { createToolHandler, defineTool } from '@fastgpt-plugin/sdk-factory';
+import {
+  createToolHandler,
+  defineTool,
+  type InputSchemaMetaType,
+  type OutputSchemaMetaType
+} from '@fastgpt-plugin/sdk-factory';
 import z from 'zod';
 
 const handler = createToolHandler({
   inputSchema: z.object({
-    delay: z.number()
+    delay: z.number().meta({
+      title: 'Delay',
+      description: 'Delay duration in milliseconds'
+    } satisfies InputSchemaMetaType)
   }),
-  outputSchema: z.object({}),
+  outputSchema: z.object({}).meta({} satisfies OutputSchemaMetaType),
   handler: async (input, _ctx) => {
     await new Promise((resolve) => setTimeout(resolve, input.delay));
     return {};

package/templates/tool/index.toolset.ts

@@ -1,21 +1,45 @@
-import { defineToolSet } from 'sdk/factory/dist';
-import { createToolHandler } from 'sdk/factory/src';
+import {
+  createToolHandler,
+  defineToolSet,
+  type InputSchemaMetaType,
+  type OutputSchemaMetaType,
+  type SecretSchemaMetaType
+} from '@fastgpt-plugin/sdk-factory';
 import z from 'zod';
 
 const secretSchema = z.object({
-  host: z.string(),
-  port: z.number(),
-  username: z.string(),
-  password: z.string(),
-  database: z.string()
+  host: z.string().meta({
+    title: 'Host',
+    isSecret: false
+  } satisfies SecretSchemaMetaType),
+  port: z.number().meta({
+    title: 'Port',
+    isSecret: false
+  } satisfies SecretSchemaMetaType),
+  username: z.string().meta({
+    title: 'Username',
+    isSecret: false
+  } satisfies SecretSchemaMetaType),
+  password: z.string().meta({
+    title: 'Password',
+    isSecret: true
+  } satisfies SecretSchemaMetaType),
+  database: z.string().meta({
+    title: 'Database',
+    isSecret: false
+  } satisfies SecretSchemaMetaType)
 });
 
 const mysqlHandler = createToolHandler({
   inputSchema: z.object({
-    query: z.string()
+    query: z.string().meta({
+      title: 'SQL Query'
+    } satisfies InputSchemaMetaType)
   }),
   outputSchema: z.object({
-    results: z.array(z.record(z.string(), z.unknown()))
+    results: z.array(z.record(z.string(), z.unknown())).meta({
+      title: 'Query Results'
+    } satisfies OutputSchemaMetaType)
   }),
   secretSchema,
   handler: async (input, ctx) => {
@@ -37,10 +61,14 @@ const mysqlHandler = createToolHandler({
 
 const pgsqlHandler = createToolHandler({
   inputSchema: z.object({
-    query: z.string()
+    query: z.string().meta({
+      title: 'SQL Query'
+    } satisfies InputSchemaMetaType)
   }),
   outputSchema: z.object({
-    results: z.array(z.record(z.string(), z.unknown()))
+    results: z.array(z.record(z.string(), z.unknown())).meta({
+      title: 'Query Results'
+    } satisfies OutputSchemaMetaType)
   }),
   secretSchema,
   handler: async (input, ctx) => {