@f5-sales-demo/xcsh 19.51.2

package/src/exa/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Exa MCP Tools
+ *
+ * 22 tools for Exa's MCP servers:
+ * - 4 search tools (search, deep, code, crawl)
+ * - 1 LinkedIn search tool
+ * - 1 company research tool
+ * - 2 researcher tools (start, poll)
+ * - 14 websets tools (CRUD, items, search, enrichment, monitor)
+ */
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import { researcherTools } from "./researcher";
+import { searchTools } from "./search";
+import type { ExaRenderDetails } from "./types";
+import { websetsTools } from "./websets";
+
+/** All Exa tools (22 total) - static export for backward compatibility */
+export const exaTools: CustomTool<any, ExaRenderDetails>[] = [...searchTools, ...researcherTools, ...websetsTools];
+
+export * from "./mcp-client";
+export { renderExaCall, renderExaResult } from "./render";
+export { researcherTools } from "./researcher";
+// Re-export individual modules for selective importing
+export { searchTools } from "./search";
+// Re-export types and utilities
+export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult, MCPToolWrapperConfig } from "./types";
+export { websetsTools } from "./websets";

package/src/exa/mcp-client.ts

@@ -0,0 +1,293 @@
+import { $env, logger } from "@f5xc-salesdemos/pi-utils";
+import type { TSchema } from "@sinclair/typebox";
+import type { CustomTool, CustomToolResult } from "../extensibility/custom-tools/types";
+import { callMCP } from "../mcp/json-rpc";
+import type {
+	ExaRenderDetails,
+	ExaSearchResponse,
+	MCPCallResponse,
+	MCPTool,
+	MCPToolsResponse,
+	MCPToolWrapperConfig,
+} from "./types";
+
+/** Find EXA_API_KEY from Bun.env or .env files */
+export function findApiKey(): string | null {
+	return $env.EXA_API_KEY;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseJsonContent(text: string): unknown | null {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Normalize tools/call payloads across MCP servers.
+ *
+ * Exa currently returns different shapes depending on deployment/environment:
+ * - direct payload in result
+ * - structured payload under result.structuredContent / result.data / result.result
+ * - JSON payload embedded as text in result.content[]
+ */
+function normalizeMcpToolPayload(payload: unknown): unknown {
+	const candidates: unknown[] = [];
+	const root = asRecord(payload);
+
+	if (root) {
+		if (root.structuredContent !== undefined) candidates.push(root.structuredContent);
+		if (root.data !== undefined) candidates.push(root.data);
+		if (root.result !== undefined) candidates.push(root.result);
+		candidates.push(root);
+
+		const content = root.content;
+		if (Array.isArray(content)) {
+			for (const item of content) {
+				const part = asRecord(item);
+				if (!part) continue;
+				const text = part.text;
+				if (typeof text !== "string" || text.trim().length === 0) continue;
+				const parsed = parseJsonContent(text);
+				if (parsed !== null) candidates.push(parsed);
+			}
+		}
+	} else {
+		candidates.push(payload);
+	}
+
+	for (const candidate of candidates) {
+		if (isSearchResponse(candidate)) {
+			return candidate;
+		}
+	}
+
+	return payload;
+}
+
+/** Fetch available tools from Exa MCP */
+export async function fetchExaTools(apiKey: string | null, toolNames: string[]): Promise<MCPTool[]> {
+	const params = new URLSearchParams();
+	if (apiKey) params.set("exaApiKey", apiKey);
+	params.set("toolNames", toolNames.join(","));
+	const url = `https://mcp.exa.ai/mcp?${params.toString()}`;
+	const response = (await callMCP(url, "tools/list")) as MCPToolsResponse;
+
+	if (response.error) {
+		logger.error("MCP tools/list error", { toolNames, error: response.error });
+		throw new Error(`MCP error: ${response.error.message}`);
+	}
+
+	return response.result?.tools ?? [];
+}
+
+/** Fetch available tools from Websets MCP */
+export async function fetchWebsetsTools(apiKey: string): Promise<MCPTool[]> {
+	const url = `https://websetsmcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(apiKey)}`;
+	const response = (await callMCP(url, "tools/list")) as MCPToolsResponse;
+
+	if (response.error) {
+		logger.error("Websets MCP tools/list error", { error: response.error });
+		throw new Error(`MCP error: ${response.error.message}`);
+	}
+
+	return response.result?.tools ?? [];
+}
+
+/** Call a tool on Exa MCP (simplified: toolName as first arg for easier use) */
+export async function callExaTool(
+	toolName: string,
+	args: Record<string, unknown>,
+	apiKey: string | null,
+): Promise<unknown> {
+	const params = new URLSearchParams();
+	if (apiKey) params.set("exaApiKey", apiKey);
+	params.set("tools", toolName);
+	const url = `https://mcp.exa.ai/mcp?${params.toString()}`;
+	const response = (await callMCP(url, "tools/call", {
+		name: toolName,
+		arguments: args,
+	})) as MCPCallResponse;
+
+	if (response.error) {
+		logger.error("MCP tools/call error", { toolName, args, error: response.error });
+		throw new Error(`MCP error: ${response.error.message}`);
+	}
+
+	return normalizeMcpToolPayload(response.result);
+}
+
+/** Call a tool on Websets MCP */
+export async function callWebsetsTool(
+	apiKey: string,
+	toolName: string,
+	args: Record<string, unknown>,
+): Promise<unknown> {
+	const url = `https://websetsmcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(apiKey)}`;
+	const response = (await callMCP(url, "tools/call", {
+		name: toolName,
+		arguments: args,
+	})) as MCPCallResponse;
+
+	if (response.error) {
+		logger.error("Websets MCP tools/call error", { toolName, args, error: response.error });
+		throw new Error(`MCP error: ${response.error.message}`);
+	}
+
+	return normalizeMcpToolPayload(response.result);
+}
+
+/** Format search results for LLM */
+export function formatSearchResults(data: ExaSearchResponse): string {
+	const results = data.results ?? [];
+	if (results.length === 0) return "No results found.";
+
+	let output = "";
+	for (let i = 0; i < results.length; i++) {
+		const r = results[i];
+		output += `\n## ${r.title ?? "Untitled"}`;
+		if (r.url) output += `\n**URL:** ${r.url}`;
+		if (r.author) output += `\n**Author:** ${r.author}`;
+		if (r.publishedDate) output += `\n**Published Date:** ${r.publishedDate}`;
+		if (r.text) output += `\n**Text:** ${r.text}`;
+		if (r.highlights?.length) {
+			output += `\n**Highlights:**`;
+			for (const h of r.highlights) {
+				output += `\n- ${h}`;
+			}
+		}
+		output += "\n";
+	}
+
+	if (data.costDollars) {
+		output += `\n**Cost:** $${data.costDollars.total.toFixed(4)}`;
+	}
+	if (data.searchTime) {
+		output += `\n**Search Time:** ${data.searchTime.toFixed(2)}s`;
+	}
+
+	return output.trim();
+}
+
+/** Check if result is a search response */
+export function isSearchResponse(data: unknown): data is ExaSearchResponse {
+	return (
+		typeof data === "object" &&
+		data !== null &&
+		("results" in data || "statuses" in data || "costDollars" in data || "searchTime" in data)
+	);
+}
+
+/** Cache for MCP tool schemas (keyed by MCP tool name) */
+const mcpSchemaCache = new Map<string, MCPTool>();
+
+/** Fetch and cache MCP tool schema */
+export async function fetchMCPToolSchema(
+	apiKey: string,
+	mcpToolName: string,
+	isWebsetsTool = false,
+): Promise<MCPTool | null> {
+	const cacheKey = `${isWebsetsTool ? "websets" : "exa"}:${mcpToolName}`;
+	if (mcpSchemaCache.has(cacheKey)) {
+		return mcpSchemaCache.get(cacheKey)!;
+	}
+
+	try {
+		const tools = isWebsetsTool ? await fetchWebsetsTools(apiKey) : await fetchExaTools(apiKey, [mcpToolName]);
+		const tool = tools.find(t => t.name === mcpToolName);
+		if (tool) {
+			mcpSchemaCache.set(cacheKey, tool);
+			return tool;
+		}
+	} catch (error) {
+		logger.warn("Failed to fetch MCP tool schema", { mcpToolName, isWebsetsTool, error: String(error) });
+	}
+	return null;
+}
+
+/**
+ * CustomTool dynamically created from MCP tool metadata.
+ *
+ * This allows tools to be generated from MCP server schemas without hardcoding,
+ * reducing drift when MCP servers add new parameters.
+ */
+export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
+	readonly name: string;
+	readonly label: string;
+
+	constructor(
+		private readonly config: MCPToolWrapperConfig,
+		public readonly parameters: TSchema,
+		public readonly description: string,
+	) {
+		this.name = config.name;
+		this.label = config.label;
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: unknown,
+		_onUpdate?: unknown,
+		_ctx?: unknown,
+		_signal?: AbortSignal,
+	): Promise<CustomToolResult<ExaRenderDetails>> {
+		try {
+			const apiKey = findApiKey();
+			// Websets tools require an API key; basic Exa MCP tools work without one
+			if (!apiKey && this.config.isWebsetsTool) {
+				return {
+					content: [{ type: "text" as const, text: "Error: EXA_API_KEY required for Websets tools" }],
+					details: { error: "EXA_API_KEY required for Websets tools", toolName: this.config.name },
+				};
+			}
+
+			const response = this.config.isWebsetsTool
+				? await callWebsetsTool(apiKey!, this.config.mcpToolName, params as Record<string, unknown>)
+				: await callExaTool(this.config.mcpToolName, params as Record<string, unknown>, apiKey);
+
+			if (isSearchResponse(response)) {
+				const formatted = formatSearchResults(response);
+				const resultCount = response.results?.length ?? 0;
+				return {
+					content: [{ type: "text" as const, text: formatted }],
+					details: { response, toolName: this.config.name },
+					...(resultCount === 0 ? { isWarning: true } : {}),
+				};
+			}
+
+			return {
+				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				details: { raw: response, toolName: this.config.name },
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return {
+				content: [{ type: "text" as const, text: `Error: ${message}` }],
+				details: { error: message, toolName: this.config.name },
+			};
+		}
+	}
+}
+
+/**
+ * Create a CustomTool by fetching schema from MCP server.
+ *
+ * Falls back to provided fallback schema if MCP fetch fails.
+ */
+export async function createMCPToolFromServer(
+	apiKey: string,
+	config: MCPToolWrapperConfig,
+	fallbackSchema: TSchema,
+	fallbackDescription: string,
+): Promise<MCPWrappedTool> {
+	const mcpTool = await fetchMCPToolSchema(apiKey, config.mcpToolName, config.isWebsetsTool);
+	const schema = mcpTool?.inputSchema ?? fallbackSchema;
+	const description = mcpTool?.description ?? fallbackDescription;
+	return new MCPWrappedTool(config, schema, description);
+}

package/src/exa/render.ts

@@ -0,0 +1,232 @@
+/**
+ * Exa TUI Rendering
+ *
+ * Tree-based rendering with collapsed/expanded states for Exa search results.
+ */
+import type { Component } from "@f5xc-salesdemos/pi-tui";
+import { Text } from "@f5xc-salesdemos/pi-tui";
+import { logger } from "@f5xc-salesdemos/pi-utils";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import {
+	formatCount,
+	formatExpandHint,
+	formatMoreItems,
+	getDomain,
+	getPreviewLines,
+	PREVIEW_LIMITS,
+	truncateToWidth,
+} from "../tools/render-utils";
+import type { ExaRenderDetails } from "./types";
+
+const COLLAPSED_PREVIEW_LINES = PREVIEW_LIMITS.COLLAPSED_LINES;
+const EXPANDED_TEXT_LINES = 5;
+
+function renderErrorMessage(message: string, theme: Theme): Text {
+	const clean = message.replace(/^Error:\s*/, "").trim();
+	return new Text(theme.fg("error", `Error: ${clean || "Unknown error"}`), 0, 0);
+}
+
+function renderEmptyMessage(message: string, theme: Theme): Text {
+	return new Text(theme.fg("muted", message), 0, 0);
+}
+
+/** Render Exa result with tree-based layout */
+export function renderExaResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: ExaRenderDetails },
+	options: RenderResultOptions,
+	uiTheme: Theme,
+): Component {
+	const details = result.details;
+
+	if (details?.error) {
+		logger.error("Exa render error", { error: details.error, toolName: details.toolName });
+		return renderErrorMessage(details.error, uiTheme);
+	}
+
+	const response = details?.response;
+	if (!response && !details?.raw) {
+		return renderEmptyMessage("No response data", uiTheme);
+	}
+
+	return {
+		render(width: number): string[] {
+			const { expanded } = options;
+			const contentWidth = Math.max(20, width - 6);
+
+			if (!response) {
+				const rawText = typeof details?.raw === "string" ? details.raw : JSON.stringify(details?.raw, null, 2);
+				const rawLines = rawText.split("\n").filter(l => l.trim());
+				const maxLines = expanded ? rawLines.length : Math.min(rawLines.length, COLLAPSED_PREVIEW_LINES);
+				const displayLines = rawLines.slice(0, maxLines);
+				const remaining = rawLines.length - maxLines;
+				const expandHint = formatExpandHint(uiTheme, expanded, remaining > 0);
+
+				const lines: string[] = [`${uiTheme.fg("dim", "Raw response")}${expandHint}`];
+
+				for (let i = 0; i < displayLines.length; i++) {
+					const isLast = i === displayLines.length - 1 && remaining === 0;
+					const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+					lines.push(
+						` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("toolOutput", truncateToWidth(displayLines[i], contentWidth))}`,
+					);
+				}
+
+				if (remaining > 0) {
+					lines.push(
+						` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "line"))}`,
+					);
+				}
+
+				return lines;
+			}
+
+			const results = response.results ?? [];
+			const resultCount = results.length;
+			const cost = response.costDollars?.total;
+			const time = response.searchTime;
+
+			const metaParts = [formatCount("result", resultCount)];
+			if (cost !== undefined) metaParts.push(`cost:$${cost.toFixed(4)}`);
+			if (time !== undefined) metaParts.push(`time:${time.toFixed(2)}s`);
+			const summaryText = metaParts.join(uiTheme.sep.dot);
+
+			let hasMorePreview = false;
+			if (!expanded && resultCount > 0) {
+				const previewText = results[0].text ?? results[0].title ?? "";
+				const totalLines = previewText.split("\n").filter(l => l.trim()).length;
+				hasMorePreview = totalLines > COLLAPSED_PREVIEW_LINES || resultCount > 1;
+			}
+			const expandHint = formatExpandHint(uiTheme, expanded, hasMorePreview);
+
+			const lines: string[] = [`${uiTheme.fg("dim", summaryText)}${expandHint}`];
+
+			if (!expanded) {
+				if (resultCount === 0) {
+					lines.push(` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", "No results")}`);
+					return lines;
+				}
+
+				const first = results[0];
+				const previewText = first.text ?? first.title ?? "";
+				const previewLines = previewText ? getPreviewLines(previewText, COLLAPSED_PREVIEW_LINES, contentWidth) : [];
+				const safePreviewLines = previewLines.length > 0 ? previewLines : ["No preview text"];
+				const totalLines = previewText.split("\n").filter(l => l.trim()).length;
+				const remainingLines = Math.max(0, totalLines - previewLines.length);
+				const extraItems: string[] = [];
+				if (remainingLines > 0) {
+					extraItems.push(formatMoreItems(remainingLines, "line"));
+				}
+				if (resultCount > 1) {
+					extraItems.push(formatMoreItems(resultCount - 1, "result"));
+				}
+
+				for (let i = 0; i < safePreviewLines.length; i++) {
+					const isLast = i === safePreviewLines.length - 1 && extraItems.length === 0;
+					const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+					const line = safePreviewLines[i];
+					const color = line === "No preview text" ? "muted" : "toolOutput";
+					lines.push(` ${uiTheme.fg("dim", branch)} ${uiTheme.fg(color, line)}`);
+				}
+
+				for (let i = 0; i < extraItems.length; i++) {
+					const isLast = i === extraItems.length - 1;
+					const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+					lines.push(` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("muted", extraItems[i])}`);
+				}
+
+				return lines;
+			}
+
+			if (resultCount === 0) {
+				lines.push(` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", "No results")}`);
+				return lines;
+			}
+
+			for (let i = 0; i < results.length; i++) {
+				const res = results[i];
+				const isLast = i === results.length - 1;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				const cont = isLast ? " " : uiTheme.tree.vertical;
+
+				const title = truncateToWidth(res.title ?? "Untitled", contentWidth);
+				const domain = res.url ? getDomain(res.url) : "";
+				const domainPart = domain ? uiTheme.fg("dim", ` (${domain})`) : "";
+
+				lines.push(` ${uiTheme.fg("dim", branch)} ${uiTheme.fg("contentAccent", title)}${domainPart}`);
+
+				if (res.url) {
+					lines.push(
+						` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("mdLinkUrl", res.url)}`,
+					);
+				}
+
+				if (res.author) {
+					lines.push(
+						` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `Author: ${res.author}`)}`,
+					);
+				}
+
+				if (res.publishedDate) {
+					lines.push(
+						` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `Published: ${res.publishedDate}`)}`,
+					);
+				}
+
+				if (res.text) {
+					const textLines = res.text.split("\n").filter(l => l.trim());
+					const displayLines = textLines.slice(0, EXPANDED_TEXT_LINES);
+					for (const line of displayLines) {
+						lines.push(
+							` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("toolOutput", truncateToWidth(line.trim(), contentWidth))}`,
+						);
+					}
+					if (textLines.length > EXPANDED_TEXT_LINES) {
+						lines.push(
+							` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", formatMoreItems(textLines.length - EXPANDED_TEXT_LINES, "line"))}`,
+						);
+					}
+				}
+
+				if (res.highlights?.length) {
+					lines.push(
+						` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("contentAccent", "Highlights")}`,
+					);
+					const maxHighlights = Math.min(res.highlights.length, 3);
+					for (let j = 0; j < maxHighlights; j++) {
+						const h = res.highlights[j];
+						lines.push(
+							` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `${uiTheme.format.dash} ${truncateToWidth(h, contentWidth)}`)}`,
+						);
+					}
+					if (res.highlights.length > maxHighlights) {
+						lines.push(
+							` ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", formatMoreItems(res.highlights.length - maxHighlights, "highlight"))}`,
+						);
+					}
+				}
+			}
+
+			return lines;
+		},
+		invalidate() {},
+	};
+}
+
+/** Render Exa call (query/args preview) */
+export function renderExaCall(args: Record<string, unknown>, toolName: string, uiTheme: Theme): Component {
+	const toolLabel = toolName || "Exa Search";
+	const numResults = typeof args.num_results === "number" ? args.num_results : undefined;
+
+	return {
+		render(width: number): string[] {
+			const query = typeof args.query === "string" ? truncateToWidth(args.query, Math.max(20, width - 30)) : "?";
+			let text = `${uiTheme.fg("toolTitle", toolLabel)} ${uiTheme.fg("contentAccent", query)}`;
+			if (numResults !== undefined) {
+				text += ` ${uiTheme.fg("muted", `results:${numResults}`)}`;
+			}
+			return [truncateToWidth(text, width)];
+		},
+		invalidate() {},
+	};
+}

