droid-acp 0.5.0 → 0.6.0

package/dist/{acp-agent-k2cYadeP.mjs → acp-agent-DYlR7vNB.mjs}

@@ -2,14 +2,14 @@ import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { ReadableStream, WritableStream } from "node:stream/web";
 import { open, readFile, stat } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import os, { homedir } from "node:os";
+import path, { join } from "node:path";
 import { createInterface } from "node:readline";
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createReadStream, promises } from "node:fs";
+import { createReadStream, promises, readFileSync, statSync } from "node:fs";
 import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 
 //#region src/utils.ts
@@ -1534,7 +1534,7 @@ function parseWebsearchRequestBody(bodyBuffer) {
 		numResults: typeof numResultsRaw === "number" && Number.isFinite(numResultsRaw) ? Math.max(1, numResultsRaw) : 10
 	};
 }
-async function readBody(req, maxBytes) {
+async function readBody$1(req, maxBytes) {
 	const chunks = [];
 	let total = 0;
 	for await (const chunk of req) {
@@ -1706,7 +1706,7 @@ async function startWebsearchProxy(options) {
 				websearchRequests += 1;
 				lastWebsearchAt = (/* @__PURE__ */ new Date()).toISOString();
 				try {
-					bodyBuffer = await readBody(req, 1e6);
+					bodyBuffer = await readBody$1(req, 1e6);
 				} catch {
 					res.writeHead(413, { "Content-Type": "application/json" });
 					res.end(JSON.stringify({ error: "Request body too large" }));
@@ -1803,6 +1803,310 @@ async function startWebsearchProxy(options) {
 	};
 }
 
+//#endregion
+//#region src/websearch-native.ts
+/**
+* WebSearch Native Provider Mode (experimental)
+*
+* Uses model's native websearch capability based on ~/.factory/settings.json configuration.
+* Supported providers:
+* - Anthropic: web_search_20250305 server tool
+* - OpenAI: web_search tool via /responses endpoint
+*/
+let cachedSettings = null;
+let settingsLastModified = 0;
+function getFactorySettings(logger) {
+	const settingsPath = join(homedir(), ".factory", "settings.json");
+	try {
+		const stats = statSync(settingsPath);
+		if (cachedSettings && stats.mtimeMs === settingsLastModified) return cachedSettings;
+		cachedSettings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		settingsLastModified = stats.mtimeMs;
+		return cachedSettings;
+	} catch (e) {
+		logger.error("[websearch-native] Failed to load settings.json:", e.message);
+		return null;
+	}
+}
+function getCurrentModelConfig(logger) {
+	const settings = getFactorySettings(logger);
+	if (!settings) return null;
+	const currentModelId = settings.sessionDefaultSettings?.model;
+	if (!currentModelId) return null;
+	const modelConfig = (settings.customModels || []).find((m) => m.id === currentModelId);
+	if (modelConfig) {
+		logger.log("[websearch-native] Model:", modelConfig.displayName || modelConfig.id, "| Provider:", modelConfig.provider);
+		return modelConfig;
+	}
+	if (!currentModelId.startsWith("custom:")) return null;
+	logger.log("[websearch-native] Model not found:", currentModelId);
+	return null;
+}
+async function searchAnthropicNative(query, numResults, modelConfig, logger) {
+	const { baseUrl, apiKey, model } = modelConfig;
+	try {
+		const requestBody = {
+			model,
+			max_tokens: 4096,
+			stream: false,
+			system: "You are a web search assistant. Use the web_search tool to find relevant information and return the results.",
+			tools: [{
+				type: "web_search_20250305",
+				name: "web_search",
+				max_uses: 1
+			}],
+			tool_choice: {
+				type: "tool",
+				name: "web_search"
+			},
+			messages: [{
+				role: "user",
+				content: `Search the web for: ${query}\n\nReturn up to ${numResults} relevant results.`
+			}]
+		};
+		let endpoint = baseUrl;
+		if (!endpoint.endsWith("/v1/messages")) endpoint = endpoint.replace(/\/$/, "") + "/v1/messages";
+		logger.log("[websearch-native] Anthropic search:", query, "→", endpoint);
+		const data = await (await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"anthropic-version": "2023-06-01",
+				"x-api-key": apiKey
+			},
+			body: JSON.stringify(requestBody)
+		})).json();
+		if (data.error) {
+			logger.error("[websearch-native] Anthropic API error:", data.error.message);
+			return null;
+		}
+		const results = [];
+		for (const block of data.content || []) if (block.type === "web_search_tool_result") {
+			for (const result of block.content || []) if (result.type === "web_search_result") results.push({
+				title: result.title || "",
+				url: result.url || "",
+				content: result.snippet || result.page_content || ""
+			});
+		}
+		logger.log("[websearch-native] Anthropic results:", results.length);
+		return results.length > 0 ? results.slice(0, numResults) : null;
+	} catch (e) {
+		logger.error("[websearch-native] Anthropic error:", e.message);
+		return null;
+	}
+}
+async function searchOpenAINative(query, numResults, modelConfig, logger) {
+	const { baseUrl, apiKey, model } = modelConfig;
+	try {
+		const requestBody = {
+			model,
+			stream: false,
+			tools: [{ type: "web_search" }],
+			tool_choice: "required",
+			input: `Search the web for: ${query}\n\nReturn up to ${numResults} relevant results.`
+		};
+		let endpoint = baseUrl;
+		if (!endpoint.endsWith("/responses")) endpoint = endpoint.replace(/\/$/, "") + "/responses";
+		logger.log("[websearch-native] OpenAI search:", query, "→", endpoint);
+		const data = await (await fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify(requestBody)
+		})).json();
+		if (data.error) {
+			logger.error("[websearch-native] OpenAI API error:", data.error.message);
+			return null;
+		}
+		const results = [];
+		for (const item of data.output || []) if (item.type === "message" && Array.isArray(item.content)) {
+			for (const content of item.content) if (content.type === "output_text" && Array.isArray(content.annotations)) {
+				for (const annotation of content.annotations) if (annotation.type === "url_citation" && annotation.url) results.push({
+					title: annotation.title || "",
+					url: annotation.url || "",
+					content: annotation.title || ""
+				});
+			}
+		}
+		logger.log("[websearch-native] OpenAI results:", results.length);
+		return results.length > 0 ? results.slice(0, numResults) : null;
+	} catch (e) {
+		logger.error("[websearch-native] OpenAI error:", e.message);
+		return null;
+	}
+}
+async function search(query, numResults, logger) {
+	logger.log("[websearch-native] Search:", query);
+	const modelConfig = getCurrentModelConfig(logger);
+	if (!modelConfig) {
+		logger.log("[websearch-native] No custom model configured");
+		return {
+			results: [],
+			source: "none"
+		};
+	}
+	const provider = modelConfig.provider;
+	let results = null;
+	if (provider === "anthropic") results = await searchAnthropicNative(query, numResults, modelConfig, logger);
+	else if (provider === "openai") results = await searchOpenAINative(query, numResults, modelConfig, logger);
+	else logger.log("[websearch-native] Unsupported provider:", provider);
+	if (results && results.length > 0) return {
+		results,
+		source: `native-${provider}`
+	};
+	return {
+		results: [],
+		source: "none"
+	};
+}
+function parseRequestBody(body) {
+	try {
+		const parsed = JSON.parse(body);
+		const query = typeof parsed.query === "string" ? parsed.query.trim() : "";
+		if (!query) return null;
+		return {
+			query,
+			numResults: typeof parsed.numResults === "number" && Number.isFinite(parsed.numResults) ? Math.max(1, parsed.numResults) : 10
+		};
+	} catch {
+		return null;
+	}
+}
+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).toString("utf-8");
+}
+async function startNativeWebsearchProxy(options) {
+	const logger = options.logger ?? console;
+	const host = options.host ?? "127.0.0.1";
+	const port = options.port ?? 0;
+	const factoryApiUrl = options.factoryApiUrl ?? "https://api.factory.ai";
+	let totalRequests = 0;
+	let websearchRequests = 0;
+	let lastWebsearchAt = null;
+	let lastWebsearchSource = 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"}`);
+			if (requestUrl.pathname === "/health") {
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({
+					status: "ok",
+					mode: "native-provider",
+					requests: {
+						total: totalRequests,
+						websearch: websearchRequests,
+						lastWebsearchAt,
+						lastWebsearchSource
+					}
+				}));
+				return;
+			}
+			if (requestUrl.pathname === "/api/tools/exa/search" && req.method === "POST") {
+				websearchRequests += 1;
+				lastWebsearchAt = (/* @__PURE__ */ new Date()).toISOString();
+				try {
+					const parsed = parseRequestBody(await readBody(req, 1e6));
+					if (!parsed) {
+						res.writeHead(400, { "Content-Type": "application/json" });
+						res.end(JSON.stringify({
+							error: "Invalid request body",
+							results: []
+						}));
+						return;
+					}
+					const result = await search(parsed.query, parsed.numResults, logger);
+					lastWebsearchSource = result.source;
+					logger.log("[websearch-native] Results:", result.results.length, "from", result.source);
+					res.writeHead(200, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({ results: result.results }));
+				} catch (e) {
+					logger.error("[websearch-native] Search error:", e.message);
+					res.writeHead(500, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({
+						error: String(e),
+						results: []
+					}));
+				}
+				return;
+			}
+			const pathAndQuery = `${requestUrl.pathname}${requestUrl.search || ""}`;
+			const targetUrl = new URL(pathAndQuery, factoryApiUrl);
+			logger.log("[websearch-native] Proxy:", req.method ?? "GET", pathAndQuery);
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(req.headers)) {
+				if (value === void 0) continue;
+				if (key.toLowerCase() === "host") continue;
+				if (key.toLowerCase() === "accept-encoding") continue;
+				if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+				else headers.set(key, value);
+			}
+			headers.set("accept-encoding", "identity");
+			try {
+				let body;
+				if (req.method !== "GET" && req.method !== "HEAD") body = await readBody(req, 1e7);
+				const response = await fetch(targetUrl, {
+					method: req.method,
+					headers,
+					body,
+					redirect: "manual"
+				});
+				for (const [key, value] of response.headers) {
+					if (key.toLowerCase() === "content-encoding") continue;
+					if (key.toLowerCase() === "content-length") continue;
+					res.setHeader(key, value);
+				}
+				res.statusCode = response.status;
+				if (!response.body) {
+					res.end();
+					return;
+				}
+				const arrayBuffer = await response.arrayBuffer();
+				res.end(Buffer.from(arrayBuffer));
+			} catch (e) {
+				res.writeHead(502, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: "Proxy failed: " + e.message }));
+			}
+		})();
+	});
+	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 native websearch proxy server");
+	}
+	const baseUrl = `http://${host}:${address.port}`;
+	logger.log("[websearch-native] proxy listening on", baseUrl);
+	return {
+		baseUrl,
+		close: () => new Promise((resolve) => {
+			server.close(() => resolve());
+		})
+	};
+}
+
 //#endregion
 //#region src/droid-adapter.ts
 function createDroidAdapter(options) {
@@ -2044,18 +2348,8 @@ function createDroidAdapter(options) {
 			};
 			const reasoningEffort = env.DROID_ACP_REASONING_EFFORT;
 			if (typeof reasoningEffort === "string" && reasoningEffort.trim().length > 0) args.push("--reasoning-effort", reasoningEffort.trim());
-			const hasExplicitToggle = typeof env.DROID_ACP_WEBSEARCH === "string";
-			const smitheryConfigured = typeof env.SMITHERY_API_KEY === "string" && env.SMITHERY_API_KEY.trim().length > 0 && typeof env.SMITHERY_PROFILE === "string" && env.SMITHERY_PROFILE.trim().length > 0;
-			const forwardConfigured = typeof env.DROID_ACP_WEBSEARCH_FORWARD_URL === "string" && env.DROID_ACP_WEBSEARCH_FORWARD_URL.trim().length > 0;
-			if (hasExplicitToggle ? isEnvEnabled(env.DROID_ACP_WEBSEARCH) : smitheryConfigured || forwardConfigured) {
+			if (isEnvEnabled(env.DROID_ACP_WEBSEARCH_NATIVE)) {
 				stopWebsearchProxy();
-				const upstreamBaseUrl = env.DROID_ACP_WEBSEARCH_UPSTREAM_URL ?? env.FACTORY_API_BASE_URL_OVERRIDE ?? "https://api.factory.ai";
-				const forwardModeRaw = env.DROID_ACP_WEBSEARCH_FORWARD_MODE;
-				const forwardUrlRaw = typeof env.DROID_ACP_WEBSEARCH_FORWARD_URL === "string" ? env.DROID_ACP_WEBSEARCH_FORWARD_URL.trim() : "";
-				const forwardPrefixMatch = forwardUrlRaw.match(/^mcp:(.*)$/i);
-				const websearchForwardUrl = forwardUrlRaw.length > 0 ? forwardUrlRaw : void 0;
-				const forwardModeNormalized = typeof forwardModeRaw === "string" ? forwardModeRaw.trim().toLowerCase() : "";
-				const websearchForwardMode = forwardModeNormalized === "mcp" ? "mcp" : forwardModeNormalized === "http" ? "http" : forwardPrefixMatch ? "mcp" : "http";
 				const host = env.DROID_ACP_WEBSEARCH_HOST ?? "127.0.0.1";
 				const portRaw = env.DROID_ACP_WEBSEARCH_PORT;
 				let port;
@@ -2064,12 +2358,10 @@ function createDroidAdapter(options) {
 					if (Number.isNaN(parsed) || parsed < 0 || parsed > 65535) throw new Error(`Invalid DROID_ACP_WEBSEARCH_PORT: ${portRaw}`);
 					port = parsed;
 				}
-				websearchProxy = await startWebsearchProxy({
-					upstreamBaseUrl,
-					websearchForwardUrl: forwardPrefixMatch ? forwardPrefixMatch[1]?.trim() : websearchForwardUrl,
-					websearchForwardMode,
-					smitheryApiKey: env.SMITHERY_API_KEY,
-					smitheryProfile: env.SMITHERY_PROFILE,
+				const factoryApiUrl = env.DROID_ACP_WEBSEARCH_UPSTREAM_URL ?? env.FACTORY_API_BASE_URL_OVERRIDE ?? "https://api.factory.ai";
+				logger.log("[websearch] Starting native provider proxy (experimental)...");
+				websearchProxy = await startNativeWebsearchProxy({
+					factoryApiUrl,
 					host,
 					port,
 					logger
@@ -2077,6 +2369,41 @@ function createDroidAdapter(options) {
 				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;
+			} else {
+				const hasExplicitToggle = typeof env.DROID_ACP_WEBSEARCH === "string";
+				const smitheryConfigured = typeof env.SMITHERY_API_KEY === "string" && env.SMITHERY_API_KEY.trim().length > 0 && typeof env.SMITHERY_PROFILE === "string" && env.SMITHERY_PROFILE.trim().length > 0;
+				const forwardConfigured = typeof env.DROID_ACP_WEBSEARCH_FORWARD_URL === "string" && env.DROID_ACP_WEBSEARCH_FORWARD_URL.trim().length > 0;
+				if (hasExplicitToggle ? isEnvEnabled(env.DROID_ACP_WEBSEARCH) : smitheryConfigured || forwardConfigured) {
+					stopWebsearchProxy();
+					const upstreamBaseUrl = env.DROID_ACP_WEBSEARCH_UPSTREAM_URL ?? env.FACTORY_API_BASE_URL_OVERRIDE ?? "https://api.factory.ai";
+					const forwardModeRaw = env.DROID_ACP_WEBSEARCH_FORWARD_MODE;
+					const forwardUrlRaw = typeof env.DROID_ACP_WEBSEARCH_FORWARD_URL === "string" ? env.DROID_ACP_WEBSEARCH_FORWARD_URL.trim() : "";
+					const forwardPrefixMatch = forwardUrlRaw.match(/^mcp:(.*)$/i);
+					const websearchForwardUrl = forwardUrlRaw.length > 0 ? forwardUrlRaw : void 0;
+					const forwardModeNormalized = typeof forwardModeRaw === "string" ? forwardModeRaw.trim().toLowerCase() : "";
+					const websearchForwardMode = forwardModeNormalized === "mcp" ? "mcp" : forwardModeNormalized === "http" ? "http" : forwardPrefixMatch ? "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: forwardPrefixMatch ? forwardPrefixMatch[1]?.trim() : 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: [
@@ -3858,5 +4185,5 @@ function runAcp() {
 }
 
 //#endregion
-export { ACP_MODES as a, isEnvEnabled as c, startWebsearchProxy as i, isWindows as l, DroidAcpAgent as n, Pushable as o, createDroidAdapter as r, findDroidExecutable as s, runAcp as t };
-//# sourceMappingURL=acp-agent-k2cYadeP.mjs.map
+export { startWebsearchProxy as a, findDroidExecutable as c, startNativeWebsearchProxy as i, isEnvEnabled as l, DroidAcpAgent as n, ACP_MODES as o, createDroidAdapter as r, Pushable as s, runAcp as t, isWindows as u };
+//# sourceMappingURL=acp-agent-DYlR7vNB.mjs.map