droid-acp 0.1.0 → 0.2.0

package/README.md

@@ -12,6 +12,7 @@ Use Droid from any [ACP-compatible](https://agentclientprotocol.com) clients suc
 - Image prompts (e.g. paste screenshots in Zed)
 - Multiple model support
 - Session modes (Spec, Manual, Auto Low/Medium/High)
+- Optional WebSearch proxy (Smithery Exa MCP / custom forward)
 
 ## Installation
 
@@ -24,11 +25,13 @@ npm install droid-acp
 ### Prerequisites
 
 1. Install Droid CLI from [Factory](https://factory.ai)
-2. Set your Factory API key:
+2. (Recommended) Set your Factory API key for Factory-hosted features:
    ```bash
    export FACTORY_API_KEY=fk-...
    ```
 
+> If you only need WebSearch via the built-in proxy + Smithery Exa MCP, a valid Factory key is not required (droid-acp injects a dummy key into the spawned droid process to satisfy droid's local auth gate).
+
 ### Running
 
 ```bash
@@ -93,6 +96,25 @@ Add to your Zed `settings.json`:
 }
 ```
 
+**Enable WebSearch proxy (Smithery Exa MCP):**
+
+```json
+{
+  "agent_servers": {
+    "Droid WebSearch": {
+      "type": "custom",
+      "command": "npx",
+      "args": ["droid-acp"],
+      "env": {
+        "DROID_ACP_WEBSEARCH": "1",
+        "SMITHERY_API_KEY": "your_smithery_key",
+        "SMITHERY_PROFILE": "your_profile_id"
+      }
+    }
+  }
+}
+```
+
 ### Modes
 
 | Command               | Mode           | Custom Models    | Description                   |
@@ -104,9 +126,58 @@ Add to your Zed `settings.json`:
 
 ### Environment Variables
 
-- `FACTORY_API_KEY` - Your Factory API key (required)
+- `FACTORY_API_KEY` - Your Factory API key (recommended for Factory-hosted features)
 - `DROID_EXECUTABLE` - Path to the droid binary (optional, defaults to `droid` in PATH)
 
+- `DROID_ACP_WEBSEARCH` - Enable local proxy to optionally intercept Droid websearch (`/api/tools/exa/search`)
+- `DROID_ACP_WEBSEARCH_FORWARD_URL` - Optional forward target for websearch (base URL or full URL)
+- `DROID_ACP_WEBSEARCH_FORWARD_MODE` - Forward mode for `DROID_ACP_WEBSEARCH_FORWARD_URL` (`http` or `mcp`, default: `http`)
+- `DROID_ACP_WEBSEARCH_UPSTREAM_URL` - Optional upstream Factory API base URL (default: `FACTORY_API_BASE_URL_OVERRIDE` or `https://api.factory.ai`)
+- `DROID_ACP_WEBSEARCH_HOST` - Optional proxy bind host (default: `127.0.0.1`)
+- `DROID_ACP_WEBSEARCH_PORT` - Optional proxy bind port (default: auto-assign an available port)
+- `DROID_ACP_WEBSEARCH_DEBUG` - Emit a WebSearch status message in the ACP UI (e.g. Zed) for debugging
+
+- `SMITHERY_API_KEY` - Optional (recommended) Smithery Exa MCP API key (enables high-quality websearch)
+- `SMITHERY_PROFILE` - Optional Smithery Exa MCP profile id
+
+### WebSearch Proxy (optional)
+
+Enable the built-in proxy to intercept `POST /api/tools/exa/search` and serve results from Smithery Exa MCP (recommended):
+
+```bash
+export SMITHERY_API_KEY="your_smithery_key"
+export SMITHERY_PROFILE="your_profile_id"
+DROID_ACP_WEBSEARCH=1 npx droid-acp
+```
+
+To debug proxy wiring (shows `proxyBaseUrl` and a `/health` link in the ACP UI):
+
+```bash
+DROID_ACP_WEBSEARCH=1 DROID_ACP_WEBSEARCH_DEBUG=1 npx droid-acp
+```
+
+To forward WebSearch to your own HTTP handler instead:
+
+```bash
+DROID_ACP_WEBSEARCH=1 \
+DROID_ACP_WEBSEARCH_FORWARD_URL="http://127.0.0.1:20002" \
+npx droid-acp
+```
+
+To forward WebSearch to an MCP endpoint (JSON-RPC `tools/call`), set:
+
+```bash
+DROID_ACP_WEBSEARCH=1 \
+DROID_ACP_WEBSEARCH_FORWARD_MODE=mcp \
+DROID_ACP_WEBSEARCH_FORWARD_URL="http://127.0.0.1:20002" \
+npx droid-acp
+```
+
+Notes:
+
+- The proxy exposes `GET /health` on `proxyBaseUrl` (handy for troubleshooting).
+- When `DROID_ACP_WEBSEARCH=1`, droid-acp injects a dummy `FACTORY_API_KEY` into the spawned droid process if none is set, so WebSearch requests can reach the proxy even without Factory login.
+
 ## Session Modes
 
 | Mode        | Description                                 | Droid autonomy level |

package/dist/{acp-agent-Ddz1S3Jm.mjs → acp-agent-DUNNYT3R.mjs}

@@ -1,8 +1,12 @@
+import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 import { createInterface } from "node:readline";
 import { randomUUID } from "node:crypto";
 import { ReadableStream, WritableStream } from "node:stream/web";
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 
 //#region src/utils.ts
 var Pushable = class {
@@ -61,6 +65,16 @@ function nodeToWebReadable(nodeStream) {
 		nodeStream.on("error", (err) => controller.error(err));
 	} });
 }
+function isEnvEnabled(value) {
+	if (!value) return false;
+	switch (value.trim().toLowerCase()) {
+		case "1":
+		case "true":
+		case "yes":
+		case "on": return true;
+		default: return false;
+	}
+}
 /** Check if running on Windows */
 const isWindows = process.platform === "win32";
 /**
@@ -73,11 +87,343 @@ function findDroidExecutable() {
 	return "droid";
 }
 
+//#endregion
+//#region src/websearch-proxy.ts
+function parseSseJsonPayload(raw) {
+	const lines = raw.split(/\r?\n/);
+	let currentData = [];
+	const flush = (acc) => {
+		if (currentData.length === 0) return;
+		const joined = currentData.join("\n");
+		try {
+			acc.push(JSON.parse(joined));
+		} catch {}
+		currentData = [];
+	};
+	const parsed = [];
+	for (const line of lines) {
+		if (line.length === 0) {
+			flush(parsed);
+			continue;
+		}
+		if (line.startsWith("event:")) continue;
+		if (line.startsWith("data:")) {
+			const data = line.slice(5).replace(/^ /, "");
+			currentData.push(data);
+			continue;
+		}
+	}
+	flush(parsed);
+	return parsed.length > 0 ? parsed[parsed.length - 1] : null;
+}
+function parseHttpUrl(value, name) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error(`${name} must be a valid URL: ${value}`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`${name} must be http(s): ${value}`);
+	return url;
+}
+function resolveForwardTarget(forward, requestPathAndQuery) {
+	if (forward.pathname === "/" && forward.search === "" && forward.hash === "") return new URL(requestPathAndQuery, forward);
+	const target = new URL(forward.toString());
+	if (!target.search && requestPathAndQuery.includes("?")) target.search = requestPathAndQuery.slice(requestPathAndQuery.indexOf("?"));
+	return target;
+}
+function isBodylessMethod(method) {
+	return method === "GET" || method === "HEAD";
+}
+function toNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parseWebsearchRequestBody(bodyBuffer) {
+	let input;
+	try {
+		input = JSON.parse(bodyBuffer.toString("utf8"));
+	} catch {
+		return null;
+	}
+	const query = toNonEmptyString(input?.query);
+	if (!query) return null;
+	const numResultsRaw = input?.numResults;
+	return {
+		query,
+		numResults: typeof numResultsRaw === "number" && Number.isFinite(numResultsRaw) ? Math.max(1, numResultsRaw) : 10
+	};
+}
+async function readBody(req, maxBytes) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of req) {
+		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buf.length;
+		if (total > maxBytes) throw new Error(`Request body too large (${total} bytes)`);
+		chunks.push(buf);
+	}
+	return Buffer.concat(chunks);
+}
+function parseSearchResultsText(text, numResults) {
+	try {
+		const json = JSON.parse(text);
+		if (Array.isArray(json)) return json.slice(0, numResults);
+	} catch {}
+	const matches = [...text.matchAll(/^Title:\s*(.*)$/gm)];
+	if (matches.length === 0) return null;
+	const results = [];
+	for (let i = 0; i < matches.length && results.length < numResults; i += 1) {
+		const start = matches[i]?.index ?? 0;
+		const end = matches[i + 1]?.index ?? text.length;
+		const chunk = text.slice(start, end).trim();
+		const title = matches[i]?.[1]?.trim() ?? "";
+		const url = (chunk.match(/^URL:\s*(.*)$/m)?.[1] ?? "").trim();
+		const snippet = (chunk.match(/^Text:\s*(.*)$/m)?.[1] ?? "").trim();
+		results.push({
+			title,
+			url,
+			snippet,
+			text: snippet
+		});
+	}
+	return results;
+}
+async function tryHandleWebsearchWithMcp(res, logger, mcpEndpoint, bodyBuffer) {
+	const parsed = parseWebsearchRequestBody(bodyBuffer);
+	if (!parsed) return { handled: false };
+	const { query, numResults } = parsed;
+	const requestBody = {
+		jsonrpc: "2.0",
+		id: 1,
+		method: "tools/call",
+		params: {
+			name: "web_search_exa",
+			arguments: {
+				query,
+				numResults
+			}
+		}
+	};
+	let mcpResponse;
+	try {
+		const response = await fetch(mcpEndpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json, text/event-stream"
+			},
+			body: JSON.stringify(requestBody)
+		});
+		if ((response.headers.get("content-type")?.toLowerCase() ?? "").includes("text/event-stream")) {
+			const parsedSse = parseSseJsonPayload(await response.text());
+			if (!parsedSse) throw new Error("Invalid MCP SSE response: missing JSON payload");
+			mcpResponse = parsedSse;
+		} else mcpResponse = await response.json();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.error("[websearch] MCP request failed:", message);
+		return {
+			handled: false,
+			error: message
+		};
+	}
+	const resultContent = mcpResponse?.result?.content;
+	const textBlock = (Array.isArray(resultContent) ? resultContent : []).find((c) => !!c && typeof c === "object" && c.type === "text" && typeof c.text === "string");
+	if (!textBlock) {
+		const errorMessage = mcpResponse?.error?.message ?? mcpResponse?.error ?? null;
+		const message = typeof errorMessage === "string" ? errorMessage : `Invalid MCP response: ${JSON.stringify(mcpResponse)}`;
+		logger.error("[websearch] MCP response missing text content:", message);
+		return {
+			handled: false,
+			error: message
+		};
+	}
+	const parsedItems = parseSearchResultsText(textBlock.text, numResults);
+	if (!parsedItems) {
+		logger.error("[websearch] Failed to parse MCP text payload");
+		return {
+			handled: false,
+			error: "Invalid MCP payload: unsupported format"
+		};
+	}
+	const results = parsedItems.slice(0, numResults).map((item) => {
+		const title = toNonEmptyString(item.title) ?? "";
+		const url = toNonEmptyString(item.url) ?? "";
+		const highlights = Array.isArray(item.highlights) ? item.highlights.filter((v) => typeof v === "string") : [];
+		const content = toNonEmptyString(item.text) ?? toNonEmptyString(item.snippet) ?? (highlights.length > 0 ? highlights.join(" ") : "");
+		return {
+			title,
+			url,
+			content,
+			snippet: content,
+			publishedDate: item.publishedDate ?? null,
+			author: item.author ?? null,
+			score: item.score ?? null
+		};
+	});
+	res.writeHead(200, { "Content-Type": "application/json" });
+	res.end(JSON.stringify({ results }));
+	return { handled: true };
+}
+async function startWebsearchProxy(options) {
+	const logger = options.logger ?? console;
+	const host = options.host ?? "127.0.0.1";
+	const port = options.port ?? 0;
+	const upstreamBase = parseHttpUrl(options.upstreamBaseUrl, "DROID_ACP_WEBSEARCH_UPSTREAM_URL");
+	const forward = options.websearchForwardUrl ? parseHttpUrl(options.websearchForwardUrl, "DROID_ACP_WEBSEARCH_FORWARD_URL") : null;
+	const forwardMode = options.websearchForwardMode ?? "http";
+	const smitheryApiKey = toNonEmptyString(options.smitheryApiKey);
+	const smitheryProfile = toNonEmptyString(options.smitheryProfile);
+	const smitheryEndpoint = smitheryApiKey && smitheryProfile ? new URL(`https://server.smithery.ai/exa/mcp?api_key=${encodeURIComponent(smitheryApiKey)}&profile=${encodeURIComponent(smitheryProfile)}`) : null;
+	let totalRequests = 0;
+	let websearchRequests = 0;
+	let lastWebsearchAt = null;
+	let lastWebsearchOutcome = null;
+	const server = createServer((req, res) => {
+		(async () => {
+			totalRequests += 1;
+			const rawUrl = req.url;
+			if (!rawUrl) {
+				res.writeHead(400, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Missing URL" }));
+				return;
+			}
+			const requestUrl = new URL(rawUrl, `http://${req.headers.host ?? "127.0.0.1"}`);
+			const pathAndQuery = `${requestUrl.pathname}${requestUrl.search || ""}`;
+			if (requestUrl.pathname === "/health") {
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					status: "ok",
+					upstreamBaseUrl: upstreamBase.toString(),
+					websearchForwardUrl: forward?.toString() ?? null,
+					websearchForwardMode: forwardMode,
+					smitheryEnabled: Boolean(smitheryEndpoint),
+					requests: {
+						total: totalRequests,
+						websearch: websearchRequests,
+						lastWebsearchAt,
+						lastWebsearchOutcome
+					}
+				}));
+				return;
+			}
+			const isWebsearch = requestUrl.pathname.startsWith("/api/tools/exa/search") && req.method === "POST";
+			const targetUrl = isWebsearch && forward && forwardMode === "http" ? resolveForwardTarget(forward, pathAndQuery) : new URL(pathAndQuery, upstreamBase);
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(req.headers)) {
+				if (value === void 0) continue;
+				if (key.toLowerCase() === "host") continue;
+				if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+				else headers.set(key, value);
+			}
+			const controller = new AbortController();
+			req.on("aborted", () => controller.abort());
+			let bodyBuffer = null;
+			if (isWebsearch) {
+				websearchRequests += 1;
+				lastWebsearchAt = (/* @__PURE__ */ new Date()).toISOString();
+				try {
+					bodyBuffer = await readBody(req, 1e6);
+				} catch {
+					res.writeHead(413, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({ error: "Request body too large" }));
+					lastWebsearchOutcome = "rejected: body too large";
+					return;
+				}
+				if (forward && forwardMode === "mcp") {
+					const r = await tryHandleWebsearchWithMcp(res, logger, forward, bodyBuffer);
+					if (r.handled) {
+						lastWebsearchOutcome = "handled: mcp forward";
+						return;
+					}
+					res.writeHead(502, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						error: "WebSearch MCP forward failed",
+						message: r.error ?? "Unknown error"
+					}));
+					lastWebsearchOutcome = `error: mcp forward (${r.error ?? "unknown"})`;
+					return;
+				}
+				if (smitheryEndpoint) {
+					const r = await tryHandleWebsearchWithMcp(res, logger, smitheryEndpoint, bodyBuffer);
+					if (r.handled) {
+						lastWebsearchOutcome = "handled: smithery exa mcp";
+						return;
+					}
+					res.writeHead(502, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						error: "Smithery Exa MCP websearch failed",
+						message: r.error ?? "Unknown error"
+					}));
+					lastWebsearchOutcome = `error: smithery exa mcp (${r.error ?? "unknown"})`;
+					return;
+				}
+				logger.log("[websearch] proxying", pathAndQuery, "->", targetUrl.toString());
+				lastWebsearchOutcome = "proxied: upstream";
+			} else logger.log("[factory-proxy]", req.method ?? "GET", pathAndQuery);
+			let upstreamResponse;
+			try {
+				upstreamResponse = await fetch(targetUrl, {
+					method: req.method,
+					headers,
+					body: isBodylessMethod(req.method) ? void 0 : bodyBuffer ? bodyBuffer : req,
+					redirect: "manual",
+					signal: controller.signal,
+					duplex: "half"
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				res.writeHead(502, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					error: "Upstream request failed",
+					message
+				}));
+				return;
+			}
+			const setCookie = upstreamResponse.headers.getSetCookie?.();
+			if (setCookie && setCookie.length > 0) res.setHeader("set-cookie", setCookie);
+			for (const [key, value] of upstreamResponse.headers) {
+				if (key.toLowerCase() === "set-cookie") continue;
+				res.setHeader(key, value);
+			}
+			res.statusCode = upstreamResponse.status;
+			if (!upstreamResponse.body) {
+				res.end();
+				return;
+			}
+			try {
+				await pipeline(Readable.fromWeb(upstreamResponse.body), res);
+			} catch {}
+		})();
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const address = server.address();
+	if (!address || typeof address === "string") {
+		server.close();
+		throw new Error("Failed to bind websearch proxy server");
+	}
+	const baseUrl = `http://${host}:${address.port}`;
+	logger.log("[websearch] proxy listening on", baseUrl);
+	return {
+		baseUrl,
+		close: () => new Promise((resolve) => {
+			server.close(() => resolve());
+		})
+	};
+}
+
 //#endregion
 //#region src/droid-adapter.ts
 function createDroidAdapter(options) {
 	let process$1 = null;
 	let sessionId = null;
+	let websearchProxy = null;
 	const machineId = randomUUID();
 	const logger = options.logger ?? console;
 	const notificationHandlers = [];
@@ -287,6 +633,12 @@ function createDroidAdapter(options) {
 			logger.error("Parse error:", err.message);
 		}
 	};
