aai-gateway 0.4.3 → 0.5.0

package/README.md

@@ -14,7 +14,6 @@ Why this matters:
   **App-level exposure, not tool-level.** Tools are grouped into apps and only the app interface is visible initially. Users interact through `app:<id>` guides instead of seeing dozens of individual tools.
 
   **Two app interfaces, user chooses:**
-
   - `summary` — a natural language description; good for automatic triggering
   - `keywords` — a compact keyword set; further reduces context overhead when users reference tools explicitly
 
@@ -73,12 +72,55 @@ Once connected, your AI tool can use AAI Gateway tools such as:
 
 - `remote:discover`
 - `aai:exec`
+- `import:search`
 - `mcp:import`
 - `skill:import`
 - `mcp:refresh`
 - `import:config`
 
-### 2. Import An MCP Server
+`import:search` also has a compatibility alias: `ability_search`.
+
+### 2. Search For MCP Servers Or Skills
+
+If you do not already know which MCP server or skill to install, ask the AI tool to call `import:search` first.
+
+This tool does not perform the web search for you. Instead, it:
+
+- turns the user request into search keywords
+- recommends safer mainstream sources to search first
+- normalizes the agent's gathered results into a shortlist
+- gives each shortlist item a temporary id for user confirmation
+- routes confirmed items into existing `mcp:import` or `skill:import` flows
+
+Recommended source order:
+
+- Official catalogs first:
+  - `modelcontextprotocol/registry`
+  - `modelcontextprotocol/servers`
+  - `openai/skills`
+- Community-curated GitHub lists second:
+  - `punkpeye/awesome-mcp-servers`
+  - `ComposioHQ/awesome-claude-skills`
+- Higher-scrutiny sources:
+  - open marketplaces such as ClawHub
+
+Important:
+
+- The recommended list is a preferred starting point, not a hard allowlist.
+- Do not casually suggest tools from random small websites.
+- Outside the preferred list, inspect maintainer identity, repository activity, README quality, license visibility, and whether the source actually exposes an importable MCP config or real skill root.
+- Open marketplaces such as ClawHub should be treated with extra caution. They are not default-trust sources.
+
+If the AI tool does not already have a retrieval tool, it can first import a fetch MCP through AAI Gateway, for example:
+
+```json
+{
+  "command": "npx",
+  "args": ["-y", "mcp-fetch-server"]
+}
+```
+
+### 3. Import An MCP Server
 
 The main workflow is: copy a mainstream MCP config snippet into your AI tool and ask it to import that server through AAI Gateway.
 
@@ -137,7 +179,7 @@ Important:
 - After restart, the imported app will appear as `app:<id>`.
 - Use `aai:exec` to actually run the imported app’s operations.
 
-### 3. Import A Skill
+### 4. Import A Skill
 
 Skills are imported through the AI tool as well.
 
@@ -169,7 +211,7 @@ Just like MCP import, skill import returns:
 
 Then restart your AI tool before using the imported skill.
 
