oh-my-opencode 4.10.0 → 4.11.0

package/packages/lsp-core/src/tools/definitions.ts

@@ -0,0 +1,141 @@
+import { executeLspDiagnostics } from "./diagnostics.js";
+import { executeLspInstallDecision } from "./install-decision.js";
+import { executeLspFindReferences, executeLspGotoDefinition } from "./navigation.js";
+import { executeLspPrepareRename, executeLspRename } from "./rename.js";
+import { objectSchema } from "./schema.js";
+import { executeLspStatus } from "./status.js";
+import { executeLspSymbols } from "./symbols.js";
+import type { LspMcpTool } from "./types.js";
+
+export const LSP_MCP_TOOLS: LspMcpTool[] = [
+	{
+		name: "status",
+		aliases: ["lsp_status"],
+		title: "LSP Status",
+		description: "List configured and active LSP servers without starting a new language server.",
+		inputSchema: objectSchema({}),
+		execute: executeLspStatus,
+	},
+	{
+		name: "diagnostics",
+		aliases: ["lsp_diagnostics"],
+		title: "LSP Diagnostics",
+		description: "Get errors, warnings, and hints for a source file or directory.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "File or directory path to check." },
+				severity: {
+					type: "string",
+					enum: ["error", "warning", "information", "hint", "all"],
+					description: "Severity filter. Defaults to all.",
+				},
+			},
+			["filePath"],
+		),
+		execute: executeLspDiagnostics,
+	},
+	{
+		name: "goto_definition",
+		aliases: ["lsp_goto_definition"],
+		title: "LSP Goto Definition",
+		description: "Find where a symbol is defined.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspGotoDefinition,
+	},
+	{
+		name: "find_references",
+		aliases: ["lsp_find_references"],
+		title: "LSP Find References",
+		description: "Find references of a symbol across the workspace.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file containing the symbol." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				includeDeclaration: { type: "boolean", description: "Include the declaration. Defaults to true." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspFindReferences,
+	},
+	{
+		name: "symbols",
+		aliases: ["lsp_symbols"],
+		title: "LSP Symbols",
+		description: "List document symbols or search workspace symbols.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "File path used as LSP context." },
+				scope: {
+					type: "string",
+					enum: ["document", "workspace"],
+					description: "Use document for file outline or workspace for project-wide search.",
+				},
+				query: { type: "string", description: "Workspace symbol query." },
+				limit: { type: "number", description: "Maximum number of symbols to return." },
+			},
+			["filePath", "scope"],
+		),
+		execute: executeLspSymbols,
+	},
+	{
+		name: "prepare_rename",
+		aliases: ["lsp_prepare_rename"],
+		title: "LSP Prepare Rename",
+		description: "Check whether a symbol can be renamed at a position.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+			},
+			["filePath", "line", "character"],
+		),
+		execute: executeLspPrepareRename,
+	},
+	{
+		name: "rename",
+		aliases: ["lsp_rename"],
+		title: "LSP Rename",
+		description: "Rename a symbol across the workspace and apply the returned workspace edit.",
+		inputSchema: objectSchema(
+			{
+				filePath: { type: "string", description: "Source file path." },
+				line: { type: "number", description: "1-based line number." },
+				character: { type: "number", description: "0-based column." },
+				newName: { type: "string", description: "New symbol name." },
+			},
+			["filePath", "line", "character", "newName"],
+		),
+		execute: executeLspRename,
+	},
+	{
+		name: "install_decision",
+		aliases: ["lsp_install_decision"],
+		title: "LSP Install Decision",
+		description:
+			"Record whether the user allowed or declined installing a missing LSP server. Record 'declined' when the user declines, or has not explicitly asked for LSP installation, to silence future prompts.",
+		inputSchema: objectSchema(
+			{
+				server_id: {
+					type: "string",
+					description: "The LSP server id from the not-installed message (e.g. 'rust').",
+				},
+				decision: {
+					type: "string",
+					enum: ["declined", "allowed"],
+					description: "'declined' silences future prompts; 'allowed' pre-authorizes installation.",
+				},
+			},
+			["server_id", "decision"],
+		),
+		execute: executeLspInstallDecision,
+	},
+];

package/packages/lsp-core/src/tools/diagnostics.ts