package/src/exa/researcher.ts

@@ -0,0 +1,47 @@
+/**
+ * Exa Researcher Tools
+ *
+ * Async research tasks with polling for completion.
+ */
+import { Type } from "@sinclair/typebox";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import { createExaTool } from "./factory";
+import type { ExaRenderDetails } from "./types";
+
+const researcherStartTool = createExaTool(
+	"exa_researcher_start",
+	"Start Deep Research",
+	"Start an asynchronous deep research task using Exa's researcher. Returns a task_id for polling completion.",
+	Type.Object({
+		query: Type.String({ description: "Research query to investigate" }),
+		depth: Type.Optional(
+			Type.Number({
+				description: "Research depth (1-5, default: 3)",
+				minimum: 1,
+				maximum: 5,
+			}),
+		),
+		breadth: Type.Optional(
+			Type.Number({
+				description: "Research breadth (1-5, default: 3)",
+				minimum: 1,
+				maximum: 5,
+			}),
+		),
+	}),
+	"deep_researcher_start",
+	{ formatResponse: false },
+);
+
+const researcherPollTool = createExaTool(
+	"exa_researcher_poll",
+	"Poll Research Status",
+	"Poll the status of an asynchronous research task. Returns status (pending|running|completed|failed) and result if completed.",
+	Type.Object({
+		task_id: Type.String({ description: "Task ID returned from exa_researcher_start" }),
+	}),
+	"deep_researcher_check",
+	{ formatResponse: false },
+);
+
+export const researcherTools: CustomTool<any, ExaRenderDetails>[] = [researcherStartTool, researcherPollTool];

