@mcpc-tech/unplugin-dev-inspector-mcp 0.0.12 → 0.0.14

package/dist/config-updater.js

@@ -7,8 +7,9 @@ import z$1, { z } from "zod";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { Readable, Writable } from "node:stream";
 import { Readable as Readable$1 } from "stream";
+import { createServer } from "node:net";
 import { createHash } from "node:crypto";
-import path, { dirname, resolve } from "node:path";
+import path from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -20,12 +21,11 @@ import fs, { existsSync } from "fs";
 import * as http from "http";
 import * as https from "https";
 import * as zlib from "zlib";
-import path$1, { dirname as dirname$1, join } from "path";
+import path$1, { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { convertToModelMessages, jsonSchema, streamText, tool } from "ai";
 import { ClientSideConnection, PROTOCOL_VERSION, ndJsonStream, planEntrySchema } from "@agentclientprotocol/sdk";
 import { spawn } from "node:child_process";
-import { existsSync as existsSync$1, readFileSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 
 //#region rolldown:runtime
@@ -276,13 +276,13 @@ var ClientExecServer = class {
 			return toolCallHandler?.(request$1, extra);
 		}
 		const requestId = crypto.randomUUID();
-		const resultPromise = new Promise((resolve$4, reject) => {
+		const resultPromise = new Promise((resolve$3, reject) => {
 			const timeout = setTimeout(() => {
 				this.pendingRequests.delete(requestId);
 				reject(new McpError(ErrorCode.InternalError, `Tool execution timeout for ${name}`));
 			}, this.requestTimeoutMs);
 			this.pendingRequests.set(requestId, {
-				resolve: resolve$4,
+				resolve: resolve$3,
 				reject,
 				timeout
 			});
@@ -26586,9 +26586,9 @@ var require_dispatcher_base = /* @__PURE__ */ __commonJSMin(((exports, module) =
 			return this[kClosed$3];
 		}
 		close(callback) {
-			if (callback === void 0) return new Promise((resolve$4, reject) => {
+			if (callback === void 0) return new Promise((resolve$3, reject) => {
 				this.close((err, data$1) => {
-					return err ? reject(err) : resolve$4(data$1);
+					return err ? reject(err) : resolve$3(data$1);
 				});
 			});
 			if (typeof callback !== "function") throw new InvalidArgumentError$27("invalid callback");
@@ -26617,9 +26617,9 @@ var require_dispatcher_base = /* @__PURE__ */ __commonJSMin(((exports, module) =
 				callback = err;
 				err = null;
 			}
-			if (callback === void 0) return new Promise((resolve$4, reject) => {
+			if (callback === void 0) return new Promise((resolve$3, reject) => {
 				this.destroy(err, (err$1, data$1) => {
-					return err$1 ? reject(err$1) : resolve$4(data$1);
+					return err$1 ? reject(err$1) : resolve$3(data$1);
 				});
 			});
 			if (typeof callback !== "function") throw new InvalidArgumentError$27("invalid callback");
@@ -29620,8 +29620,8 @@ var require_promise$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		let res;
 		let rej;
 		return {
-			promise: new Promise((resolve$4, reject) => {
-				res = resolve$4;
+			promise: new Promise((resolve$3, reject) => {
+				res = resolve$3;
 				rej = reject;
 			}),
 			resolve: res,
@@ -30731,10 +30731,10 @@ var require_client_h1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				cb();
 			}
 		}
-		const waitForDrain = () => new Promise((resolve$4, reject) => {
+		const waitForDrain = () => new Promise((resolve$3, reject) => {
 			assert$23(callback === null);
 			if (socket[kError$2]) reject(socket[kError$2]);
-			else callback = resolve$4;
+			else callback = resolve$3;
 		});
 		socket.on("close", onDrain).on("drain", onDrain);
 		const writer = new AsyncWriter({
@@ -31262,10 +31262,10 @@ var require_client_h2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				cb();
 			}
 		}
-		const waitForDrain = () => new Promise((resolve$4, reject) => {
+		const waitForDrain = () => new Promise((resolve$3, reject) => {
 			assert$22(callback === null);
 			if (socket[kError$1]) reject(socket[kError$1]);
-			else callback = resolve$4;
+			else callback = resolve$3;
 		});
 		h2stream.on("close", onDrain).on("drain", onDrain);
 		try {
@@ -31425,13 +31425,13 @@ var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			return this[kNeedDrain$3] < 2;
 		}
 		[kClose$7]() {
-			return new Promise((resolve$4) => {
-				if (this[kSize$2]) this[kClosedResolve$1] = resolve$4;
-				else resolve$4(null);
+			return new Promise((resolve$3) => {
+				if (this[kSize$2]) this[kClosedResolve$1] = resolve$3;
+				else resolve$3(null);
 			});
 		}
 		[kDestroy$5](err) {
-			return new Promise((resolve$4) => {
+			return new Promise((resolve$3) => {
 				const requests = this[kQueue$1].splice(this[kPendingIdx]);
 				for (let i$4 = 0; i$4 < requests.length; i$4++) {
 					const request$1 = requests[i$4];
@@ -31442,7 +31442,7 @@ var require_client = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						this[kClosedResolve$1]();
 						this[kClosedResolve$1] = null;
 					}
-					resolve$4(null);
+					resolve$3(null);
 				};
 				if (this[kHTTPContext]) {
 					this[kHTTPContext].destroy(err, callback);
@@ -31796,8 +31796,8 @@ var require_pool_base = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				const closeAll = new Array(this[kClients$4].length);
 				for (let i$4 = 0; i$4 < this[kClients$4].length; i$4++) closeAll[i$4] = this[kClients$4][i$4].close();
 				return Promise.all(closeAll);
-			} else return new Promise((resolve$4) => {
-				this[kClosedResolve] = resolve$4;
+			} else return new Promise((resolve$3) => {
+				this[kClosedResolve] = resolve$3;
 			});
 		}
 		[kDestroy$4](err) {
@@ -33017,7 +33017,7 @@ var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const limit = opts?.limit && Number.isFinite(opts.limit) ? opts.limit : 128 * 1024;
 			if (signal?.aborted) return Promise.reject(signal.reason ?? new AbortError$1());
 			if (this._readableState.closeEmitted) return Promise.resolve(null);
-			return new Promise((resolve$4, reject) => {
+			return new Promise((resolve$3, reject) => {
 				if (this[kContentLength$1] && this[kContentLength$1] > limit || this[kBytesRead] > limit) this.destroy(new AbortError$1());
 				if (signal) {
 					const onAbort = () => {
@@ -33027,9 +33027,9 @@ var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					this.on("close", function() {
 						signal.removeEventListener("abort", onAbort);
 						if (signal.aborted) reject(signal.reason ?? new AbortError$1());
-						else resolve$4(null);
+						else resolve$3(null);
 					});
-				} else this.on("close", resolve$4);
+				} else this.on("close", resolve$3);
 				this.on("error", noop$6).on("data", () => {
 					if (this[kBytesRead] > limit) this.destroy();
 				}).resume();
@@ -33090,7 +33090,7 @@ var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	*/
 	function consume(stream$2, type) {
 		assert$19(!stream$2[kConsume]);
-		return new Promise((resolve$4, reject) => {
+		return new Promise((resolve$3, reject) => {
 			if (isUnusable(stream$2)) {
 				const rState = stream$2._readableState;
 				if (rState.destroyed && rState.closeEmitted === false) stream$2.on("error", reject).on("close", () => {
@@ -33101,7 +33101,7 @@ var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				stream$2[kConsume] = {
 					type,
 					stream: stream$2,
-					resolve: resolve$4,
+					resolve: resolve$3,
 					reject,
 					length: 0,
 					body: []
@@ -33171,13 +33171,13 @@ var require_readable = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @returns {void}
 	*/
 	function consumeEnd(consume$1, encoding) {
-		const { type, body, resolve: resolve$4, stream: stream$2, length } = consume$1;
+		const { type, body, resolve: resolve$3, stream: stream$2, length } = consume$1;
 		try {
-			if (type === "text") resolve$4(chunksDecode(body, length, encoding));
-			else if (type === "json") resolve$4(JSON.parse(chunksDecode(body, length, encoding)));
-			else if (type === "arrayBuffer") resolve$4(chunksConcat(body, length).buffer);
-			else if (type === "blob") resolve$4(new Blob(body, { type: stream$2[kContentType] }));
-			else if (type === "bytes") resolve$4(chunksConcat(body, length));
+			if (type === "text") resolve$3(chunksDecode(body, length, encoding));
+			else if (type === "json") resolve$3(JSON.parse(chunksDecode(body, length, encoding)));
+			else if (type === "arrayBuffer") resolve$3(chunksConcat(body, length).buffer);
+			else if (type === "blob") resolve$3(new Blob(body, { type: stream$2[kContentType] }));
+			else if (type === "bytes") resolve$3(chunksConcat(body, length));
 			consumeFinish(consume$1);
 		} catch (err) {
 			stream$2.destroy(err);
@@ -33345,9 +33345,9 @@ var require_api_request = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	};
 	function request(opts, callback) {
-		if (callback === void 0) return new Promise((resolve$4, reject) => {
+		if (callback === void 0) return new Promise((resolve$3, reject) => {
 			request.call(this, opts, (err, data$1) => {
-				return err ? reject(err) : resolve$4(data$1);
+				return err ? reject(err) : resolve$3(data$1);
 			});
 		});
 		try {
@@ -33517,9 +33517,9 @@ var require_api_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	};
 	function stream(opts, factory$1, callback) {
-		if (callback === void 0) return new Promise((resolve$4, reject) => {
+		if (callback === void 0) return new Promise((resolve$3, reject) => {
 			stream.call(this, opts, factory$1, (err, data$1) => {
-				return err ? reject(err) : resolve$4(data$1);
+				return err ? reject(err) : resolve$3(data$1);
 			});
 		});
 		try {
@@ -33762,9 +33762,9 @@ var require_api_upgrade = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	};
 	function upgrade(opts, callback) {
-		if (callback === void 0) return new Promise((resolve$4, reject) => {
+		if (callback === void 0) return new Promise((resolve$3, reject) => {
 			upgrade.call(this, opts, (err, data$1) => {
-				return err ? reject(err) : resolve$4(data$1);
+				return err ? reject(err) : resolve$3(data$1);
 			});
 		});
 		try {
@@ -33843,9 +33843,9 @@ var require_api_connect = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		}
 	};
 	function connect(opts, callback) {
-		if (callback === void 0) return new Promise((resolve$4, reject) => {
+		if (callback === void 0) return new Promise((resolve$3, reject) => {
 			connect.call(this, opts, (err, data$1) => {
-				return err ? reject(err) : resolve$4(data$1);
+				return err ? reject(err) : resolve$3(data$1);
 			});
 		});
 		try {
@@ -34903,7 +34903,7 @@ var require_snapshot_utils = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 //#region ../../node_modules/.pnpm/undici@7.16.0/node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { writeFile: writeFile$1, readFile: readFile$1, mkdir: mkdir$1 } = __require("node:fs/promises");
-	const { dirname: dirname$2, resolve: resolve$3 } = __require("node:path");
+	const { dirname: dirname$1, resolve: resolve$2 } = __require("node:path");
 	const { setTimeout: setTimeout$1, clearTimeout: clearTimeout$1 } = __require("node:timers");
 	const { InvalidArgumentError: InvalidArgumentError$6, UndiciError: UndiciError$1 } = require_errors$1();
 	const { hashId, isUrlExcludedFactory, normalizeHeaders: normalizeHeaders$2, createHeaderFilters } = require_snapshot_utils();
@@ -35161,7 +35161,7 @@ var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module)
 			const path$2 = filePath || this.#snapshotPath;
 			if (!path$2) throw new InvalidArgumentError$6("Snapshot path is required");
 			try {
-				const data$1 = await readFile$1(resolve$3(path$2), "utf8");
+				const data$1 = await readFile$1(resolve$2(path$2), "utf8");
 				const parsed = JSON.parse(data$1);
 				if (Array.isArray(parsed)) {
 					this.#snapshots.clear();
@@ -35181,8 +35181,8 @@ var require_snapshot_recorder = /* @__PURE__ */ __commonJSMin(((exports, module)
 		async saveSnapshots(filePath) {
 			const path$2 = filePath || this.#snapshotPath;
 			if (!path$2) throw new InvalidArgumentError$6("Snapshot path is required");
-			const resolvedPath = resolve$3(path$2);
-			await mkdir$1(dirname$2(resolvedPath), { recursive: true });
+			const resolvedPath = resolve$2(path$2);
+			await mkdir$1(dirname$1(resolvedPath), { recursive: true });
 			const data$1 = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
 				hash,
 				snapshot
@@ -40087,7 +40087,7 @@ var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const url = requestCurrentURL(request$1);
 			/** @type {import('../../..').Agent} */
 			const agent = fetchParams.controller.dispatcher;
-			return new Promise((resolve$4, reject) => agent.dispatch({
+			return new Promise((resolve$3, reject) => agent.dispatch({
 				path: url.pathname + url.search,
 				origin: url.origin,
 				method: request$1.method,
@@ -40148,7 +40148,7 @@ var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 						}
 					}
 					const onError$1 = this.onError.bind(this);
-					resolve$4({
+					resolve$3({
 						status,
 						statusText,
 						headersList,
@@ -40179,7 +40179,7 @@ var require_fetch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					if (status !== 101) return;
 					const headersList = new HeadersList();
 					for (let i$4 = 0; i$4 < rawHeaders.length; i$4 += 2) headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i$4]), rawHeaders[i$4 + 1].toString("latin1"), true);
-					resolve$4({
+					resolve$3({
 						status,
 						statusText: STATUS_CODES[status],
 						headersList,
@@ -46871,7 +46871,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 		ref = (0, resolve_1$1.resolveUrl)(this.opts.uriResolver, baseId, ref);
 		const schOrFunc = root$2.refs[ref];
 		if (schOrFunc) return schOrFunc;
-		let _sch = resolve$2.call(this, root$2, ref);
+		let _sch = resolve$1.call(this, root$2, ref);
 		if (_sch === void 0) {
 			const schema = (_a$2 = root$2.localRefs) === null || _a$2 === void 0 ? void 0 : _a$2[ref];
 			const { schemaId } = this.opts;
@@ -46897,7 +46897,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
 	function sameSchemaEnv(s1, s2) {
 		return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
 	}
-	function resolve$2(root$2, ref) {
+	function resolve$1(root$2, ref) {
 		let sch;
 		while (typeof (sch = this.refs[ref]) == "string") ref = sch;
 		return sch || this.schemas[ref] || resolveSchema.call(this, root$2, ref);
@@ -47470,7 +47470,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	* @param {import('./types/index').Options} [options]
 	* @returns {string}
 	*/
-	function resolve$1(baseURI, relativeURI, options) {
+	function resolve(baseURI, relativeURI, options) {
 		const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
 		const resolved = resolveComponent(parse$7(baseURI, schemelessOptions), parse$7(relativeURI, schemelessOptions), schemelessOptions, true);
 		schemelessOptions.skipEscape = true;
@@ -47669,7 +47669,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const fastUri = {
 		SCHEMES,
 		normalize,
-		resolve: resolve$1,
+		resolve,
 		resolveComponent,
 		equal: equal$1,
 		serialize,
@@ -56300,8 +56300,8 @@ var require_promise$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.Deferred = void 0;
 	var Deferred$1 = class {
 		constructor() {
-			this._promise = new Promise((resolve$4, reject) => {
-				this._resolve = resolve$4;
+			this._promise = new Promise((resolve$3, reject) => {
+				this._resolve = resolve$3;
 				this._reject = reject;
 			});
 		}
@@ -56367,10 +56367,10 @@ var require_exporter$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	* Shared functionality used by Exporters while exporting data, including suppression of Traces.
 	*/
 	function _export$1(exporter, arg) {
-		return new Promise((resolve$4) => {
+		return new Promise((resolve$3) => {
 			api_1$50.context.with((0, suppress_tracing_1$5.suppressTracing)(api_1$50.context.active()), () => {
 				exporter.export(arg, (result) => {
-					resolve$4(result);
+					resolve$3(result);
 				});
 			});
 		});
@@ -57631,19 +57631,19 @@ var require_BatchSpanProcessorBase = /* @__PURE__ */ __commonJSMin(((exports) =>
 		* for all other cases _flush should be used
 		* */
 		_flushAll() {
-			return new Promise((resolve$4, reject) => {
+			return new Promise((resolve$3, reject) => {
 				const promises = [];
 				const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
 				for (let i$4 = 0, j = count; i$4 < j; i$4++) promises.push(this._flushOneBatch());
 				Promise.all(promises).then(() => {
-					resolve$4();
+					resolve$3();
 				}).catch(reject);
 			});
 		}
 		_flushOneBatch() {
 			this._clearTimer();
 			if (this._finishedSpans.length === 0) return Promise.resolve();
-			return new Promise((resolve$4, reject) => {
+			return new Promise((resolve$3, reject) => {
 				const timer = setTimeout(() => {
 					reject(/* @__PURE__ */ new Error("Timeout"));
 				}, this._exportTimeoutMillis);
@@ -57656,7 +57656,7 @@ var require_BatchSpanProcessorBase = /* @__PURE__ */ __commonJSMin(((exports) =>
 					const doExport = () => this._exporter.export(spans, (result) => {
 						var _a$2;
 						clearTimeout(timer);
-						if (result.code === core_1$18.ExportResultCode.SUCCESS) resolve$4();
+						if (result.code === core_1$18.ExportResultCode.SUCCESS) resolve$3();
 						else reject((_a$2 = result.error) !== null && _a$2 !== void 0 ? _a$2 : /* @__PURE__ */ new Error("BatchSpanProcessor: span export failed"));
 					});
 					let pendingResources = null;
@@ -58932,12 +58932,12 @@ var require_MultiSpanProcessor = /* @__PURE__ */ __commonJSMin(((exports) => {
 		forceFlush() {
 			const promises = [];
 			for (const spanProcessor of this._spanProcessors) promises.push(spanProcessor.forceFlush());
-			return new Promise((resolve$4) => {
+			return new Promise((resolve$3) => {
 				Promise.all(promises).then(() => {
-					resolve$4();
+					resolve$3();
 				}).catch((error$1) => {
 					(0, core_1$14.globalErrorHandler)(error$1 || /* @__PURE__ */ new Error("MultiSpanProcessor: forceFlush failed"));
-					resolve$4();
+					resolve$3();
 				});
 			});
 		}
@@ -58950,9 +58950,9 @@ var require_MultiSpanProcessor = /* @__PURE__ */ __commonJSMin(((exports) => {
 		shutdown() {
 			const promises = [];
 			for (const spanProcessor of this._spanProcessors) promises.push(spanProcessor.shutdown());
-			return new Promise((resolve$4, reject) => {
+			return new Promise((resolve$3, reject) => {
 				Promise.all(promises).then(() => {
-					resolve$4();
+					resolve$3();
 				}, reject);
 			});
 		}
@@ -59059,30 +59059,30 @@ var require_BasicTracerProvider = /* @__PURE__ */ __commonJSMin(((exports) => {
 		forceFlush() {
 			const timeout = this._config.forceFlushTimeoutMillis;
 			const promises = this._registeredSpanProcessors.map((spanProcessor) => {
-				return new Promise((resolve$4) => {
+				return new Promise((resolve$3) => {
 					let state;
 					const timeoutInterval = setTimeout(() => {
-						resolve$4(/* @__PURE__ */ new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+						resolve$3(/* @__PURE__ */ new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
 						state = ForceFlushState.timeout;
 					}, timeout);
 					spanProcessor.forceFlush().then(() => {
 						clearTimeout(timeoutInterval);
 						if (state !== ForceFlushState.timeout) {
 							state = ForceFlushState.resolved;
-							resolve$4(state);
+							resolve$3(state);
 						}
 					}).catch((error$1) => {
 						clearTimeout(timeoutInterval);
 						state = ForceFlushState.error;
-						resolve$4(error$1);
+						resolve$3(error$1);
 					});
 				});
 			});
-			return new Promise((resolve$4, reject) => {
+			return new Promise((resolve$3, reject) => {
 				Promise.all(promises).then((results) => {
 					const errors$1 = results.filter((result) => result !== ForceFlushState.resolved);
 					if (errors$1.length > 0) reject(errors$1);
-					else resolve$4();
+					else resolve$3();
 				}).catch((error$1) => reject([error$1]));
 			});
 		}
@@ -61219,11 +61219,11 @@ var __awaiter$3, __generator$3, BoundedQueueExportPromiseHandler;
 var init_bounded_queue_export_promise_handler = __esmMin((() => {
 	__awaiter$3 = void 0 && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
 		function adopt(value) {
-			return value instanceof P ? value : new P(function(resolve$4) {
-				resolve$4(value);
+			return value instanceof P ? value : new P(function(resolve$3) {
+				resolve$3(value);
 			});
 		}
-		return new (P || (P = Promise))(function(resolve$4, reject) {
+		return new (P || (P = Promise))(function(resolve$3, reject) {
 			function fulfilled(value) {
 				try {
 					step(generator.next(value));
@@ -61239,7 +61239,7 @@ var init_bounded_queue_export_promise_handler = __esmMin((() => {
 				}
 			}
 			function step(result) {
-				result.done ? resolve$4(result.value) : adopt(result.value).then(fulfilled, rejected);
+				result.done ? resolve$3(result.value) : adopt(result.value).then(fulfilled, rejected);
 			}
 			step((generator = generator.apply(thisArg, _arguments || [])).next());
 		});
@@ -63035,8 +63035,8 @@ var require_promise = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.Deferred = void 0;
 	var Deferred = class {
 		constructor() {
-			this._promise = new Promise((resolve$4, reject) => {
-				this._resolve = resolve$4;
+			this._promise = new Promise((resolve$3, reject) => {
+				this._resolve = resolve$3;
 				this._reject = reject;
 			});
 		}
@@ -63102,10 +63102,10 @@ var require_exporter = /* @__PURE__ */ __commonJSMin(((exports) => {
 	* Shared functionality used by Exporters while exporting data, including suppression of Traces.
 	*/
 	function _export(exporter, arg) {
-		return new Promise((resolve$4) => {
+		return new Promise((resolve$3) => {
 			api_1$17.context.with((0, suppress_tracing_1$1.suppressTracing)(api_1$17.context.active()), () => {
 				exporter.export(arg, (result) => {
-					resolve$4(result);
+					resolve$3(result);
 				});
 			});
 		});
@@ -63563,11 +63563,11 @@ var init_otlp_export_delegate = __esmMin((() => {
 	init_esm$2();
 	__awaiter$2 = void 0 && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
 		function adopt(value) {
-			return value instanceof P ? value : new P(function(resolve$4) {
-				resolve$4(value);
+			return value instanceof P ? value : new P(function(resolve$3) {
+				resolve$3(value);
 			});
 		}
-		return new (P || (P = Promise))(function(resolve$4, reject) {
+		return new (P || (P = Promise))(function(resolve$3, reject) {
 			function fulfilled(value) {
 				try {
 					step(generator.next(value));
@@ -63583,7 +63583,7 @@ var init_otlp_export_delegate = __esmMin((() => {
 				}
 			}
 			function step(result) {
-				result.done ? resolve$4(result.value) : adopt(result.value).then(fulfilled, rejected);
+				result.done ? resolve$3(result.value) : adopt(result.value).then(fulfilled, rejected);
 			}
 			step((generator = generator.apply(thisArg, _arguments || [])).next());
 		});
@@ -68849,7 +68849,7 @@ var require_aspromise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	function asPromise(fn, ctx) {
 		var params = new Array(arguments.length - 1), offset = 0, index$1 = 2, pending = true;
 		while (index$1 < arguments.length) params[offset++] = arguments[index$1++];
-		return new Promise(function executor(resolve$4, reject) {
+		return new Promise(function executor(resolve$3, reject) {
 			params[offset] = function callback(err) {
 				if (pending) {
 					pending = false;
@@ -68857,7 +68857,7 @@ var require_aspromise = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					else {
 						var params$1 = new Array(arguments.length - 1), offset$1 = 0;
 						while (offset$1 < params$1.length) params$1[offset$1++] = arguments[offset$1];
-						resolve$4.apply(null, params$1);
+						resolve$3.apply(null, params$1);
 					}
 				}
 			};
@@ -82550,11 +82550,11 @@ var __awaiter$1, __generator$1, HttpExporterTransport;
 var init_http_exporter_transport = __esmMin((() => {
 	__awaiter$1 = void 0 && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
 		function adopt(value) {
-			return value instanceof P ? value : new P(function(resolve$4) {
-				resolve$4(value);
+			return value instanceof P ? value : new P(function(resolve$3) {
+				resolve$3(value);
 			});
 		}
-		return new (P || (P = Promise))(function(resolve$4, reject) {
+		return new (P || (P = Promise))(function(resolve$3, reject) {
 			function fulfilled(value) {
 				try {
 					step(generator.next(value));
@@ -82570,7 +82570,7 @@ var init_http_exporter_transport = __esmMin((() => {
 				}
 			}
 			function step(result) {
-				result.done ? resolve$4(result.value) : adopt(result.value).then(fulfilled, rejected);
+				result.done ? resolve$3(result.value) : adopt(result.value).then(fulfilled, rejected);
 			}
 			step((generator = generator.apply(thisArg, _arguments || [])).next());
 		});
@@ -82675,10 +82675,10 @@ var init_http_exporter_transport = __esmMin((() => {
 						this._agent = createHttpAgent$1(this._parameters.url, this._parameters.agentOptions);
 						this._send = sendWithHttp$1;
 					}
-					return [2, new Promise(function(resolve$4) {
+					return [2, new Promise(function(resolve$3) {
 						var _a$3;
 						(_a$3 = _this._send) === null || _a$3 === void 0 || _a$3.call(_this, _this._parameters, _this._agent, data$1, function(result) {
-							resolve$4(result);
+							resolve$3(result);
 						}, timeoutMillis);
 					})];
 				});
@@ -82707,11 +82707,11 @@ var __awaiter, __generator, MAX_ATTEMPTS, INITIAL_BACKOFF, MAX_BACKOFF, BACKOFF_
 var init_retrying_transport = __esmMin((() => {
 	__awaiter = void 0 && (void 0).__awaiter || function(thisArg, _arguments, P, generator) {
 		function adopt(value) {
-			return value instanceof P ? value : new P(function(resolve$4) {
-				resolve$4(value);
+			return value instanceof P ? value : new P(function(resolve$3) {
+				resolve$3(value);
 			});
 		}
-		return new (P || (P = Promise))(function(resolve$4, reject) {
+		return new (P || (P = Promise))(function(resolve$3, reject) {
 			function fulfilled(value) {
 				try {
 					step(generator.next(value));
@@ -82727,7 +82727,7 @@ var init_retrying_transport = __esmMin((() => {
 				}
 			}
 			function step(result) {
-				result.done ? resolve$4(result.value) : adopt(result.value).then(fulfilled, rejected);
+				result.done ? resolve$3(result.value) : adopt(result.value).then(fulfilled, rejected);
 			}
 			step((generator = generator.apply(thisArg, _arguments || [])).next());
 		});
@@ -82827,9 +82827,9 @@ var init_retrying_transport = __esmMin((() => {
 		}
 		RetryingTransport$1.prototype.retry = function(data$1, timeoutMillis, inMillis) {
 			var _this = this;
-			return new Promise(function(resolve$4, reject) {
+			return new Promise(function(resolve$3, reject) {
 				setTimeout(function() {
-					_this._transport.send(data$1, timeoutMillis).then(resolve$4, reject);
+					_this._transport.send(data$1, timeoutMillis).then(resolve$3, reject);
 				}, inMillis);
 			});
 		};
@@ -86594,14 +86594,14 @@ function callMcpMethod(mcpServer, method, params) {
 		jsonrpc: "2.0",
 		id: messageId
 	};
-	return new Promise((resolve$4) => {
+	return new Promise((resolve$3) => {
 		if (!mcpServer.transport) throw new Error("MCP server transport not initialized");
 		mcpServer.transport.onmessage?.(message);
 		const originalSend = mcpServer.transport.send;
 		mcpServer.transport.send = function(payload) {
 			const payloadObj = payload;
 			if (payloadObj.id === messageId) {
-				resolve$4(payloadObj.result);
+				resolve$3(payloadObj.result);
 				if (!mcpServer.transport) throw new Error("MCP server transport not initialized");
 				mcpServer.transport.send = originalSend;
 			}
@@ -86970,11 +86970,19 @@ function handleCors(res, method) {
 
 //#endregion
 //#region src/middleware/mcproute-middleware.ts
+let sharedConnectionManager = null;
+/**
+* Get the shared connection manager instance
+*/
+function getConnectionManager() {
+	return sharedConnectionManager;
+}
 /**
 * Setup MCP server endpoints in Vite dev server
 */
 async function setupMcpMiddleware(middlewares, serverContext) {
 	const connectionManager = new ConnectionManager();
+	sharedConnectionManager = connectionManager;
 	middlewares.use(async (req, res, next$1) => {
 		const url = req.url || "";
 		if (url.startsWith("/__mcp__")) {
@@ -87148,13 +87156,13 @@ async function handleSseMessage(req, res, serverContext, connectionManager) {
 * Helper to read request body
 */
 function readRequestBody(req) {
-	return new Promise((resolve$4, reject) => {
+	return new Promise((resolve$3, reject) => {
 		let body = "";
 		req.on("data", (chunk) => {
 			body += chunk.toString();
 		});
 		req.on("end", () => {
-			resolve$4(body);
+			resolve$3(body);
 		});
 		req.on("error", reject);
 	});
@@ -87168,7 +87176,7 @@ function isInitializeRequest(body) {
 
 //#endregion
 //#region src/middleware/inspector-middleware.ts
-const __dirname = dirname$1(fileURLToPath(import.meta.url));
+const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
 * Get the inspector client script content
 * Tries multiple paths to locate the bundled inspector script
@@ -87252,7 +87260,7 @@ function setupInspectorMiddleware(middlewares, config) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@mcpc-tech+acp-ai-provider@0.1.25/node_modules/@mcpc-tech/acp-ai-provider/index.mjs
+//#region ../../node_modules/.pnpm/@mcpc-tech+acp-ai-provider@0.1.31/node_modules/@mcpc-tech/acp-ai-provider/index.mjs
 createRequire(import.meta.url);
 function formatToolError(toolResult) {
 	if (!toolResult || toolResult.length === 0) return "Unknown tool error";
@@ -87265,7 +87273,284 @@ function formatToolError(toolResult) {
 function extractBase64Data(data$1) {
 	return data$1.includes(",") ? data$1.split(",")[1] : data$1;
 }
+function createResponse(id, result) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		result
+	};
+}
+function createErrorResponse(id, code, message, data$1) {
+	const error$1 = {
+		code,
+		message
+	};
+	if (data$1 !== void 0) error$1.data = data$1;
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: error$1
+	};
+}
+function parseMessage(line$1) {
+	try {
+		const parsed = JSON.parse(line$1);
+		if (parsed.jsonrpc !== "2.0") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function serializeMessage(message) {
+	return JSON.stringify(message);
+}
+var JsonRpcErrorCode = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603
+};
+var ProxyMethod = {
+	REGISTER_TOOLS: "registerTools",
+	CALL_HANDLER: "callHandler"
+};
+var RUNTIME_CODE = `
+/* MCP Protocol Version 2024-11-05 */
+const isDeno=typeof Deno!=="undefined",MCP_VER="2024-11-05";
+let tools=[],host=null,pending=new Map,buf="",hbuf="",rid=0;
+const env=k=>isDeno?Deno.env.get(k):process.env[k];
+const write=async m=>{
+  const s=JSON.stringify(m)+"\\n";
+  if(isDeno)await Deno.stdout.write(new TextEncoder().encode(s));
+  else process.stdout.write(s);
+};
+const send=(id,r,e)=>write({jsonrpc:"2.0",id,...(e?{error:e}:{result:r})});
+const hostReq=(m,p)=>new Promise((res,rej)=>{
+  const id="r-"+ ++rid;
+  const s=JSON.stringify({jsonrpc:"2.0",id,method:m,params:p})+"\\n";
+  if(isDeno)host.write(new TextEncoder().encode(s));
+  else host.write(s);
+  const t=setTimeout(()=>{pending.delete(id);rej(new Error("timeout"))},30000);
+  pending.set(id,{resolve:v=>{clearTimeout(t);res(v)},reject:e=>{clearTimeout(t);rej(e)}});
+});
+const init=async()=>{
+  const p=parseInt(env("ACP_TOOL_PROXY_PORT")||"0",10);
+  if(p){
+    if(isDeno){
+      host=await Deno.connect({hostname:"127.0.0.1",port:p});
+      (async()=>{
+        const d=new TextDecoder(),b=new Uint8Array(65536);
+        while(true){const n=await host.read(b);if(!n)break;
+        hbuf+=d.decode(b.subarray(0,n));let ls=hbuf.split("\\n");hbuf=ls.pop();
+        for(let l of ls)if(l.trim())onHostMsg(l)}})();
+    }else{
+      host=require("net").createConnection({host:"127.0.0.1",port:p});
+      await new Promise(r=>host.on("connect",r));
+      host.on("data",d=>{hbuf+=d;let ls=hbuf.split("\\n");hbuf=ls.pop();
+        for(let l of ls)if(l.trim())onHostMsg(l)});
+    }
+    try{tools=await hostReq("getTools")}catch(e){
+       const m="Failed to get tools: "+e.message+"\\n";
+       if(isDeno)Deno.stderr.write(new TextEncoder().encode(m));
+       else process.stderr.write(m);
+    }
+  }
+};
+const onHostMsg=l=>{try{let r=JSON.parse(l),h=pending.get(r.id);
+  if(h){pending.delete(r.id);r.error?h.reject(new Error(r.error.message)):h.resolve(r.result)}}catch{}};
+const handle=async l=>{let m;try{m=JSON.parse(l)}catch{return}if(m.jsonrpc!=="2.0")return;
+  if(m.method==="initialize")send(m.id,{protocolVersion:MCP_VER,capabilities:{tools:{}},serverInfo:{name:"proxy",version:"1.0"}});
+  else if(m.method==="notifications/initialized");
+  else if(m.method==="tools/list")send(m.id,{tools:tools.map(t=>({name:t.name,description:t.description,inputSchema:t.inputSchema}))});
+  else if(m.method==="tools/call"){let p=m.params,t=tools.find(x=>x.name===p.name);
+    if(!t)send(m.id,null,{code:-32601,message:"Not found"});
+    else try{let r=await hostReq("callHandler",{name:p.name,args:p.arguments||{}});send(m.id,r)}
+    catch(e){send(m.id,{content:[{type:"text",text:"Error: "+e.message}],isError:true})}}
+  else send(m.id,null,{code:-32601,message:"Unknown"});
+};
+init().then(async()=>{
+  if(isDeno){
+    const d=new TextDecoder(),b=new Uint8Array(65536);
+    while(true){const n=await Deno.stdin.read(b);if(!n)break;
+      buf+=d.decode(b.subarray(0,n));let ls=buf.split("\\n");buf=ls.pop();for(let l of ls)if(l.trim())handle(l)}
+  }else{
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data",c=>{buf+=c;let ls=buf.split("\\n");buf=ls.pop();for(let l of ls)if(l.trim())handle(l)});
+  }
+});
+`.trim().replace(/\n/g, "");
+var ToolProxyHost = class {
+	server = null;
+	connections = [];
+	tools = /* @__PURE__ */ new Map();
+	serverName;
+	port = 0;
+	constructor(name = "acp-tool-proxy") {
+		this.serverName = name;
+	}
+	/**
+	* Register an AI SDK tool to be exposed through the proxy
+	*/
+	registerTool(name, tool2) {
+		this.tools.set(name, tool2);
+	}
+	/**
+	* Register multiple tools at once
+	*/
+	registerTools(tools) {
+		for (const [name, tool2] of Object.entries(tools)) this.registerTool(name, tool2);
+	}
+	/**
+	* Get tool definitions for the runtime
+	*/
+	getToolDefinitions() {
+		const definitions = [];
+		for (const [name, tool2] of this.tools.entries()) definitions.push({
+			name,
+			description: tool2.description || `Tool: ${name}`,
+			inputSchema: tool2.inputSchema || {
+				type: "object",
+				properties: {}
+			}
+		});
+		return definitions;
+	}
+	/**
+	* 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();
+		return {
+			name: this.serverName,
+			command: "node",
+			args: ["-e", RUNTIME_CODE],
+			env: [{
+				name: "ACP_TOOL_PROXY_PORT",
+				value: String(this.port)
+			}]
+		};
+	}
+	/**
+	* Start TCP server to receive tool execution requests
+	*/
+	startServer() {
+		return new Promise((resolve$3, reject) => {
+			this.server = createServer((socket) => {
+				this.handleConnection(socket);
+			});
+			this.server.on("error", (err) => {
+				reject(err);
+			});
+			this.server.listen(0, "127.0.0.1", () => {
+				const address = this.server.address();
+				if (typeof address === "object" && address) {
+					this.port = address.port;
+					resolve$3();
+				} else reject(/* @__PURE__ */ new Error("Failed to get server address"));
+			});
+		});
+	}
+	/**
+	* Handle incoming connection from runtime
+	*/
+	handleConnection(socket) {
+		this.connections.push(socket);
+		let buffer$2 = "";
+		socket.on("data", (data$1) => {
+			buffer$2 += data$1.toString();
+			const lines = buffer$2.split("\n");
+			buffer$2 = lines.pop() || "";
+			for (const line$1 of lines) {
+				if (!line$1.trim()) continue;
+				const message = parseMessage(line$1);
+				if (!message) continue;
+				if ("method" in message) this.handleRequest(socket, message).catch((err) => console.error("[ToolProxy] Error handling request:", err));
+			}
+		});
+		socket.on("close", () => {
+			this.connections = this.connections.filter((c) => c !== socket);
+		});
+		socket.on("error", (err) => {
+			console.error("[ToolProxy] Socket error:", err);
+		});
+	}
+	/**
+	* Handle JSON-RPC request from runtime
+	*/
+	async handleRequest(socket, request$1) {
+		try {
+			if (request$1.method === ProxyMethod.CALL_HANDLER) {
+				const params = request$1.params;
+				const tool2 = this.tools.get(params.name);
+				if (!tool2) {
+					this.sendResponse(socket, createErrorResponse(request$1.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Tool not found: ${params.name}`));
+					return;
+				}
+				if (!tool2.execute) {
+					this.sendResponse(socket, createErrorResponse(request$1.id, JsonRpcErrorCode.INTERNAL_ERROR, `Tool has no execute function: ${params.name}`));
+					return;
+				}
+				const result = await tool2.execute?.(params.args, {
+					toolCallId: params.name,
+					messages: []
+				});
+				const toolResult = { content: [{
+					type: "text",
+					text: typeof result === "string" ? result : JSON.stringify(result)
+				}] };
+				this.sendResponse(socket, createResponse(request$1.id, toolResult));
+			} else if (request$1.method === "getTools") this.sendResponse(socket, createResponse(request$1.id, this.getToolDefinitions()));
+			else this.sendResponse(socket, createErrorResponse(request$1.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Unknown method: ${request$1.method}`));
+		} catch (error$1) {
+			this.sendResponse(socket, createErrorResponse(request$1.id, JsonRpcErrorCode.INTERNAL_ERROR, error$1 instanceof Error ? error$1.message : String(error$1)));
+		}
+	}
+	/**
+	* Send response to runtime
+	*/
+	sendResponse(socket, response) {
+		socket.write(serializeMessage(response) + "\n");
+	}
+	/**
+	* Stop the TCP server
+	*/
+	stop() {
+		for (const socket of this.connections) socket.destroy();
+		this.connections = [];
+		if (this.server) {
+			this.server.close();
+			this.server = null;
+		}
+		this.port = 0;
+	}
+};
 var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME = "acp.acp_provider_agent_dynamic_tool";
+var executeRegistry = /* @__PURE__ */ new Map();
+function acpTools(tools) {
+	for (const [name, toolDef] of Object.entries(tools)) if (toolDef.execute) executeRegistry.set(name, toolDef.execute);
+	return {
+		...tools,
+		...getACPDynamicTool()
+	};
+}
+function getACPDynamicTool() {
+	return { [ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME]: tool({
+		type: "provider-defined",
+		id: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+		name: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+		args: {},
+		inputSchema: jsonSchema({})
+	}) };
+}
+function getExecuteByName(name) {
+	return executeRegistry.get(name);
+}
+function hasRegisteredExecute(name) {
+	return executeRegistry.has(name);
+}
+var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2 = "acp.acp_provider_agent_dynamic_tool";
 var providerAgentDynamicToolSchema = z$1.object({
 	toolCallId: z$1.string().describe("The unique ID of the tool call."),
 	toolName: z$1.string().describe("The name of the tool being called."),
@@ -87292,11 +87577,11 @@ var ACPAISDKClient = class {
 		} };
 	}
 	writeTextFile(params) {
-		console.log("Write file request (not implemented):", params.path);
+		console.log("[acp-ai-provider] Write file request (not implemented):", params.path);
 		throw new Error("File operations not implemented in language model client");
 	}
 	readTextFile(params) {
-		console.log("Read file request (not implemented):", params.path);
+		console.log("[acp-ai-provider] Read file request (not implemented):", params.path);
 		throw new Error("File operations not implemented in language model client");
 	}
 };
@@ -87304,6 +87589,7 @@ var ACPLanguageModel = class {
 	specificationVersion = "v2";
 	provider = "acp";
 	modelId;
+	modeId;
 	supportedUrls = {};
 	config;
 	agentProcess = null;
@@ -87311,13 +87597,17 @@ var ACPLanguageModel = class {
 	sessionId = null;
 	sessionResponse = null;
 	client = null;
+	currentModelId = null;
+	currentModeId = null;
 	textBlockIndex = 0;
 	thinkBlockIndex = 0;
 	currentTextId = null;
 	currentThinkingId = null;
 	toolCallsMap = /* @__PURE__ */ new Map();
-	constructor(modelId, config) {
+	toolProxyHost = null;
+	constructor(modelId, modeId, config) {
 		this.modelId = modelId;
+		this.modeId = modeId;
 		this.config = config;
 	}
 	/**
@@ -87379,7 +87669,7 @@ var ACPLanguageModel = class {
 			if (Array.isArray(msg.content)) {
 				let isFirst = true;
 				for (const part of msg.content) if (part.type === "text") {
-					const text$2 = isFirst ? `${prefix}${part.text}` : part.text;
+					const text$2 = isFirst ? `${prefix}${part.text} ` : part.text;
 					contentBlocks.push({
 						type: "text",
 						text: text$2
@@ -87395,33 +87685,42 @@ var ACPLanguageModel = class {
 				}
 			} else if (typeof msg.content === "string") contentBlocks.push({
 				type: "text",
-				text: `${prefix}${msg.content}`
+				text: `${prefix}${msg.content} `
 			});
 		}
 		return contentBlocks;
 	}
 	/**
 	* Ensures the ACP agent process is running and a session is established.
+	* @param acpTools - Tools from streamText options to proxy
 	*/
-	async ensureConnected() {
-		if (this.connection && this.sessionId) return;
-		const sessionCwd = this.config.session?.cwd || process$1.cwd();
-		this.agentProcess = spawn(this.config.command, this.config.args ?? [], {
-			stdio: [
-				"pipe",
-				"pipe",
-				"inherit"
-			],
-			env: {
-				...process$1.env,
-				...this.config.env
-			},
-			cwd: sessionCwd
-		});
-		const input = Writable.toWeb(this.agentProcess.stdin);
-		const output = Readable.toWeb(this.agentProcess.stdout);
-		this.client = new ACPAISDKClient();
-		this.connection = new ClientSideConnection(() => this.client, ndJsonStream(input, output));
+	/**
+	* Connects to the ACP agent process and initializes the protocol connection.
+	* Does NOT start a session.
+	*/
+	async connectClient() {
+		if (this.connection) return;
+		if (!this.agentProcess) {
+			const sessionCwd = this.config.session?.cwd || (typeof process$1.cwd === "function" ? process$1.cwd() : "/");
+			this.agentProcess = spawn(this.config.command, this.config.args ?? [], {
+				stdio: [
+					"pipe",
+					"pipe",
+					"inherit"
+				],
+				env: {
+					...process$1.env,
+					...this.config.env
+				},
+				cwd: sessionCwd
+			});
+			if (!this.agentProcess.stdout || !this.agentProcess.stdin) throw new Error("Failed to spawn agent process with stdio");
+			const input = Writable.toWeb(this.agentProcess.stdin);
+			const output = Readable.toWeb(this.agentProcess.stdout);
+			this.client = new ACPAISDKClient();
+			this.connection = new ClientSideConnection(() => this.client, ndJsonStream(input, output));
+		}
+		if (!this.connection) throw new Error("Connection not initialized");
 		const initConfig = {
 			...this.config.initialize ?? {},
 			protocolVersion: this.config.initialize?.protocolVersion ?? PROTOCOL_VERSION,
@@ -87436,25 +87735,105 @@ var ACPLanguageModel = class {
 		const initResult = await this.connection.initialize(initConfig);
 		const validAuthMethods = initResult.authMethods?.find((a) => a.id === this.config.authMethodId)?.id;
 		if (initResult.authMethods?.length ?? false) {
-			if (!this.config.authMethodId || !validAuthMethods) console.log("⚠️ 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) 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(`\u26A0\uFE0F No authentication methods required by the ACP agent, skipping authentication step.`);
+		} else console.log(`[acp-ai-provider] No authentication methods required by the ACP agent, skipping authentication step.`);
+	}
+	/**
+	* Prepares the list of MCP servers, including the tool proxy if needed.
+	*/
+	async prepareMcpServers(acpTools2) {
+		const mcpServers = [...this.config.session?.mcpServers ?? []];
+		if (acpTools2 && acpTools2.length > 0) {
+			if (!this.toolProxyHost) this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
+			for (const t$5 of acpTools2) this.toolProxyHost.registerTool(t$5.name, t$5);
+			if (!this.toolProxyHost) {
+				this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
+				for (const t$5 of acpTools2) this.toolProxyHost.registerTool(t$5.name, t$5);
+				const proxyConfig = await this.toolProxyHost.start();
+				mcpServers.push(proxyConfig);
+			}
+		}
+		return mcpServers;
+	}
+	async prepareToolProxy(acpTools2, mcpServers) {
+		if (this.toolProxyHost) return;
+		this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
+		for (const t$5 of acpTools2) this.toolProxyHost.registerTool(t$5.name, t$5);
+		const proxyConfig = await this.toolProxyHost.start();
+		mcpServers.push(proxyConfig);
+	}
+	/**
+	* Starts a new session or updates the existing one.
+	* Assumes connectClient() has been called.
+	*/
+	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...");
+			this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
+			for (const t$5 of acpTools2) this.toolProxyHost.registerTool(t$5.name, t$5);
+			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 ?? process$1.cwd(),
+				mcpServers
+			});
+			this.sessionId = this.sessionResponse.sessionId;
+			await this.applySessionDelay();
+			return;
+		}
+		if (this.sessionId) return;
 		if (this.config.existingSessionId) {
 			await this.connection.loadSession({
 				sessionId: this.config.existingSessionId,
-				cwd: this.config.session?.cwd ?? sessionCwd,
-				mcpServers: this.config.session?.mcpServers ?? []
+				cwd: this.config.session?.cwd ?? process$1.cwd(),
+				mcpServers
 			});
 			this.sessionId = this.config.existingSessionId;
 			this.sessionResponse = { sessionId: this.config.existingSessionId };
 		} else {
 			this.sessionResponse = await this.connection.newSession({
 				...this.config.session,
-				cwd: this.config.session?.cwd ?? sessionCwd,
-				mcpServers: this.config.session?.mcpServers ?? []
+				cwd: this.config.session?.cwd ?? process$1.cwd(),
+				mcpServers
 			});
 			this.sessionId = this.sessionResponse.sessionId;
 		}
+		const { models, modes } = this.sessionResponse ?? {};
+		if (models?.currentModelId) this.currentModelId = models.currentModelId;
+		if (modes?.currentModeId) this.currentModeId = modes.currentModeId;
+		if (this.modelId && this.modelId !== this.currentModelId) {
+			await this.setModel(this.modelId);
+			this.currentModelId = this.modelId;
+		}
+		if (this.modeId && this.modeId !== this.currentModeId) {
+			await this.setMode(this.modeId);
+			this.currentModeId = this.modeId;
+		}
+		await this.applySessionDelay();
+	}
+	async applySessionDelay() {
+		if (this.config.sessionDelayMs) {
+			console.log(`[acp-ai-provider] Waiting for ${this.config.sessionDelayMs}ms after session setup...`);
+			await new Promise((resolve$3) => setTimeout(resolve$3, this.config.sessionDelayMs));
+		}
+	}
+	/**
+	* Ensures the ACP agent process is running and a session is established.
+	* @param acpTools - Tools from streamText options to proxy
+	*/
+	async ensureConnected(acpTools2) {
+		await this.connectClient();
+		await this.startSession(acpTools2);
 	}
 	/**
 	* Clears connection state. Skips if persistSession is enabled.
@@ -87473,8 +87852,20 @@ var ACPLanguageModel = class {
 	* Initializes the session and returns session info (models, modes, meta).
 	* Call this before prompting to discover available options.
 	*/
-	async initSession() {
-		await this.ensureConnected();
+	/**
+	* Initializes the session and returns session info (models, modes, meta).
+	* Call this before prompting to discover available options.
+	*
+	* @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);
 		return this.sessionResponse;
 	}
 	/**
@@ -87482,25 +87873,47 @@ var ACPLanguageModel = class {
 	*/
 	async setMode(modeId) {
 		if (!this.connection || !this.sessionId) throw new Error("Not connected. Call preconnect() first.");
+		const availableModes = this.sessionResponse?.modes?.availableModes;
+		if (availableModes) {
+			if (!availableModes.find((m) => m.id === modeId)) {
+				const availableList = availableModes.map((m) => m.id).join(", ");
+				const currentInfo = this.sessionResponse?.modes?.currentModeId ? ` (Current: "${this.sessionResponse.modes.currentModeId}")` : "";
+				throw new Error(`Mode "${modeId}" is not available${currentInfo}. Available modes: ${availableList}`);
+			}
+		}
 		await this.connection.setSessionMode({
 			sessionId: this.sessionId,
 			modeId
 		});
+		this.currentModeId = modeId;
 	}
 	/**
 	* Sets the session model.
 	*/
 	async setModel(modelId) {
 		if (!this.connection || !this.sessionId) throw new Error("Not connected. Call preconnect() first.");
+		const { models } = this.sessionResponse ?? {};
+		if (models?.availableModels) {
+			if (!models.availableModels.some((m) => m.modelId === modelId)) {
+				const availableList = models.availableModels.map((m) => m.modelId).join(", ");
+				const currentInfo = this.currentModelId ? ` (Current: "${this.currentModelId}")` : "";
+				throw new Error(`Model "${modelId}" is not available${currentInfo}. Available models: ${availableList}`);
+			}
+		}
 		await this.connection.setSessionModel({
 			sessionId: this.sessionId,
 			modelId
 		});
+		this.currentModelId = modelId;
 	}
 	/**
 	* Forces cleanup regardless of persistSession setting.
 	*/
 	forceCleanup() {
+		if (this.toolProxyHost) {
+			this.toolProxyHost.stop();
+			this.toolProxyHost = null;
+		}
 		if (this.agentProcess) {
 			this.agentProcess.kill();
 			this.agentProcess.stdin?.end();
@@ -87527,7 +87940,7 @@ var ACPLanguageModel = class {
 				break;
 			case "agent_thought_chunk":
 				if (!this.currentThinkingId) {
-					this.currentThinkingId = `reasoning-${this.thinkBlockIndex++}`;
+					this.currentThinkingId = `reasoning - ${this.thinkBlockIndex++} `;
 					controller.enqueue({
 						type: "reasoning-start",
 						id: this.currentThinkingId
@@ -87550,7 +87963,7 @@ var ACPLanguageModel = class {
 				if (update$1.content.type === "text") {
 					const textChunk = update$1.content.text;
 					if (!this.currentTextId) {
-						this.currentTextId = `text-${this.textBlockIndex++}`;
+						this.currentTextId = `text - ${this.textBlockIndex++} `;
 						controller.enqueue({
 							type: "text-start",
 							id: this.currentTextId
@@ -87582,7 +87995,7 @@ var ACPLanguageModel = class {
 				controller.enqueue({
 					type: "tool-call",
 					toolCallId,
-					toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+					toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
 					input: JSON.stringify({
 						toolCallId,
 						toolName,
@@ -87608,7 +88021,7 @@ var ACPLanguageModel = class {
 					controller.enqueue({
 						type: "tool-call",
 						toolCallId,
-						toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+						toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
 						input: JSON.stringify({
 							toolCallId,
 							toolName
@@ -87618,7 +88031,7 @@ var ACPLanguageModel = class {
 				controller.enqueue({
 					type: "tool-result",
 					toolCallId,
-					toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+					toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
 					result: toolResult,
 					providerExecuted: true,
 					...isError && {
@@ -87709,7 +88122,21 @@ var ACPLanguageModel = class {
 	* Implements the streaming generation method.
 	*/
 	async doStream(options) {
-		await this.ensureConnected();
+		const acpTools2 = [];
+		if (options.tools) {
+			for (const t$5 of options.tools) if (t$5.type === "function") {
+				const toolInputSchema = t$5.inputSchema;
+				if (hasRegisteredExecute(t$5.name) && toolInputSchema) {
+					const execute = getExecuteByName(t$5.name);
+					if (execute) acpTools2.push({
+						...t$5,
+						name: t$5.name,
+						execute
+					});
+				}
+			}
+		}
+		await this.ensureConnected(acpTools2.length > 0 ? acpTools2 : void 0);
 		const promptContent = this.getPromptContent(options);
 		const connection = this.connection;
 		const sessionId = this.sessionId;
@@ -87758,18 +88185,8 @@ var ACPLanguageModel = class {
 			warnings: []
 		};
 	}
-	/**
-	* Defines the provider agent dynamic tool used to bridge ACP's agent-side tool calls
-	* with the AI SDK's tool execution flow.
-	*/
 	get tools() {
-		return { [ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME]: tool({
-			name: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
-			type: "provider-defined",
-			inputSchema: jsonSchema({}),
-			id: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
-			args: jsonSchema({})
-		}) };
+		return getACPDynamicTool();
 	}
 };
 var ACPProvider = class {
@@ -87783,8 +88200,10 @@ var ACPProvider = class {
 	*
 	* @returns A LanguageModelV2 instance
 	*/
-	languageModel() {
-		if (!this.model) this.model = new ACPLanguageModel("acp-agent", this.config);
+	languageModel(modelId, modeId) {
+		if (!this.model) this.model = new ACPLanguageModel(modelId, modeId, this.config);
+		if (modelId) this.model.modelId = modelId;
+		if (modeId) this.model.modeId = modeId;
 		return this.model;
 	}
 	/**
@@ -87794,7 +88213,7 @@ var ACPProvider = class {
 		return this.languageModel();
 	}
 	/**
-	* Provider tools
+	* Provider tools - includes the agent dynamic tool
 	*/
 	get tools() {
 		return this.model?.tools;
@@ -87810,9 +88229,17 @@ var ACPProvider = class {
 	* Initializes the session and returns session info (models, modes, meta).
 	* Call this before prompting to discover available options.
 	*/
-	initSession() {
+	initSession(acpTools2) {
+		if (!this.model) this.languageModel();
+		return this.model.initSession(acpTools2);
+	}
+	/**
+	* Initializes the connection to the agent process without starting a session.
+	* Useful if you need to reduce the time to the first token.
+	*/
+	connect() {
 		if (!this.model) this.languageModel();
-		return this.model.initSession();
+		return this.model.connectClient();
 	}
 	/**
 	* Sets the session mode (e.g., "ask", "plan").
@@ -87841,55 +88268,64 @@ function createACPProvider(config) {
 }
 
 //#endregion
-//#region src/utils/resolve-bin.ts
+//#region src/middleware/acp-middleware.ts
 /**
-* Resolves a package's binary path from node_modules by reading its package.json
-* This is more stable than using npx as it uses the installed package directly
-* 
-* @param packageName - The npm package name (e.g., 'mcp-remote', 'typescript', 'eslint')
-* @param cwd - Current working directory (defaults to process.cwd())
-* @returns Object containing the command and args to execute the binary
-* 
-* @example
-* ```ts
-* const { command, args } = resolvePackageBin('mcp-remote');
-* spawn(command, [...args, 'http://localhost:5173']);
-* ```
+* Call MCP method via transport and wait for response
 */
-function resolvePackageBin(packageName, cwd$1 = process.cwd()) {
-	try {
-		const packageJsonPath = createRequire(resolve(cwd$1, "package.json")).resolve(`${packageName}/package.json`);
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-		if (packageJson.bin) {
-			const binPath = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin[packageName] || packageJson.bin[Object.keys(packageJson.bin)[0]];
-			if (binPath) {
-				const fullBinPath = resolve(dirname(packageJsonPath), binPath);
-				if (existsSync$1(fullBinPath)) return {
-					command: "node",
-					args: [fullBinPath]
-				};
-			}
-		}
-	} catch (error$1) {}
-	console.warn(`${packageName} not found in node_modules, falling back to npx. Consider installing ${packageName} as a dependency.`);
-	return {
-		command: "npx",
-		args: [packageName]
+function callMcpMethodViaTransport(transport, method, params) {
+	const messageId = Date.now();
+	const message = {
+		method,
+		params,
+		jsonrpc: "2.0",
+		id: messageId
 	};
+	return new Promise((resolve$3) => {
+		transport.onmessage?.(message);
+		const originalSend = transport.send;
+		transport.send = function(payload) {
+			const payloadObj = payload;
+			if (payloadObj.id === messageId) {
+				resolve$3(payloadObj.result);
+				transport.send = originalSend;
+			}
+			return originalSend.call(this, payload);
+		};
+	});
+}
+/**
+* Load MCP tools from transport in AI SDK v5 format
+*/
+async function loadMcpToolsV5(transport) {
+	const tools = {};
+	const { tools: toolsListFromServer } = await callMcpMethodViaTransport(transport, "tools/list");
+	for (const toolInfo of toolsListFromServer) {
+		const toolName = toolInfo.name;
+		tools[toolName] = tool({
+			description: toolInfo.description,
+			inputSchema: jsonSchema(toolInfo.inputSchema),
+			execute: async (args) => {
+				console.log(`[dev-inspector] [acp] Executing MCP tool: ${toolName}`);
+				return await callMcpMethodViaTransport(transport, "tools/call", {
+					name: toolName,
+					arguments: args
+				});
+			}
+		});
+	}
+	console.log(`[dev-inspector] [acp] Loaded ${Object.keys(tools).length} MCP tools`);
+	return tools;
 }
 /**
-* Resolves the mcp-remote CLI path from node_modules
-* Convenience wrapper around resolvePackageBin for mcp-remote
-* 
-* @param cwd - Current working directory (defaults to process.cwd())
-* @returns Object containing the command and args to execute mcp-remote
+* Get an active transport from the connection manager
 */
-function resolveMcpRemote(cwd$1 = process.cwd()) {
-	return resolvePackageBin("mcp-remote", cwd$1);
+function getActiveTransport() {
+	const connectionManager = getConnectionManager();
+	if (!connectionManager) return null;
+	const sessionIds = Object.keys(connectionManager.transports);
+	if (sessionIds.length === 0) return null;
+	return connectionManager.transports[sessionIds[0]];
 }
-
-//#endregion
-//#region src/middleware/acp-middleware.ts
 function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 	middlewares.use("/api/acp/chat", async (req, res) => {
 		if (handleCors(res, req.method)) return;
@@ -87902,42 +88338,26 @@ function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 			const body = await readBody(req);
 			const { messages, agent, envVars } = JSON.parse(body);
 			const cwd$1 = process.cwd();
-			const mcpRemote = resolveMcpRemote(cwd$1);
 			const provider = createACPProvider({
 				command: agent.command,
 				args: agent.args,
 				env: envVars,
 				session: {
 					cwd: cwd$1,
-					mcpServers: [{
-						command: mcpRemote.command,
-						args: [...mcpRemote.args, `http://${serverContext?.host || "localhost"}:${serverContext?.port || 5173}/__mcp__/sse?clientId=acp&puppetId=inspector`],
-						env: [],
-						name: "inspect"
-					}]
+					mcpServers: []
 				},
 				authMethodId: agent.authMethodId
 			});
-			const sessionInfo = await provider.initSession();
-			console.log("[dev-inspector] [acp] Session initialized");
-			if (sessionInfo.modes) {
-				const { availableModes, currentModeId } = sessionInfo.modes;
-				console.log("[dev-inspector] [acp] Available modes:", availableModes.map((m) => m.id).join(", "));
-				console.log("[dev-inspector] [acp] Current mode:", currentModeId);
-			}
-			if (sessionInfo.models) {
-				const { availableModels, currentModelId } = sessionInfo.models;
-				console.log("[dev-inspector] [acp] Available models:", availableModels.map((m) => m.modelId).join(", "));
-				console.log("[dev-inspector] [acp] Current model:", currentModelId);
-			}
+			const transport = getActiveTransport();
+			let mcpTools = {};
+			if (transport) mcpTools = await loadMcpToolsV5(transport);
+			else console.warn("[dev-inspector] [acp] No active MCP transport available, tools will not be loaded");
 			const mode = agent.acpMode ?? acpOptions?.acpMode;
 			const model = agent.acpModel ?? acpOptions?.acpModel;
 			const delay = agent.acpDelay ?? acpOptions?.acpDelay;
-			if (mode !== void 0) await provider.setMode(mode);
-			if (model !== void 0) await provider.setModel(model);
 			if (delay !== void 0 && delay > 0) {
 				console.log(`[dev-inspector] [acp] Delaying response by ${delay}ms, agent: ${agent.name}`);
-				await new Promise((resolve$4) => setTimeout(resolve$4, delay));
+				await new Promise((resolve$3) => setTimeout(resolve$3, delay));
 			}
 			const abortController = new AbortController();
 			req.on("close", () => {
@@ -87946,15 +88366,15 @@ function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 				provider.cleanup();
 			});
 			const response = streamText({
-				model: provider.languageModel(),
+				model: provider.languageModel(model, mode),
 				includeRawChunks: true,
 				messages: convertToModelMessages(messages),
 				abortSignal: abortController.signal,
+				tools: acpTools(mcpTools),
 				onError: (error$1) => {
 					console.error("Error occurred while streaming text:", JSON.stringify(error$1, null, 2));
 					provider.cleanup();
-				},
-				tools: provider.tools
+				}
 			}).toUIMessageStreamResponse({
 				messageMetadata: ({ part }) => {
 					if (part.type === "raw" && part.rawValue) {
@@ -87998,13 +88418,13 @@ function setupAcpMiddleware(middlewares, serverContext, acpOptions) {
 	});
 }
 function readBody(req) {
-	return new Promise((resolve$4, reject) => {
+	return new Promise((resolve$3, reject) => {
 		let body = "";
 		req.on("data", (chunk) => {
 			body += chunk.toString();
 		});
 		req.on("end", () => {
-			resolve$4(body);
+			resolve$3(body);
 		});
 		req.on("error", (err) => {
 			reject(err);