@@ -0,0 +1,97 @@
+import { resolve } from "node:path";
+
+import { isDirectoryPath, withLspClient } from "../lsp/client-wrapper.js";
+import { DEFAULT_MAX_DIAGNOSTICS } from "../lsp/constants.js";
+import { aggregateDiagnosticsForDirectory } from "../lsp/directory-diagnostics.js";
+import { filterDiagnosticsBySeverity, formatDiagnostic } from "../lsp/formatters.js";
+import { inferExtensionFromDirectory } from "../lsp/infer-extension.js";
+import type { Diagnostic } from "../lsp/types.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { contextCwd } from "../request-context.js";
+import { clientOptions, requireString, severityFilter } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspDiagnosticsDetails, ToolExecutionResult } from "./types.js";
+
+function asDiagnosticArray(result: { items?: Diagnostic[] } | Diagnostic[] | null | undefined): Diagnostic[] {
+	if (!result) return [];
+	if (Array.isArray(result)) return result;
+	return result.items ?? [];
+}
+
+export async function executeLspDiagnostics(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const severity = severityFilter(params);
+
+	try {
+		const absPath = resolve(contextCwd(), filePath);
+		if (isDirectoryPath(absPath)) {
+			const extension = inferExtensionFromDirectory(absPath);
+			if (!extension) {
+				const message = `No supported source files found in directory: ${absPath}`;
+				const details: LspDiagnosticsDetails = {
+					filePath,
+					severity,
+					mode: "directory",
+					diagnostics: [],
+					totalDiagnostics: 0,
+					truncated: false,
+					error: message,
+					errorKind: "no_files",
+				};
+				return text(message, details);
+			}
+
+			const output = await aggregateDiagnosticsForDirectory(absPath, extension, severity);
+			const details: LspDiagnosticsDetails = {
+				filePath,
+				severity,
+				mode: "directory",
+				diagnostics: [],
+				totalDiagnostics: 0,
+				truncated: false,
+			};
+			return text(output, details);
+		}
+
+		const result = await withLspClient(
+			filePath,
+			async (client) => client.diagnostics(filePath),
+			"diagnostics",
+			clientOptions(signal),
+		);
+		const diagnostics = filterDiagnosticsBySeverity(asDiagnosticArray(result), severity);
+		const total = diagnostics.length;
+		const truncated = total > DEFAULT_MAX_DIAGNOSTICS;
+		const limited = truncated ? diagnostics.slice(0, DEFAULT_MAX_DIAGNOSTICS) : diagnostics;
+		const output =
+			total === 0
+				? "No diagnostics found"
+				: [
+						...(truncated ? [`Found ${total} diagnostics (showing first ${DEFAULT_MAX_DIAGNOSTICS}):`] : []),
+						...limited.map(formatDiagnostic),
+					].join("\n");
+		const details: LspDiagnosticsDetails = {
+			filePath,
+			severity,
+			mode: "file",
+			diagnostics: diagnostics.map((diagnostic) => ({ file: absPath, diagnostic })),
+			totalDiagnostics: total,
+			truncated,
+		};
+		return text(output, details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			severity,
+			mode: "file",
+			diagnostics: [],
+			totalDiagnostics: 0,
+			truncated: false,
+		} satisfies Omit<LspDiagnosticsDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

package/packages/lsp-core/src/tools/index.ts

@@ -0,0 +1,10 @@
+export { executeLspDiagnostics } from "./diagnostics.js";
+export { LSP_MCP_TOOLS } from "./definitions.js";
+export { executeLspInstallDecision } from "./install-decision.js";
+export { executeLspFindReferences, executeLspGotoDefinition } from "./navigation.js";
+export { isRecord } from "./parameters.js";
+export { executeLspPrepareRename, executeLspRename } from "./rename.js";
+export { executeLspStatus } from "./status.js";
+export { executeLspSymbols } from "./symbols.js";
+export type * from "./types.js";
+export { coerceToolArguments, executeLspTool } from "./runtime.js";

package/packages/lsp-core/src/tools/install-decision.ts

@@ -0,0 +1,39 @@
+import { getMergedServers } from "../lsp/config-loader.js";
+import { type InstallDecision, isInstallDecision, recordInstallDecision } from "../lsp/server-install-state.js";
+import { requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { ToolExecutionResult } from "./types.js";
+
+export async function executeLspInstallDecision(params: Record<string, unknown>): Promise<ToolExecutionResult> {
+	const serverId = requireString(params, "server_id");
+	const decision = params["decision"];
+	if (!isInstallDecision(decision)) {
+		return text(
+			`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`,
+			{ serverId, errorKind: "invalid_decision" },
+			true,
+		);
+	}
+
+	const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
+	if (!serverIds.includes(serverId)) {
+		const preview = serverIds.slice(0, 20).join(", ");
+		return text(
+			`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`,
+			{ serverId, errorKind: "unknown_server" },
+			true,
+		);
+	}
+
+	recordInstallDecision(serverId, decision);
+	return text(`Recorded install decision for '${serverId}': ${decision}. ${decisionFollowUp(decision)}`, {
+		serverId,
+		decision,
+	});
+}
+
+function decisionFollowUp(decision: InstallDecision): string {
+	return decision === "declined"
+		? "Future LSP lookups for this server stay quiet; proceed without LSP."
+		: "Future LSP lookups keep install instructions without asking the user.";
+}

package/packages/lsp-core/src/tools/navigation.ts

@@ -0,0 +1,86 @@
+import { DEFAULT_MAX_REFERENCES } from "../lsp/constants.js";
+import { formatLocation } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, optionalBoolean, requireNumber, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspFindReferencesDetails, LspGotoDefinitionDetails, ToolExecutionResult } from "./types.js";
+
+export async function executeLspGotoDefinition(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+
+	try {
+		const result = await withLspClient(
+			filePath,
+			async (client) => client.definition(filePath, line, character),
+			"definition",
+			clientOptions(signal),
+		);
+		const locations = !result ? [] : Array.isArray(result) ? result : [result];
+		const details: LspGotoDefinitionDetails = { filePath, line, character, locations };
+		if (locations.length === 0) return text("No definition found", details);
+		return text(locations.map(formatLocation).join("\n"), details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			locations: [],
+		} satisfies Omit<LspGotoDefinitionDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+export async function executeLspFindReferences(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+	const includeDeclaration = optionalBoolean(params, "includeDeclaration") ?? true;
+
+	try {
+		const result = await withLspClient(
+			filePath,
+			async (client) => client.references(filePath, line, character, includeDeclaration),
+			"references",
+			clientOptions(signal),
+		);
+		const references = Array.isArray(result) ? result : [];
+		const total = references.length;
+		const truncated = total > DEFAULT_MAX_REFERENCES;
+		const limited = truncated ? references.slice(0, DEFAULT_MAX_REFERENCES) : references;
+		const details: LspFindReferencesDetails = {
+			filePath,
+			line,
+			character,
+			references,
+			totalReferences: total,
+			truncated,
+		};
+		if (total === 0) return text("No references found", details);
+		const output = [
+			...(truncated ? [`Found ${total} references (showing first ${DEFAULT_MAX_REFERENCES}):`] : []),
+			...limited.map(formatLocation),
+		].join("\n");
+		return text(output, details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			references: [],
+			totalReferences: 0,
+			truncated: false,
+		} satisfies Omit<LspFindReferencesDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

package/packages/lsp-core/src/tools/parameters.ts

@@ -0,0 +1,49 @@
+import type { WithLspClientOptions } from "../lsp/client-wrapper.js";
+import type { SeverityFilter } from "../lsp/types.js";
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function requireString(params: Record<string, unknown>, key: string): string {
+	const value = params[key];
+	if (typeof value !== "string" || value.length === 0) {
+		throw new Error(`Missing required string parameter '${key}'`);
+	}
+	return value;
+}
+
+export function optionalString(params: Record<string, unknown>, key: string): string | undefined {
+	const value = params[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+export function requireNumber(params: Record<string, unknown>, key: string): number {
+	const value = params[key];
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		throw new Error(`Missing required number parameter '${key}'`);
+	}
+	return value;
+}
+
+export function optionalNumber(params: Record<string, unknown>, key: string): number | undefined {
+	const value = params[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function optionalBoolean(params: Record<string, unknown>, key: string): boolean | undefined {
+	const value = params[key];
+	return typeof value === "boolean" ? value : undefined;
+}
+
+export function severityFilter(params: Record<string, unknown>): SeverityFilter {
+	const value = params["severity"];
+	if (value === "error" || value === "warning" || value === "information" || value === "hint" || value === "all") {
+		return value;
+	}
+	return "all";
+}
+
+export function clientOptions(signal: AbortSignal | undefined): WithLspClientOptions {
+	return signal === undefined ? {} : { signal };
+}

package/packages/lsp-core/src/tools/rename.ts

@@ -0,0 +1,72 @@
+import { formatApplyResult, formatPrepareRenameResult } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import { applyWorkspaceEdit } from "../lsp/workspace-edit.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, requireNumber, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspPrepareRenameDetails, LspRenameDetails, ToolExecutionResult } from "./types.js";
+
+export async function executeLspPrepareRename(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+
+	try {
+		const result = await withLspClient(
+			filePath,
+			async (client) => client.prepareRename(filePath, line, character),
+			"prepareRename",
+			clientOptions(signal),
+		);
+		const details: LspPrepareRenameDetails = { filePath, line, character, result };
+		return text(formatPrepareRenameResult(result), details);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			result: null,
+		} satisfies Omit<LspPrepareRenameDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+export async function executeLspRename(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const line = requireNumber(params, "line");
+	const character = requireNumber(params, "character");
+	const newName = requireString(params, "newName");
+
+	try {
+		const edit = await withLspClient(
+			filePath,
+			async (client, workspaceRoot) => ({
+				edit: await client.rename(filePath, line, character, newName),
+				workspaceRoot,
+			}),
+			"rename",
+			clientOptions(signal),
+		);
+		const apply = applyWorkspaceEdit(edit.edit, { workspaceRoot: edit.workspaceRoot });
+		const details: LspRenameDetails = { filePath, line, character, newName, apply, edit: edit.edit };
+		return text(formatApplyResult(apply), details, !apply.success);
+	} catch (error) {
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			line,
+			character,
+			newName,
+			apply: null,
+			edit: null,
+		} satisfies Omit<LspRenameDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}

package/packages/lsp-core/src/tools/result.ts

@@ -0,0 +1,5 @@
+import type { ToolExecutionResult } from "./types.js";
+
+export function text(text: string, details?: unknown, isError = false): ToolExecutionResult {
+	return { content: [{ type: "text", text }], details, isError };
+}

package/packages/lsp-core/src/tools/runtime.ts

@@ -0,0 +1,21 @@
+import { LSP_MCP_TOOLS } from "./definitions.js";
+import { isRecord } from "./parameters.js";
+import type { LspMcpTool, ToolExecutionResult } from "./types.js";
+
+export async function executeLspTool(
+	name: string,
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const tool = LSP_MCP_TOOLS.find((candidate) => matchesToolName(candidate, name));
+	if (!tool) throw new Error(`Unknown LSP tool: ${name}`);
+	return tool.execute(params, signal);
+}
+
+function matchesToolName(tool: LspMcpTool, name: string): boolean {
+	return tool.name === name || (tool.aliases?.includes(name) ?? false);
+}
+
+export function coerceToolArguments(value: unknown): Record<string, unknown> {
+	return isRecord(value) ? value : {};
+}

package/packages/lsp-core/src/tools/schema.ts

@@ -0,0 +1,9 @@
+import type { JsonSchema } from "./types.js";
+
+export function objectSchema(properties: Record<string, JsonSchema>, required: string[] = []): JsonSchema {
+	return {
+		type: "object",
+		properties,
+		required,
+	};
+}

package/packages/lsp-core/src/tools/status.ts

@@ -0,0 +1,28 @@
+import { getLspManager } from "../lsp/manager.js";
+import { getAllServers } from "../lsp/server-resolution.js";
+import { text } from "./result.js";
+import type { ToolExecutionResult } from "./types.js";
+
+export async function executeLspStatus(): Promise<ToolExecutionResult> {
+	const servers = getAllServers();
+	const snapshots = getLspManager().getSnapshot();
+	const installed = servers.filter((server) => server.installed && !server.disabled);
+	const configuredLines = servers.map((server) => {
+		const state = server.disabled ? "disabled" : server.installed ? "installed" : "missing";
+		return `- ${server.id}: ${state}; source=${server.source}; extensions=${server.extensions.join(", ")}`;
+	});
+	const activeLines = snapshots.map((snapshot) => {
+		const state = snapshot.alive ? (snapshot.isInitializing ? "initializing" : "alive") : "dead";
+		return `- ${snapshot.serverId}: ${state}; root=${snapshot.root}; refs=${snapshot.refCount}`;
+	});
+	const lines = [
+		`Configured LSP servers: ${servers.length}`,
+		`Installed LSP servers: ${installed.length}`,
+		"",
+		...configuredLines,
+		"",
+		`Active LSP clients: ${snapshots.length}`,
+		...activeLines,
+	];
+	return text(lines.join("\n"), { servers, snapshots });
+}

package/packages/lsp-core/src/tools/symbols.ts

@@ -0,0 +1,99 @@
+import { DEFAULT_MAX_SYMBOLS } from "../lsp/constants.js";
+import { formatDocumentSymbol, formatSymbolInfo } from "../lsp/formatters.js";
+import { withLspClient } from "../lsp/client-wrapper.js";
+import type { DocumentSymbol, SymbolInfo } from "../lsp/types.js";
+import { missingDependencyResult } from "../missing-dependency-result.js";
+import { clientOptions, optionalNumber, optionalString, requireString } from "./parameters.js";
+import { text } from "./result.js";
+import type { LspSymbolsDetails, ToolExecutionResult } from "./types.js";
+
+function isDocumentSymbol(symbol: DocumentSymbol | SymbolInfo): symbol is DocumentSymbol {
+	return "range" in symbol;
+}
+
+export async function executeLspSymbols(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+): Promise<ToolExecutionResult> {
+	const filePath = requireString(params, "filePath");
+	const rawScope = optionalString(params, "scope") ?? "document";
+	const scope = rawScope === "workspace" ? "workspace" : "document";
+	const limit = Math.min(optionalNumber(params, "limit") ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS);
+
+	try {
+		if (scope === "workspace") {
+			const query = optionalString(params, "query");
+			if (!query) {
+				const message = "Error: 'query' is required for workspace scope";
+				return text(message, {
+					filePath,
+					scope,
+					symbols: [],
+					totalSymbols: 0,
+					truncated: false,
+					error: message,
+					errorKind: "missing_query",
+				});
+			}
+
+			const symbols = await withLspClient(
+				filePath,
+				async (client) => client.workspaceSymbols(query),
+				"workspaceSymbols",
+				clientOptions(signal),
+			);
+			return formatSymbolsResult(filePath, scope, symbols, limit, query);
+		}
+
+		const symbols = await withLspClient(
+			filePath,
+			async (client) => client.documentSymbols(filePath),
+			"documentSymbols",
+			clientOptions(signal),
+		);
+		return formatSymbolsResult(filePath, scope, symbols, limit);
+	} catch (error) {
+		const query = optionalString(params, "query");
+		const missingDependency = missingDependencyResult(error, {
+			filePath,
+			scope,
+			symbols: [],
+			totalSymbols: 0,
+			truncated: false,
+			...(query === undefined ? {} : { query }),
+		} satisfies Omit<LspSymbolsDetails, "error" | "errorKind">);
+		if (missingDependency) return missingDependency;
+		throw error;
+	}
+}
+
+function formatSymbolsResult(
+	filePath: string,
+	scope: "document" | "workspace",
+	symbols: Array<DocumentSymbol | SymbolInfo>,
+	limit: number,
+	query?: string,
+): ToolExecutionResult {
+	const total = symbols.length;
+	const truncated = total > limit;
+	const limited = truncated ? symbols.slice(0, limit) : symbols;
+	const details: LspSymbolsDetails = {
+		filePath,
+		scope,
+		symbols,
+		totalSymbols: total,
+		truncated,
+		...(query === undefined ? {} : { query }),
+	};
+	if (total === 0) return text("No symbols found", details);
+
+	const lines: string[] = [];
+	if (truncated) lines.push(`Found ${total} symbols (showing first ${limit}):`);
+	const documentSymbols = limited.filter(isDocumentSymbol);
+	if (documentSymbols.length === limited.length) {
+		lines.push(...documentSymbols.map((symbol) => formatDocumentSymbol(symbol)));
+	} else {
+		lines.push(...limited.filter((symbol): symbol is SymbolInfo => !isDocumentSymbol(symbol)).map(formatSymbolInfo));
+	}
+	return text(lines.join("\n"), details);
+}