-### 4. Supported ACP Agents
+### 5. Supported ACP Agents
 
 AAI Gateway can also control app-like agents through ACP.
 

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { A as logger, D as createDesktopDiscovery, O as getManagedAppDir, T as AAI_GATEWAY_VERSION, _ as isMcpAccess, a as buildMcpImportConfig, b as getMcpExecutor, c as importSkill, d as upsertSkillRegistryEntry, f as upsertMcpRegistryEntry, i as IMPORT_LIMITS, l as normalizeExposureInput, m as createSecureStorage, n as createGatewayServer, o as buildSkillImportSource, r as EXPOSURE_LIMITS, s as importMcpServer, u as validateImportHeaders, v as isSkillAccess } from "./server-C2U35Fro.js";
+import { A as logger, D as createDesktopDiscovery, O as getManagedAppDir, T as AAI_GATEWAY_VERSION, _ as isMcpAccess, a as buildMcpImportConfig, b as getMcpExecutor, c as importSkill, d as upsertSkillRegistryEntry, f as upsertMcpRegistryEntry, i as IMPORT_LIMITS, l as normalizeExposureInput, m as createSecureStorage, n as createGatewayServer, o as buildSkillImportSource, r as EXPOSURE_LIMITS, s as importMcpServer, u as validateImportHeaders, v as isSkillAccess } from "./server-Cz0gw4Tf.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/cli.ts

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as logger, C as AcpExecutor, D as createDesktopDiscovery, E as fetchWebDescriptor, M as ConsentManager, N as createConsentDialog, P as AaiError, S as getCliExecutor, T as AAI_GATEWAY_VERSION, b as getMcpExecutor, g as getSkillExecutor, h as SkillExecutor, j as parseAaiJson, k as SimpleCache, m as createSecureStorage, n as createGatewayServer, p as FileRegistry, t as AaiGatewayServer, w as getAcpExecutor, x as CliExecutor, y as McpExecutor } from "./server-C2U35Fro.js";
+import { A as logger, C as AcpExecutor, D as createDesktopDiscovery, E as fetchWebDescriptor, M as ConsentManager, N as createConsentDialog, P as AaiError, S as getCliExecutor, T as AAI_GATEWAY_VERSION, b as getMcpExecutor, g as getSkillExecutor, h as SkillExecutor, j as parseAaiJson, k as SimpleCache, m as createSecureStorage, n as createGatewayServer, p as FileRegistry, t as AaiGatewayServer, w as getAcpExecutor, x as CliExecutor, y as McpExecutor } from "./server-Cz0gw4Tf.js";
 //#region src/executors/registry.ts
 /**
 * Executor Registry

package/dist/{server-C2U35Fro.js → server-Cz0gw4Tf.js}

@@ -2955,6 +2955,448 @@ function validateStringRecordLength(record, field, maxItems, maxKeyLength, maxVa
 	}
 }
 //#endregion
+//#region src/mcp/search-guidance.ts
+var IMPORT_SEARCH_TOOL_NAME = "import:search";
+var IMPORT_SEARCH_TOOL_ALIASES = ["ability_search"];
+var PREFERRED_SOURCES = [
+	{
+		label: "Official MCP Registry",
+		url: "https://github.com/modelcontextprotocol/registry",
+		tier: "official",
+		reason: "Primary MCP ecosystem registry under the official MCP GitHub organization."
+	},
+	{
+		label: "Official MCP Servers",
+		url: "https://github.com/modelcontextprotocol/servers",
+		tier: "official",
+		reason: "Official MCP server catalog and examples maintained by the MCP organization."
+	},
+	{
+		label: "OpenAI Skills Catalog",
+		url: "https://github.com/openai/skills",
+		tier: "official",
+		reason: "Official public skills catalog for Codex-oriented skills."
+	},
+	{
+		label: "awesome-mcp-servers",
+		url: "https://github.com/punkpeye/awesome-mcp-servers",
+		tier: "community",
+		reason: "Community-curated MCP discovery list; useful for breadth, but not authoritative."
+	},
+	{
+		label: "awesome-claude-skills",
+		url: "https://github.com/ComposioHQ/awesome-claude-skills",
+		tier: "community",
+		reason: "Community-curated skill list; useful for discovery, but not an official catalog."
+	},
+	{
+		label: "Open marketplaces such as ClawHub",
+		url: "https://clawhub.dev",
+		tier: "high-scrutiny",
+		reason: "Open publishing marketplaces can contain malicious or weakly reviewed skills and are not default-trust sources."
+	}
+];
+var importSearchInputSchema = {
+	type: "object",
+	properties: {
+		request: {
+			type: "string",
+			description: "Required. The user request or installation intent you want to satisfy, for example \"I need an MCP that can search GitHub issues\"."
+		},
+		hasRetrievalTool: {
+			type: "boolean",
+			description: "Optional. Set to false when the agent does not currently have a web retrieval tool. The response will include fetch-tool fallback guidance."
+		},
+		evidence: {
+			type: "array",
+			description: "Optional. Search results gathered by the agent from preferred sources. Provide this to normalize candidates and generate user-facing selection ids.",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					type: {
+						type: "string",
+						enum: ["mcp", "skill"]
+					},
+					source: { type: "string" },
+					url: { type: "string" },
+					description: { type: "string" },
+					stars: { type: "number" },
+					popularity: { type: "string" },
+					install: {
+						type: "object",
+						properties: {
+							transport: {
+								type: "string",
+								enum: ["streamable-http", "sse"]
+							},
+							url: { type: "string" },
+							path: { type: "string" },
+							headers: {
+								type: "object",
+								additionalProperties: { type: "string" }
+							},
+							command: { type: "string" },
+							args: {
+								type: "array",
+								items: { type: "string" }
+							},
+							env: {
+								type: "object",
+								additionalProperties: { type: "string" }
+							},
+							cwd: { type: "string" }
+						},
+						additionalProperties: false
+					}
+				},
+				required: ["name", "url"],
+				additionalProperties: false
+			}
+		},
+		confirmedIds: {
+			type: "array",
+			description: "Optional. Candidate ids confirmed by the user. Resend the same evidence array together with these ids to generate an install handoff plan.",
+			items: { type: "string" }
+		}
+	},
+	required: ["request"],
+	additionalProperties: false,
+	examples: [{
+		request: "Need an MCP or skill that can search GitHub issues and PRs",
+		hasRetrievalTool: true
+	}, {
+		request: "Need a skill for release notes and changelog drafting",
+		evidence: [{
+			name: "Release Notes Writer",
+			type: "skill",
+			source: "GitHub/openai/skills",
+			url: "https://github.com/openai/skills/tree/main/skills/release-notes",
+			stars: 1200,
+			install: { url: "https://raw.githubusercontent.com/openai/skills/main/skills/release-notes" }
+		}],
+		confirmedIds: ["skill-abc123"]
+	}]
+};
+function parseImportSearchArguments(args) {
+	const request = asTrimmedString(args?.request);
+	if (!request) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} requires a non-empty 'request'`);
+	const evidence = parseEvidence(args?.evidence);
+	const confirmedIds = parseConfirmedIds(args?.confirmedIds);
+	return {
+		request,
+		hasRetrievalTool: args?.hasRetrievalTool === false ? false : true,
+		evidence,
+		confirmedIds
+	};
+}
+function buildImportSearchResponse(args) {
+	const lines = [];
+	lines.push(`Search intent: ${args.request}`);
+	lines.push("");
+	lines.push("Preferred source policy:");
+	lines.push(...formatSourcePolicy());
+	lines.push("");
+	lines.push("Suggested queries:");
+	lines.push(...buildQueryPlan(args.request).map((query) => `- ${query}`));
+	if (!args.hasRetrievalTool) {
+		lines.push("");
+		lines.push("Retrieval fallback:");
+		lines.push(...formatFetchFallback());
+	}
+	if (args.evidence.length === 0) {
+		lines.push("");
+		lines.push("Next step:");
+		lines.push("- Search the preferred sources above with your own retrieval tool. If you do not have one, import a fetch MCP first.");
+		lines.push("- Gather candidate evidence with at least `name` and `url`. Include `type`, `source`, `stars`, `description`, and `install` hints when available.");
+		lines.push(`- Call \`${IMPORT_SEARCH_TOOL_NAME}\` again with the same \`request\` plus an \`evidence\` array so the gateway can normalize a shortlist.`);
+		return lines.join("\n");
+	}
+	const candidates = normalizeCandidates(args.evidence);
+	lines.push("");
+	lines.push("Candidate shortlist:");
+	lines.push(...formatCandidates(candidates));
+	if (args.confirmedIds.length === 0) {
+		lines.push("");
+		lines.push("User confirmation required:");
+		lines.push("- Ask the user to confirm one or more candidate ids from the shortlist above.");
+		lines.push(`- Then call \`${IMPORT_SEARCH_TOOL_NAME}\` again with the same \`request\`, the same \`evidence\`, and \`confirmedIds\`.`);
+		return lines.join("\n");
+	}
+	const confirmed = resolveConfirmedCandidates(candidates, args.confirmedIds);
+	lines.push("");
+	lines.push("Installation handoff:");
+	lines.push(...formatInstallHandoff(confirmed));
+	lines.push("");
+	lines.push("Import reminder:");
+	lines.push("- After the first `mcp:import` or `skill:import` inspection call, ask the user to confirm exposure mode, keywords, and summary before completing the final import.");
+	return lines.join("\n");
+}
+function normalizeCandidates(evidence) {
+	const seenIds = /* @__PURE__ */ new Map();
+	return evidence.map((item) => {
+		const type = inferCandidateType(item);
+		const source = item.source?.trim() || inferSourceLabel(item.url);
+		const tier = inferSourceTier(item.url, source);
+		const install = normalizeInstallHint(item.install);
+		const popularity = normalizePopularity(item.stars, item.popularity);
+		const baseId = `${type}-${stableHash([
+			type,
+			item.name,
+			item.url,
+			source
+		].join("|"))}`;
+		const nextCount = (seenIds.get(baseId) ?? 0) + 1;
+		seenIds.set(baseId, nextCount);
+		return {
+			id: nextCount === 1 ? baseId : `${baseId}-${nextCount}`,
+			type,
+			name: item.name.trim(),
+			source,
+			url: item.url.trim(),
+			description: asOptionalTrimmedString(item.description),
+			stars: typeof item.stars === "number" && Number.isFinite(item.stars) ? item.stars : void 0,
+			popularity,
+			tier,
+			install
+		};
+	}).sort((a, b) => {
+		const starDelta = (b.stars ?? -1) - (a.stars ?? -1);
+		if (starDelta !== 0) return starDelta;
+		return a.name.localeCompare(b.name);
+	});
+}
+function resolveConfirmedCandidates(candidates, confirmedIds) {
+	const uniqueIds = Array.from(new Set(confirmedIds.map((item) => item.trim()).filter(Boolean)));
+	const matched = uniqueIds.map((id) => candidates.find((candidate) => candidate.id === id));
+	const missing = uniqueIds.filter((_id, index) => !matched[index]);
+	if (missing.length > 0) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} received unknown confirmedIds: ${missing.join(", ")}`);
+	return matched.filter((candidate) => Boolean(candidate));
+}
+function formatInstallHandoff(candidates) {
+	const lines = [];
+	for (const candidate of candidates) {
+		lines.push(`- [${candidate.id}] ${candidate.name} | ${candidate.type} | next step: ${candidate.type === "mcp" ? "`mcp:import`" : "`skill:import`"}`);
+		lines.push(`  Source: ${candidate.url}`);
+		if (candidate.type === "mcp") {
+			const payload = buildMcpImportPayload(candidate.install);
+			if (payload) {
+				lines.push("  First import call payload:");
+				lines.push(indentBlock(jsonBlock(payload)));
+			} else lines.push("  Import status: inspect the repository docs first and extract a supported MCP config snippet before calling `mcp:import`.");
+		} else {
+			const payload = buildSkillImportPayload(candidate.install);
+			if (payload) {
+				lines.push("  First import call payload:");
+				lines.push(indentBlock(jsonBlock(payload)));
+			} else lines.push("  Import status: inspect the skill docs first and find a skill root `url` or local `path` before calling `skill:import`.");
+		}
+	}
+	return lines;
+}
+function buildMcpImportPayload(install) {
+	if (!install) return null;
+	try {
+		const payload = { ...buildMcpImportConfig({
+			transport: install.transport,
+			url: asOptionalTrimmedString(install.url),
+			command: asOptionalTrimmedString(install.command),
+			args: asStringArray$1(install.args),
+			env: isStringRecord$1(install.env) ? install.env : void 0,
+			cwd: asOptionalTrimmedString(install.cwd)
+		}) };
+		if (isStringRecord$1(install.headers)) {
+			validateImportHeaders(install.headers);
+			payload.headers = install.headers;
+		}
+		return payload;
+	} catch {
+		return null;
+	}
+}
+function buildSkillImportPayload(install) {
+	if (!install) return null;
+	try {
+		return { ...buildSkillImportSource({
+			path: asOptionalTrimmedString(install.path),
+			url: asOptionalTrimmedString(install.url)
+		}) };
+	} catch {
+		return null;
+	}
+}
+function formatCandidates(candidates) {
+	return candidates.map((candidate) => {
+		const popularity = candidate.popularity ? ` | popularity: ${candidate.popularity}` : "";
+		const description = candidate.description ? ` | ${candidate.description}` : "";
+		return `- [${candidate.id}] ${candidate.name} | ${candidate.type} | ${candidate.source} | trust: ${candidate.tier}${popularity} | ${candidate.url}${description}`;
+	});
+}
+function buildQueryPlan(request) {
+	const normalized = request.trim();
+	return [
+		normalized,
+		`mcp ${normalized}`,
+		`model context protocol ${normalized}`,
+		`skill ${normalized}`,
+		`SKILL.md ${normalized}`,
+		`site:github.com ${normalized}`
+	];
+}
+function formatSourcePolicy() {
+	return PREFERRED_SOURCES.map((source) => `- [${source.tier}] ${source.label}: ${source.url} — ${source.reason}`).concat([
+		"- Use the list above as a preferred starting point, not a hard allowlist.",
+		"- Avoid arbitrary low-trust or low-signal websites when suggesting installable tools.",
+		"- Outside the preferred list, verify maintainer identity, repository activity, README quality, license visibility, and whether the source exposes a real import path or config."
+	]);
+}
+function formatFetchFallback() {
+	return [
+		"- You said no retrieval tool is available. Import a fetch MCP before searching remote sources if needed.",
+		"- Recommended first import call:",
+		indentBlock(jsonBlock({
+			command: "npx",
+			args: ["-y", "mcp-fetch-server"]
+		})),
+		"- Optional MCP config details for the underlying server:",
+		indentBlock(jsonBlock({
+			type: "local",
+			command: [
+				"npx",
+				"-y",
+				"mcp-fetch-server"
+			],
+			enabled: true,
+			timeout: 5e4,
+			environment: { DEFAULT_LIMIT: "50000" }
+		}))
+	];
+}
+function parseEvidence(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} expected 'evidence' to be an array`);
+	return value.map((item, index) => parseEvidenceItem(item, index));
+}
+function parseEvidenceItem(value, index) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} evidence[${index}] must be an object`);
+	const item = value;
+	const name = asTrimmedString(item.name);
+	const url = asTrimmedString(item.url);
+	if (!name || !url) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} evidence[${index}] requires non-empty 'name' and 'url'`);
+	return {
+		name,
+		type: item.type === "mcp" || item.type === "skill" ? item.type : void 0,
+		source: asOptionalTrimmedString(item.source),
+		url,
+		description: asOptionalTrimmedString(item.description),
+		stars: asOptionalNumber(item.stars),
+		popularity: asOptionalTrimmedString(item.popularity),
+		install: parseInstallHint(item.install, index)
+	};
+}
+function parseInstallHint(value, index) {
+	if (value === void 0) return;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} evidence[${index}].install must be an object`);
+	const install = value;
+	return normalizeInstallHint({
+		transport: install.transport === "streamable-http" || install.transport === "sse" ? install.transport : void 0,
+		url: asOptionalTrimmedString(install.url),
+		path: asOptionalTrimmedString(install.path),
+		headers: isStringRecord$1(install.headers) ? install.headers : void 0,
+		command: asOptionalTrimmedString(install.command),
+		args: asStringArray$1(install.args),
+		env: isStringRecord$1(install.env) ? install.env : void 0,
+		cwd: asOptionalTrimmedString(install.cwd)
+	});
+}
+function parseConfirmedIds(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`${IMPORT_SEARCH_TOOL_NAME} expected 'confirmedIds' to be an array`);
+	return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+function inferCandidateType(item) {
+	if (item.type) return item.type;
+	if (item.install?.path) return "skill";
+	if (item.install?.command || item.install?.transport || item.install?.headers) return "mcp";
+	const combined = `${item.name} ${item.source ?? ""} ${item.url} ${item.description ?? ""}`.toLowerCase();
+	if (combined.includes("skill")) return "skill";
+	if (combined.includes("mcp")) return "mcp";
+	if (item.url.toLowerCase().includes("/skills/")) return "skill";
+	return "mcp";
+}
+function inferSourceLabel(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname === "github.com") {
+			const segments = parsed.pathname.split("/").filter(Boolean);
+			if (segments.length >= 2) return `GitHub/${segments[0]}/${segments[1]}`;
+		}
+		return parsed.hostname;
+	} catch {
+		return "unclassified";
+	}
+}
+function inferSourceTier(url, source) {
+	const value = `${url} ${source}`.toLowerCase();
+	if (value.includes("github.com/modelcontextprotocol/registry") || value.includes("github.com/modelcontextprotocol/servers") || value.includes("github.com/openai/skills")) return "official";
+	if (value.includes("github.com/punkpeye/awesome-mcp-servers") || value.includes("github.com/composiohq/awesome-claude-skills")) return "community";
+	if (value.includes("clawhub")) return "high-scrutiny";
+	return "unclassified";
+}
+function normalizePopularity(stars, popularity) {
+	if (typeof stars === "number" && Number.isFinite(stars)) return `${formatCompactNumber(stars)} GitHub stars`;
+	return asOptionalTrimmedString(popularity);
+}
+function formatCompactNumber(value) {
+	if (value >= 1e3) return `${Math.round(value / 1e3 * 10) / 10}k`;
+	return String(value);
+}
+function normalizeInstallHint(install) {
+	if (!install) return;
+	const next = {
+		transport: install.transport,
+		url: asOptionalTrimmedString(install.url),
+		path: asOptionalTrimmedString(install.path),
+		headers: isStringRecord$1(install.headers) ? install.headers : void 0,
+		command: asOptionalTrimmedString(install.command),
+		args: asStringArray$1(install.args),
+		env: isStringRecord$1(install.env) ? install.env : void 0,
+		cwd: asOptionalTrimmedString(install.cwd)
+	};
+	if (Object.values(next).every((value) => value === void 0 || Array.isArray(value) && value.length === 0)) return;
+	return next;
+}
+function stableHash(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36).slice(0, 6);
+}
+function jsonBlock(value) {
+	return `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
+}
+function indentBlock(value) {
+	return value.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function asTrimmedString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asOptionalTrimmedString(value) {
+	return asTrimmedString(value);
+}
+function asOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asStringArray$1(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean) : [];
+}
+function isStringRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	return Object.entries(value).every(([key, item]) => typeof key === "string" && typeof item === "string");
+}
+//#endregion
 //#region src/mcp/task-runner.ts
 var McpTaskRunner = class {
 	activeTasks = /* @__PURE__ */ new Map();
@@ -3378,6 +3820,16 @@ var AaiGatewayServer = class {
 					}
 				}
 			});
