@mcpc-tech/unplugin-dev-inspector-mcp 0.0.31 → 0.0.34

package/client.d.ts

@@ -3,19 +3,65 @@
 
 declare module "virtual:dev-inspector-mcp" {
   /**
-   * Development-only inspector initialization module.
-   * This module is automatically tree-shaken in production builds.
-   *
-   * Import this in your entry point for non-HTML projects (miniapps, library bundles):
+   * JSON Schema for tool input parameters
+   */
+  export interface ToolInputSchema {
+    type: "object";
+    properties: Record<
+      string,
+      {
+        type: string;
+        description?: string;
+        enum?: string[];
+        default?: unknown;
+      }
+    >;
+    required?: string[];
+  }
+
+  /**
+   * Custom inspector tool definition
+   */
+  export interface InspectorTool {
+    /** Unique tool name */
+    name: string;
+    /** Tool description for AI agents */
+    description: string;
+    /** JSON Schema defining input parameters */
+    inputSchema: ToolInputSchema;
+    /** Implementation function that executes when the tool is called */
+    implementation: (args: Record<string, unknown>) => unknown | Promise<unknown>;
+  }
+
+  /**
+   * Register a custom tool that can be called by AI agents through MCP.
    *
    * @example
    * ```typescript
-   * // main.ts
-   * import 'virtual:dev-inspector-mcp';
-   * ```
+   * import { registerInspectorTool } from 'virtual:dev-inspector-mcp';
    *
-   * When building for production, bundlers will statically replace `import.meta.env.DEV`
-   * with `false`, causing the entire module code to be removed via dead code elimination.
+   * registerInspectorTool({
+   *   name: "custom_alert",
+   *   description: "Show a custom alert in the browser",
+   *   inputSchema: {
+   *     type: "object",
+   *     properties: {
+   *       message: { type: "string", description: "Message to display" }
+   *     },
+   *     required: ["message"]
+   *   },
+   *   implementation: (args) => {
+   *     alert(args.message as string);
+   *     return { success: true };
+   *   }
+   * });
+   * ```
+   */
+  export function registerInspectorTool(tool: InspectorTool): void;
+
+  /**
+   * Development-only inspector initialization module.
+   * This module is automatically tree-shaken in production builds.
    */
   const _default: void;
   export default _default;

package/dist/config-updater.cjs

@@ -87226,7 +87226,7 @@ function setupInspectorMiddleware(middlewares, config) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@mcpc-tech+acp-ai-provider@0.1.37/node_modules/@mcpc-tech/acp-ai-provider/index.mjs
+//#region ../../node_modules/.pnpm/@mcpc-tech+acp-ai-provider@0.1.41/node_modules/@mcpc-tech/acp-ai-provider/index.mjs
 (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 function formatToolError(toolResult) {
 	if (!toolResult || toolResult.length === 0) return "Unknown tool error";
@@ -87383,8 +87383,13 @@ var ToolProxyHost = class {
 	* Start TCP server and return MCP server config for ACP
 	*/
 	async start() {
-		if (this.server) throw new Error("Tool proxy already started");
-		await this.startServer();
+		if (!this.server) await this.startServer();
+		return this.getServerConfig();
+	}
+	/**
+	* Get MCP server configuration
+	*/
+	getServerConfig() {
 		return {
 			name: this.serverName,
 			command: "node",
@@ -87464,8 +87469,10 @@ var ToolProxyHost = class {
 					text: typeof result === "string" ? result : JSON.stringify(result)
 				}] };
 				this.sendResponse(socket, createResponse(request.id, toolResult));
-			} else if (request.method === "getTools") this.sendResponse(socket, createResponse(request.id, this.getToolDefinitions()));
-			else this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Unknown method: ${request.method}`));
+			} else if (request.method === "getTools") {
+				const definitions = this.getToolDefinitions();
+				this.sendResponse(socket, createResponse(request.id, definitions));
+			} else this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Unknown method: ${request.method}`));
 		} catch (error) {
 			this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.INTERNAL_ERROR, error instanceof Error ? error.message : String(error)));
 		}
