@f5xc-salesdemos/xcsh 17.2.0 → 17.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "17.2.0",
+	"version": "17.4.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "17.2.0",
-		"@f5xc-salesdemos/pi-agent-core": "17.2.0",
-		"@f5xc-salesdemos/pi-ai": "17.2.0",
-		"@f5xc-salesdemos/pi-natives": "17.2.0",
-		"@f5xc-salesdemos/pi-tui": "17.2.0",
-		"@f5xc-salesdemos/pi-utils": "17.2.0",
+		"@f5xc-salesdemos/xcsh-stats": "17.4.0",
+		"@f5xc-salesdemos/pi-agent-core": "17.4.0",
+		"@f5xc-salesdemos/pi-ai": "17.4.0",
+		"@f5xc-salesdemos/pi-natives": "17.4.0",
+		"@f5xc-salesdemos/pi-tui": "17.4.0",
+		"@f5xc-salesdemos/pi-utils": "17.4.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/cli/web-search-cli.ts

@@ -4,13 +4,14 @@
  * Handles `xcsh q`/`xcsh web-search` subcommands for testing web search providers.
  */
 
-import { APP_NAME } from "@f5xc-salesdemos/pi-utils";
+import { buildAnthropicSearchHeaders, buildAnthropicUrl, findAnthropicAuth } from "@f5xc-salesdemos/pi-ai";
+import { $env, APP_NAME } from "@f5xc-salesdemos/pi-utils";
 import chalk from "chalk";
 import { initTheme, theme } from "../modes/theme/theme";
 import { runSearchQuery, type SearchQueryParams } from "../web/search/index";
 import { SEARCH_PROVIDER_ORDER } from "../web/search/provider";
 import { renderSearchResult } from "../web/search/render";
-import type { SearchProviderId } from "../web/search/types";
+import type { SearchProviderId, SearchResponse } from "../web/search/types";
 
 export interface SearchCommandArgs {
 	query: string;
@@ -18,6 +19,8 @@ export interface SearchCommandArgs {
 	recency?: "day" | "week" | "month" | "year";
 	limit?: number;
 	expanded: boolean;
+	synthesize: boolean;
+	synthesizeModel?: string;
 }
 
 const PROVIDERS: Array<SearchProviderId | "auto"> = ["auto", ...SEARCH_PROVIDER_ORDER];
@@ -36,6 +39,7 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 	const result: SearchCommandArgs = {
 		query: "",
 		expanded: true,
+		synthesize: true,
 	};
 
 	const positional: string[] = [];
@@ -50,6 +54,10 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 			result.limit = Number.parseInt(args[++i], 10);
 		} else if (arg === "--compact") {
 			result.expanded = false;
+		} else if (arg === "--no-synthesize") {
+			result.synthesize = false;
+		} else if (arg === "--model") {
+			result.synthesizeModel = args[++i];
 		} else if (!arg.startsWith("-")) {
 			positional.push(arg);
 		}
@@ -62,6 +70,54 @@ export function parseSearchArgs(args: string[]): SearchCommandArgs | undefined {
 	return result;
 }
 