+			tools.push({
+				name: IMPORT_SEARCH_TOOL_NAME,
+				description: "Plan discovery for MCP servers and skills, normalize agent-gathered search results into a shortlist, and generate install handoff guidance that routes to existing import tools.",
+				inputSchema: importSearchInputSchema
+			});
+			for (const alias of IMPORT_SEARCH_TOOL_ALIASES) tools.push({
+				name: alias,
+				description: `Alias for \`${IMPORT_SEARCH_TOOL_NAME}\`. Use it to get discovery guidance, shortlist candidates, and hand off confirmed items to existing import tools.`,
+				inputSchema: importSearchInputSchema
+			});
 			return { tools };
 		});
 		this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
@@ -3395,6 +3847,7 @@ var AaiGatewayServer = class {
 			if (name === "mcp:import") return this.handleMcpImport(args);
 			if (name === "skill:import") return this.handleSkillImport(args);
 			if (name === "import:config") return this.handleImportConfig(args);
+			if (name === "import:search" || IMPORT_SEARCH_TOOL_ALIASES.includes(name)) return this.handleImportSearch(args);
 			throw new AaiError("UNKNOWN_TOOL", `Unknown tool: ${name}`);
 		});
 	}
@@ -3592,6 +4045,16 @@ var AaiGatewayServer = class {
 			].join("\n")
 		}] };
 	}