@@ -87565,16 +87572,22 @@ function convertAiSdkMessagesToAcp(options, isFreshSession) {
 	}
 	return contentBlocks;
 }
-function extractACPTools(tools) {
+function extractACPTools(tools, prepared = true) {
 	const acpTools2 = [];
 	if (!tools) return acpTools2;
-	for (const t of tools) if (t.type === "function") {
+	const toolsArray = Array.isArray(tools) ? tools : Object.entries(tools).map(([name, tool2]) => ({
+		type: "function",
+		name,
+		...tool2
+	}));
+	for (const t of toolsArray) if (t.type === "function") {
 		const toolInputSchema = t.inputSchema;
 		if (hasRegisteredExecute(t.name) && toolInputSchema) {
 			const execute = getExecuteByName(t.name);
 			if (execute) acpTools2.push({
 				...t,
 				name: t.name,
+				inputSchema: prepared ? toolInputSchema : (0, ai.asSchema)(toolInputSchema).jsonSchema,
 				execute
 			});
 		}
@@ -87607,12 +87620,10 @@ var ACPAISDKClient = class {
 			optionId: params.options[0]?.optionId || "allow"
 		} };
 	}
-	writeTextFile(params) {
-		console.log("[acp-ai-provider] Write file request (not implemented):", params.path);
+	writeTextFile(_params) {
 		throw new Error("File operations not implemented in language model client");
 	}
-	readTextFile(params) {
-		console.log("[acp-ai-provider] Read file request (not implemented):", params.path);
+	readTextFile(_params) {
 		throw new Error("File operations not implemented in language model client");
 	}
 };
@@ -87658,6 +87669,7 @@ var ACPLanguageModel = class {
 	*/
 	parseToolCall(update$1) {
 		if (update$1.sessionUpdate !== "tool_call") throw new Error("Invalid update type for parseToolCall");
+		console.log("Parsing tool call update:", JSON.stringify(update$1, null, 2));
 		return {
 			toolCallId: update$1.toolCallId,
 			toolName: update$1.title || update$1.toolCallId,
@@ -87730,7 +87742,7 @@ var ACPLanguageModel = class {
 		if (initResult.authMethods?.length ?? false) {
 			if (!this.config.authMethodId || !validAuthMethods) console.log("[acp-ai-provider] Warning: No authMethodId specified in config, skipping authentication step. If this is not desired, please set one of the authMethodId in the ACPProviderSettings.", JSON.stringify(initResult.authMethods, null, 2));
 			if (this.config.authMethodId && validAuthMethods) await this.connection.authenticate({ methodId: this.config.authMethodId ?? initResult.authMethods?.[0].id });
-		} else console.log(`[acp-ai-provider] No authentication methods required by the ACP agent, skipping authentication step.`);
+		}
 	}
 	/**
 	* Starts a new session or updates the existing one.
@@ -87738,19 +87750,19 @@ var ACPLanguageModel = class {
 	*/
 	async startSession(acpTools2) {
 		if (!this.connection) throw new Error("Not connected");
-		console.log(`[acp-ai-provider] startSession called with ${acpTools2?.length ?? 0} tools`);
 		const mcpServers = [...this.config.session?.mcpServers ?? []];
 		let toolsAdded = false;
 		if (acpTools2 && acpTools2.length > 0 && !this.toolProxyHost) {
-			console.log("[acp-ai-provider] Setting up tool proxy for client-side tools...");
+			console.log("[acp-ai-provider] Setting up tool proxy for client-side tools...", acpTools2.map((t) => t.name));
 			this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
 			for (const t of acpTools2) this.toolProxyHost.registerTool(t.name, t);
+			toolsAdded = true;
+		}
+		if (this.toolProxyHost) {
 			const proxyConfig = await this.toolProxyHost.start();
 			mcpServers.push(proxyConfig);
-			toolsAdded = true;
 		}
 		if (this.sessionId && toolsAdded) {
-			console.log("[acp-ai-provider] Updating session to include new tools...");
 			this.sessionResponse = await this.connection.newSession({
 				...this.config.session,
 				cwd: this.config.session?.cwd ?? node_process.default.cwd(),
@@ -87795,7 +87807,7 @@ var ACPLanguageModel = class {
 	}
 	async applySessionDelay() {
 		if (this.config.sessionDelayMs) {
-			console.log(`[acp-ai-provider] Waiting for ${this.config.sessionDelayMs}ms after session setup...`);
+			console.log(`[acp-ai-provider] Waiting ${this.config.sessionDelayMs}ms after session setup...`);
 			await new Promise((resolve$1) => setTimeout(resolve$1, this.config.sessionDelayMs));
 		}
 	}
@@ -87830,14 +87842,9 @@ var ACPLanguageModel = class {
 	*
 	* @param acpTools - Optional list of tools to register during session initialization.
 	*/
-	async initSession(acpTools2) {
-		let toolsArray = [];
-		if (acpTools2) if (Array.isArray(acpTools2)) toolsArray = acpTools2;
-		else toolsArray = Object.entries(acpTools2).map(([name, tool2]) => ({
-			...tool2,
-			name
-		}));
-		await this.ensureConnected(toolsArray);
+	async initSession(tools) {
+		const acpTools2 = extractACPTools(tools, false);
+		await this.ensureConnected(acpTools2.length > 0 ? acpTools2 : void 0);
 		return this.sessionResponse;
 	}
 	/**
@@ -87964,6 +87971,11 @@ var ACPLanguageModel = class {
 					this.currentThinkingId = null;
 				}
 				const { toolCallId, toolName, toolInput } = this.parseToolCall(update$1);
+				console.log(`Parsing tool call: ${JSON.stringify({
+					toolCallId,
+					toolName,
+					toolInput
+				}, null, 2)}`);
 				const existingToolCall = this.toolCallsMap.get(toolCallId);
 				const hasInput = toolInput && typeof toolInput === "object" && Object.keys(toolInput).length > 0;
 				if (!existingToolCall) {
@@ -88004,7 +88016,6 @@ var ACPLanguageModel = class {
 				break;
 			}
 			case "tool_call_update": {
-				console.log(`###[acp-ai-provider] tool_call_update received:`, JSON.stringify(update$1, null, 2));
 				const { toolCallId, toolName, toolResult, isError, status } = this.parseToolResult(update$1);
 				let toolInfo = this.toolCallsMap.get(toolCallId);
 				if (status === "in_progress") {
@@ -88257,9 +88268,9 @@ var ACPProvider = class {
 	* Initializes the session and returns session info (models, modes, meta).
 	* Call this before prompting to discover available options.
 	*/
-	initSession(acpTools2) {
+	initSession(tools) {
 		if (!this.model) this.languageModel();
-		return this.model.initSession(acpTools2);
+		return this.model.initSession(tools);
 	}
 	/**
 	* Initializes the connection to the agent process without starting a session.
@@ -88298,6 +88309,22 @@ function createACPProvider(config) {
 //#endregion
 //#region src/middleware/acp-middleware.ts
 /**
+* Provider manager - stores one provider per agent config
+* Key: agentKey (command:args), Value: ProviderEntry
+*/
+const providerManager = /* @__PURE__ */ new Map();
+/**
+* Session to provider mapping for quick lookup
+* Key: sessionId, Value: agentKey
+*/
+const sessionToProvider = /* @__PURE__ */ new Map();
+/**
+* Generate a unique key for an agent configuration
+*/
+function getAgentKey(command, args) {
+	return `${command}:${(args || []).join(",")}`;
+}
+/**
 * Call MCP method via transport and wait for response
 */
 function callMcpMethodViaTransport(transport, method, params) {
@@ -88355,6 +88382,163 @@ function getActiveTransport() {
 	return connectionManager.transports[sessionIds[0]];
 }
 function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
+	/**
+	* Initialize a session for an agent
+	* POST /api/acp/init-session
+	* Body: { agent, envVars }
+	* Returns: { sessionId }
+	*/
+	middlewares.use("/api/acp/init-session", async (req, res) => {
+		if (handleCors(res, req.method)) return;
+		if (req.method !== "POST") {
+			res.statusCode = 405;
+			res.end("Method Not Allowed");
+			return;
+		}
+		try {
+			const body = await readBody(req);
+			const { agent, envVars } = JSON.parse(body);
+			const cwd$1 = process.cwd();
+			const agentKey = getAgentKey(agent.command, agent.args);
+			console.log(`[dev-inspector] [acp] Requesting session for agent: ${agent.name} (${agentKey})`);
+			let providerEntry = providerManager.get(agentKey);
+			let sessionId = "";
+			if (providerEntry) {
+				if (providerEntry.sessions.size > 0) {
+					const firstSession = providerEntry.sessions.values().next().value;
+					if (firstSession) {
+						sessionId = firstSession.sessionId;
+						console.log(`[dev-inspector] [acp] Reusing existing session: ${sessionId} for ${agent.name}`);
+					}
+				}
+				if (!sessionId && providerEntry.initializationPromise) {
+					console.log(`[dev-inspector] [acp] Joining pending initialization for ${agent.name}`);
+					try {
+						sessionId = await providerEntry.initializationPromise;
+					} catch (e) {
+						throw e;
+					}
+				}
+			}
+			if (!sessionId) {
+				let provider;
+				if (providerEntry) {
+					console.log(`[dev-inspector] [acp] Reusing existing provider for ${agent.name}`);
+					provider = providerEntry.provider;
+				} else {
+					console.log(`[dev-inspector] [acp] Creating new global provider for ${agent.name}`);
+					provider = createACPProvider({
+						command: agent.command,
+						args: agent.args,
+						env: {
+							...process.env,
+							...envVars
+						},
+						session: {
+							cwd: cwd$1,
+							mcpServers: []
+						},
+						authMethodId: agent.authMethodId,
+						persistSession: true
+					});
+					providerEntry = {
+						provider,
+						agentKey,
+						sessions: /* @__PURE__ */ new Map(),
+						createdAt: Date.now(),
+						initializationPromise: void 0
+					};
+					providerManager.set(agentKey, providerEntry);
+				}
+				console.log(`[dev-inspector] [acp] Spawning new process/session for ${agent.name}`);
+				const initPromise = (async () => {
+					const transport = getActiveTransport();
+					let initialTools = {};
+					if (transport) try {
+						const rawTools = await loadMcpToolsV5(transport);
+						initialTools = acpTools(rawTools);
+						console.log(`[dev-inspector] [acp] Pre-loading ${Object.keys(rawTools).length} tools for session init`);
+					} catch (e) {
+						console.warn("[dev-inspector] [acp] Failed to pre-load tools:", e);
+					}
+					const sid = (await provider.initSession(initialTools)).sessionId || `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+					if (providerEntry) {
+						providerEntry.sessions.set(sid, {
+							sessionId: sid,
+							createdAt: Date.now()
+						});
+						providerEntry.initializationPromise = void 0;
+					}
+					sessionToProvider.set(sid, agentKey);
+					return sid;
+				})();
+				if (providerEntry) providerEntry.initializationPromise = initPromise;
+				try {
+					sessionId = await initPromise;
+					console.log(`[dev-inspector] [acp] Session initialized: ${sessionId}`);
+				} catch (error) {
+					if (providerEntry) providerEntry.initializationPromise = void 0;
+					throw error;
+				}
+			}
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify({ sessionId }));
+		} catch (error) {
+			console.error("ACP Init Session Error:", error);
+			if (!res.headersSent) {
+				res.statusCode = 500;
+				res.end(JSON.stringify({ error: error instanceof Error ? error.message : "Internal Server Error" }));
+			}
+		}
+	});
+	/**
+	* Cleanup a session
+	* POST /api/acp/cleanup-session
+	* Body: { sessionId }
+	*/
+	middlewares.use("/api/acp/cleanup-session", async (req, res) => {
+		if (handleCors(res, req.method)) return;
+		if (req.method !== "POST") {
+			res.statusCode = 405;
+			res.end("Method Not Allowed");
+			return;
+		}
+		try {
+			const body = await readBody(req);
+			const { sessionId } = JSON.parse(body);
+			const agentKey = sessionToProvider.get(sessionId);
+			if (agentKey) {
+				const providerEntry = providerManager.get(agentKey);
+				if (providerEntry) {
+					console.log(`[dev-inspector] [acp] Cleaning up session: ${sessionId} (Provider sessions left: ${providerEntry.sessions.size - 1})`);
+					providerEntry.sessions.delete(sessionId);
+					if (providerEntry.sessions.size === 0) {
+						console.log(`[dev-inspector] [acp] No active sessions for ${agentKey}, cleaning up provider`);
+						try {
+							providerEntry.provider.cleanup();
+						} catch (e) {
+							console.error("Error cleaning up provider:", e);
+						}
+						providerManager.delete(agentKey);
+					}
+				}
+				sessionToProvider.delete(sessionId);
+			}
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify({ success: true }));
+		} catch (error) {
+			console.error("ACP Cleanup Session Error:", error);
+			if (!res.headersSent) {
+				res.statusCode = 500;
+				res.end(JSON.stringify({ error: "Internal Server Error" }));
+			}
+		}
+	});
+	/**
+	* Chat endpoint
+	* POST /api/acp/chat
+	* Body: { messages, agent, envVars, sessionId? }
+	*/
 	middlewares.use("/api/acp/chat", async (req, res) => {
 		if (handleCors(res, req.method)) return;
 		if (req.method !== "POST") {
@@ -88364,18 +88548,36 @@ function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 		}
 		try {
 			const body = await readBody(req);
-			const { messages, agent, envVars } = JSON.parse(body);
+			const { messages, agent, envVars, sessionId } = JSON.parse(body);
 			const cwd$1 = process.cwd();
-			const provider = createACPProvider({
-				command: agent.command,
-				args: agent.args,
-				env: envVars,
-				session: {
-					cwd: cwd$1,
-					mcpServers: []
-				},
-				authMethodId: agent.authMethodId
-			});
+			let provider;
+			let shouldCleanupProvider = true;
+			let existingProviderEntry;
+			if (sessionId) {
+				const agentKey = sessionToProvider.get(sessionId);
+				if (agentKey) existingProviderEntry = providerManager.get(agentKey);
+			}
+			if (existingProviderEntry) {
+				console.log(`[dev-inspector] [acp] Using existing global provider for session: ${sessionId}`);
+				provider = existingProviderEntry.provider;
+				shouldCleanupProvider = false;
+			} else {
+				console.log(`[dev-inspector] [acp] Creating new provider (no session found or provided)`);
+				provider = createACPProvider({
+					command: agent.command,
+					args: agent.args,
+					env: {
+						...process.env,
+						...envVars
+					},
+					session: {
+						cwd: cwd$1,
+						mcpServers: []
+					},
+					authMethodId: agent.authMethodId
+				});
+				await provider.initSession();
+			}
 			const transport = getActiveTransport();
 			let mcpTools = {};
 			if (transport) mcpTools = await loadMcpToolsV5(transport);
@@ -88391,7 +88593,7 @@ function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 			req.on("close", () => {
 				console.log("[dev-inspector] [acp] Client disconnected, aborting stream");
 				abortController.abort();
-				provider.cleanup();
+				if (shouldCleanupProvider) provider.cleanup();
 			});
 			const response = (0, ai.streamText)({
 				model: provider.languageModel(model, mode),