+async function synthesizeResponse(
+	query: string,
+	searchResponse: SearchResponse,
+	model?: string,
+): Promise<string | undefined> {
+	const auth = await findAnthropicAuth();
+	if (!auth) return undefined;
+
+	const sourcesContext = searchResponse.sources
+		.map((s, i) => `[${i + 1}] ${s.title}\n    ${s.url}${s.snippet ? `\n    ${s.snippet}` : ""}`)
+		.join("\n");
+
+	const citationsContext =
+		searchResponse.citations?.map((c, i) => `[${i + 1}] ${c.title}: "${c.citedText}"`).join("\n") ?? "";
+
+	const synthesisPrompt = `Based on the following web search results for the query "${query}", provide a comprehensive, well-structured answer. Cite sources by number.
+
+## Search Results
+${searchResponse.answer ? `### Initial Answer\n${searchResponse.answer}\n` : ""}
+### Sources
+${sourcesContext}
+${citationsContext ? `\n### Citations\n${citationsContext}` : ""}
+
+Provide a thorough answer with key facts, numbers, and source citations.`;
+
+	const url = buildAnthropicUrl(auth);
+	const headers = buildAnthropicSearchHeaders(auth);
+	const selectedModel = model ?? $env.ANTHROPIC_SEARCH_MODEL ?? "claude-haiku-4-5";
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			model: selectedModel,
+			max_tokens: 4096,
+			messages: [{ role: "user", content: synthesisPrompt }],
+		}),
+	});
+
+	if (!response.ok) return undefined;
+
+	const data = (await response.json()) as { content?: Array<{ type: string; text?: string }> };
+	return data.content
+		?.filter(b => b.type === "text" && b.text)
+		.map(b => b.text)
+		.join("\n\n");
+}
+
 export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	if (!cmd.query) {
 		process.stderr.write(`${chalk.red("Error: Query is required")}\n`);
@@ -104,6 +160,18 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 	const width = Math.max(60, process.stdout.columns ?? 100);
 	process.stdout.write(`${component.render(width).join("\n")}\n`);
 
+	if (cmd.synthesize && result.details?.response && result.details.response.sources.length > 0) {
+		try {
+			process.stderr.write(chalk.dim("\nSynthesizing response...\n"));
+			const synthesized = await synthesizeResponse(cmd.query, result.details.response, cmd.synthesizeModel);
+			if (synthesized) {
+				process.stdout.write(`\n${chalk.bold("Synthesized Answer:")}\n\n${synthesized}\n`);
+			}
+		} catch {
+			process.stderr.write(chalk.dim("Synthesis unavailable — showing raw search results only.\n"));
+		}
+	}
+
 	if (result.details?.error) {
 		process.exitCode = 1;
 	}
@@ -124,6 +192,8 @@ ${chalk.bold("Options:")}
   --recency <value>   Recency filter (Brave/Perplexity): ${RECENCY_OPTIONS.join(", ")}
   -l, --limit <n>     Max results to return
   --compact           Render condensed output
+  --no-synthesize     Skip synthesis step (raw search only)
+  --model <name>      Model for synthesis (default: ANTHROPIC_SEARCH_MODEL or claude-haiku-4-5)
   -h, --help          Show this help
 
 ${chalk.bold("Examples:")}

package/src/commands/web-search.ts

@@ -23,6 +23,8 @@ export default class Search extends Command {
 		recency: Flags.string({ description: "Recency filter", options: RECENCY }),
 		limit: Flags.integer({ char: "l", description: "Max results to return" }),
 		compact: Flags.boolean({ description: "Render condensed output" }),
+		"no-synthesize": Flags.boolean({ description: "Skip synthesis step (raw search only)" }),
+		model: Flags.string({ description: "Model for synthesis (default: claude-haiku-4-5)" }),
 	};
 
 	async run(): Promise<void> {
@@ -35,6 +37,8 @@ export default class Search extends Command {
 			recency: flags.recency as SearchCommandArgs["recency"],
 			limit: flags.limit,
 			expanded: !flags.compact,
+			synthesize: !flags["no-synthesize"],
+			synthesizeModel: flags.model,
 		};
 
 		await runSearchCommand(cmd);

package/src/config/settings-schema.ts

@@ -1313,6 +1313,15 @@ export const SETTINGS_SCHEMA = {
 		default: true,
 		ui: { tab: "tools", label: "Web Search", description: "Enable the web_search tool for web searching" },
 	},
+	"web_search.verbose": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Web Search Verbose",
+			description: "Show detailed search panels (sources, metadata, tokens). When disabled, uses compact output.",
+		},
+	},
 
 	"browser.enabled": {
 		type: "boolean",

package/src/web/search/index.ts

@@ -168,9 +168,10 @@ async function executeSearch(
 	_toolCallId: string,
 	params: SearchQueryParams,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
-	const hasDomainFilter = params.allowed_domains?.length || params.blocked_domains?.length;
+	const hasAnthropicOnlyParams =
+		params.allowed_domains?.length || params.blocked_domains?.length || params.max_uses || params.user_location;
 	const effectiveProvider =
-		hasDomainFilter && (!params.provider || params.provider === "auto") ? "anthropic" : params.provider;
+		hasAnthropicOnlyParams && (!params.provider || params.provider === "auto") ? "anthropic" : params.provider;
 	const providers =
 		effectiveProvider && effectiveProvider !== "auto"
 			? (await getSearchProvider(effectiveProvider).isAvailable())
@@ -191,6 +192,7 @@ async function executeSearch(
 	for (const provider of providers) {
 		lastProvider = provider;
 		try {
+			const searchStart = performance.now();
 			const response = await provider.search({
 				query: params.query.replace(/202\d/g, String(new Date().getFullYear())), // LUL
 				limit: params.limit,
@@ -204,6 +206,7 @@ async function executeSearch(
 				maxUses: params.max_uses,
 				userLocation: params.user_location,
 			});
+			response.durationMs = performance.now() - searchStart;
 
 			const text = formatForLLM(response);
 

package/src/web/search/providers/anthropic.ts

@@ -27,6 +27,7 @@ import { SearchProvider } from "./base";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
 const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_MAX_USES = 8;
 const WEB_SEARCH_TOOL_NAME = "web_search";
 const WEB_SEARCH_TOOL_TYPE = "web_search_20250305";
 
@@ -132,7 +133,7 @@ async function callSearch(
 	};
 	if (toolConfig?.allowed_domains?.length) tool.allowed_domains = toolConfig.allowed_domains;
 	if (toolConfig?.blocked_domains?.length) tool.blocked_domains = toolConfig.blocked_domains;
-	if (toolConfig?.max_uses) tool.max_uses = toolConfig.max_uses;
+	tool.max_uses = toolConfig?.max_uses ?? DEFAULT_MAX_USES;
 	if (toolConfig?.user_location) tool.user_location = toolConfig.user_location;
 
 	const body: Record<string, unknown> = {

package/src/web/search/render.ts

@@ -6,6 +6,7 @@
 
 import type { Component } from "@f5xc-salesdemos/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@f5xc-salesdemos/pi-tui";
+import { Settings } from "../../config/settings";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import {
@@ -25,6 +26,14 @@ import { CachedOutputBlock } from "../../tui/output-block";
 import { getSearchProvider } from "./provider";
 import type { SearchResponse } from "./types";
 
+function getVerboseSetting(): boolean {
+	try {
+		return Settings.instance.get("web_search.verbose");
+	} catch {
+		return false;
+	}
+}
+
 const MAX_COLLAPSED_ANSWER_LINES = PREVIEW_LIMITS.COLLAPSED_LINES;
 const MAX_EXPANDED_ANSWER_LINES = PREVIEW_LIMITS.EXPANDED_LINES;
 const MAX_ANSWER_LINE_LEN = TRUNCATE_LENGTHS.LINE;
@@ -92,6 +101,20 @@ export function renderSearchResult(
 		return renderFallbackText(rawText, options.expanded, theme);
 	}
 
+	const verbose = getVerboseSetting();
+	if (!verbose) {
+		const searches = response.usage?.searchRequests ?? 1;
+		const plural = searches !== 1 ? "es" : "";
+		const dur =
+			response.durationMs !== undefined
+				? response.durationMs >= 1000
+					? `${Math.round(response.durationMs / 1000)}s`
+					: `${Math.round(response.durationMs)}ms`
+				: "";
+		const line = `  \u23BF  Did ${searches} search${plural}${dur ? ` in ${dur}` : ""}`;
+		return new Text(theme.fg("dim", line), 0, 0);
+	}
+
 	const sources = Array.isArray(response.sources) ? response.sources : [];
 	const sourceCount = sources.length;
 	const citations = Array.isArray(response.citations) ? response.citations : [];
@@ -288,6 +311,10 @@ export function renderSearchCall(
 	theme: Theme,
 ): Component {
 	const query = truncateToWidth(args.query ?? "", 80);
+	const verbose = getVerboseSetting();
+	if (!verbose) {
+		return new Text(`${theme.fg("text", `Web Search("${query}")`)}`, 0, 0);
+	}
 	const text = renderStatusLine({ icon: "pending", title: "Web Search", description: query }, theme);
 	return new Text(text, 0, 0);
 }

package/src/web/search/types.ts

@@ -94,6 +94,8 @@ export interface SearchResponse {
 	requestId?: string;
 	/** Authentication mode used by the provider (e.g. oauth, api-key) */
 	authMode?: string;
+	/** Wall-clock duration of the search request in milliseconds */
+	durationMs?: number;
 }
 
 /** Provider-specific error with optional HTTP status */