+	async handleImportSearch(args) {
+		try {
+			return { content: [{
+				type: "text",
+				text: buildImportSearchResponse(parseImportSearchArguments(args))
+			}] };
+		} catch (err) {
+			throw new AaiError("INVALID_REQUEST", err instanceof Error ? err.message : String(err));
+		}
+	}
 	async loadGuideDetail(localId, descriptor) {
 		try {
 			return await this.loadLayer3Detail(localId, descriptor);
@@ -4123,4 +4586,4 @@ function createStaticDetail(descriptor, err) {
 //#endregion
 export { logger as A, AcpExecutor as C, createDesktopDiscovery as D, fetchWebDescriptor as E, ConsentManager as M, createConsentDialog as N, getManagedAppDir as O, AaiError as P, getCliExecutor as S, AAI_GATEWAY_VERSION as T, isMcpAccess as _, buildMcpImportConfig as a, getMcpExecutor as b, importSkill as c, upsertSkillRegistryEntry as d, upsertMcpRegistryEntry as f, getSkillExecutor as g, SkillExecutor as h, IMPORT_LIMITS as i, parseAaiJson as j, SimpleCache as k, normalizeExposureInput as l, createSecureStorage as m, createGatewayServer as n, buildSkillImportSource as o, FileRegistry as p, EXPOSURE_LIMITS as r, importMcpServer as s, AaiGatewayServer as t, validateImportHeaders as u, isSkillAccess as v, getAcpExecutor as w, CliExecutor as x, McpExecutor as y };
 
-//# sourceMappingURL=server-C2U35Fro.js.map
+//# sourceMappingURL=server-Cz0gw4Tf.js.map