+	const stopWebsearchProxy = () => {
+		if (!websearchProxy) return;
+		const proxy = websearchProxy;
+		websearchProxy = null;
+		proxy.close().catch((err) => logger.error("[websearch] proxy close failed:", err));
+	};
 	return {
 		async start() {
 			const executable = findDroidExecutable();
@@ -300,16 +652,45 @@ function createDroidAdapter(options) {
 				options.cwd
 			];
 			logger.log("Starting droid:", executable, args.join(" "));
+			const env = {
+				...globalThis.process.env,
+				FORCE_COLOR: "0"
+			};
+			if (isEnvEnabled(env.DROID_ACP_WEBSEARCH)) {
+				stopWebsearchProxy();
+				const upstreamBaseUrl = env.DROID_ACP_WEBSEARCH_UPSTREAM_URL ?? env.FACTORY_API_BASE_URL_OVERRIDE ?? "https://api.factory.ai";
+				const websearchForwardUrl = env.DROID_ACP_WEBSEARCH_FORWARD_URL;
+				const forwardModeRaw = env.DROID_ACP_WEBSEARCH_FORWARD_MODE;
+				const websearchForwardMode = typeof forwardModeRaw === "string" && forwardModeRaw.trim().toLowerCase() === "mcp" ? "mcp" : "http";
+				const host = env.DROID_ACP_WEBSEARCH_HOST ?? "127.0.0.1";
+				const portRaw = env.DROID_ACP_WEBSEARCH_PORT;
+				let port;
+				if (typeof portRaw === "string" && portRaw.length > 0) {
+					const parsed = Number.parseInt(portRaw, 10);
+					if (Number.isNaN(parsed) || parsed < 0 || parsed > 65535) throw new Error(`Invalid DROID_ACP_WEBSEARCH_PORT: ${portRaw}`);
+					port = parsed;
+				}
+				websearchProxy = await startWebsearchProxy({
+					upstreamBaseUrl,
+					websearchForwardUrl,
+					websearchForwardMode,
+					smitheryApiKey: env.SMITHERY_API_KEY,
+					smitheryProfile: env.SMITHERY_PROFILE,
+					host,
+					port,
+					logger
+				});
+				if (!env.FACTORY_API_KEY) env.FACTORY_API_KEY = "droid-acp-websearch";
+				env.FACTORY_API_BASE_URL_OVERRIDE = websearchProxy.baseUrl;
+				env.FACTORY_API_BASE_URL = websearchProxy.baseUrl;
+			}
 			process$1 = spawn(executable, args, {
 				stdio: [
 					"pipe",
 					"pipe",
 					"pipe"
 				],
-				env: {
-					...globalThis.process.env,
-					FORCE_COLOR: "0"
-				},
+				env,
 				shell: isWindows,
 				windowsHide: true
 			});
@@ -321,6 +702,7 @@ function createDroidAdapter(options) {
 			process$1.on("exit", (code) => {
 				logger.log("Droid exit:", code);
 				process$1 = null;
+				stopWebsearchProxy();
 				exitHandlers.forEach((h) => h(code));
 			});
 			return new Promise((resolve, reject) => {
@@ -352,6 +734,9 @@ function createDroidAdapter(options) {
 			if (Array.isArray(message.images) && message.images.length > 0) params.images = message.images;
 			send("droid.add_user_message", params);
 		},
+		getWebsearchProxyBaseUrl() {
+			return websearchProxy?.baseUrl ?? null;
+		},
 		setMode(level) {
 			if (!sessionId) return;
 			send("droid.update_session_settings", {
@@ -384,6 +769,7 @@ function createDroidAdapter(options) {
 				process$1.kill("SIGTERM");
 				process$1 = null;
 			}
+			stopWebsearchProxy();
 		},
 		isRunning() {
 			return process$1 !== null && !process$1.killed;
@@ -406,10 +792,7 @@ const ACP_MODES = [
 
 //#endregion
 //#region src/acp-agent.ts
-const packageJson = {
-	name: "droid-acp",
-	version: "0.1.0"
-};
+const packageJson = createRequire(import.meta.url)("../package.json");
 function normalizeBase64DataUrl(data, fallbackMimeType) {
 	const trimmed = data.trim();
 	const match = trimmed.match(/^data:([^;,]+);base64,(.*)$/s);
@@ -562,6 +945,34 @@ var DroidAcpAgent = class {
 		});
 		this.sessions.set(sessionId, session);
 		this.logger.log("Session created:", sessionId);
+		if (isEnvEnabled(process.env.DROID_ACP_WEBSEARCH_DEBUG) || isEnvEnabled(process.env.DROID_DEBUG)) {
+			const websearchProxyBaseUrl = droid.getWebsearchProxyBaseUrl();
+			const parentFactoryApiKey = process.env.FACTORY_API_KEY;
+			const willInjectDummyFactoryApiKey = isEnvEnabled(process.env.DROID_ACP_WEBSEARCH) && !parentFactoryApiKey;
+			setTimeout(() => {
+				this.client.sessionUpdate({
+					sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: [
+								"[droid-acp] WebSearch 状态",
+								`- DROID_ACP_WEBSEARCH: ${process.env.DROID_ACP_WEBSEARCH ?? "<unset>"}`,
+								`- DROID_ACP_WEBSEARCH_PORT: ${process.env.DROID_ACP_WEBSEARCH_PORT ?? "<unset>"}`,
+								`- DROID_ACP_WEBSEARCH_FORWARD_MODE: ${process.env.DROID_ACP_WEBSEARCH_FORWARD_MODE ?? "<unset>"}`,
+								`- DROID_ACP_WEBSEARCH_FORWARD_URL: ${process.env.DROID_ACP_WEBSEARCH_FORWARD_URL ?? "<unset>"}`,
+								`- FACTORY_API_KEY: ${parentFactoryApiKey ? "set" : "<unset>"}${willInjectDummyFactoryApiKey ? " (droid child auto-inject dummy)" : ""}`,
+								`- SMITHERY_API_KEY: ${process.env.SMITHERY_API_KEY ? "set" : "<unset>"}`,
+								`- SMITHERY_PROFILE: ${process.env.SMITHERY_PROFILE ? "set" : "<unset>"}`,
+								`- proxyBaseUrl: ${websearchProxyBaseUrl ?? "<not running>"}`,
+								websearchProxyBaseUrl ? `- health: ${websearchProxyBaseUrl}/health` : null
+							].filter((l) => typeof l === "string").join("\n") + "\n"
+						}
+					}
+				});
+			}, 0);
+		}
 		setTimeout(() => {
 			this.client.sessionUpdate({
 				sessionId,
@@ -1625,5 +2036,5 @@ function runAcp() {
 }
 
 //#endregion
-export { Pushable as a, createDroidAdapter as i, runAcp as n, findDroidExecutable as o, ACP_MODES as r, isWindows as s, DroidAcpAgent as t };
-//# sourceMappingURL=acp-agent-Ddz1S3Jm.mjs.map
+export { startWebsearchProxy as a, isEnvEnabled as c, createDroidAdapter as i, isWindows as l, runAcp as n, Pushable as o, ACP_MODES as r, findDroidExecutable as s, DroidAcpAgent as t };
+//# sourceMappingURL=acp-agent-DUNNYT3R.mjs.map