package/src/exa/search.ts

@@ -0,0 +1,86 @@
+/**
+ * Exa Search Tools
+ *
+ * Basic neural/keyword search, deep research, code search, and URL crawling.
+ */
+
+import { StringEnum } from "@f5xc-salesdemos/pi-ai";
+import { Type } from "@sinclair/typebox";
+import type { CustomTool } from "../extensibility/custom-tools/types";
+import { createExaTool } from "./factory";
+import type { ExaRenderDetails } from "./types";
+
+/** exa_search - Basic neural/keyword search */
+const exaSearchTool = createExaTool(
+	"exa_search",
+	"Exa Search",
+	`Search the web using Exa's neural or keyword search.
+
+Returns structured search results with optional text content and highlights.
+
+Parameters:
+- query: Search query (required)
+- type: Search type - "neural" (semantic), "keyword" (exact), or "auto" (default: auto)
+- include_domains: Array of domains to include in results
+- exclude_domains: Array of domains to exclude from results
+- start_published_date: Filter results published after this date (ISO 8601)
+- end_published_date: Filter results published before this date (ISO 8601)
+- use_autoprompt: Let Exa optimize your query automatically (default: true)
+- text: Include page text content in results (default: false, costs more)
+- highlights: Include highlighted relevant snippets (default: false)
+- num_results: Maximum number of results to return (default: 10, max: 100)`,
+
+	Type.Object({
+		query: Type.String({ description: "Search query" }),
+		type: Type.Optional(
+			StringEnum(["keyword", "neural", "auto"], {
+				description: "Search type - neural (semantic), keyword (exact), or auto",
+			}),
+		),
+		include_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Only include results from these domains",
+			}),
+		),
+		exclude_domains: Type.Optional(
+			Type.Array(Type.String(), {
+				description: "Exclude results from these domains",
+			}),
+		),
+		start_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published after this date (ISO 8601 format)",
+			}),
+		),
+		end_published_date: Type.Optional(
+			Type.String({
+				description: "Filter results published before this date (ISO 8601 format)",
+			}),
+		),
+		use_autoprompt: Type.Optional(
+			Type.Boolean({
+				description: "Let Exa optimize your query automatically (default: true)",
+			}),
+		),
+		text: Type.Optional(
+			Type.Boolean({
+				description: "Include page text content in results (costs more, default: false)",
+			}),
+		),
+		highlights: Type.Optional(
+			Type.Boolean({
+				description: "Include highlighted relevant snippets (default: false)",
+			}),
+		),
+		num_results: Type.Optional(
+			Type.Number({
+				description: "Maximum number of results to return (default: 10, max: 100)",
+				minimum: 1,
+				maximum: 100,
+			}),
+		),
+	}),
+	"web_search_exa",
+);
+
+export const searchTools: CustomTool<any, ExaRenderDetails>[] = [exaSearchTool];