@gajae-code/coding-agent 0.9.0 → 0.9.1

package/src/prompts/tools/search-tool-bm25.md

@@ -21,3 +21,8 @@ Returns JSON with:
 - `activated_tools` — tools activated by this search call
 - `match_count` — number of ranked matches returned by the search
 - `total_tools`
+
+Match details include:
+- `server_name` — MCP server name when the activated result is an MCP tool
+- `mcp_tool_name` — original MCP tool name when applicable
+- `schema_keys` — searchable input property names

package/src/sdk.ts

@@ -121,7 +121,12 @@ import {
 } from "./system-prompt";
 import { AgentOutputManager } from "./task/output-manager";
 import { parseThinkingLevel, resolveThinkingLevelForModel, toReasoningEffort } from "./thinking";
-import { collectDiscoverableTools, type DiscoverableTool } from "./tool-discovery/tool-index";
+import {
+	collectDiscoverableTools,
+	type DiscoverableTool,
+	isMCPBridgeTool,
+	isMCPToolName,
+} from "./tool-discovery/tool-index";
 import {
 	applyConfiguredSearchTimeout,
 	BashTool,
@@ -1789,7 +1794,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 							{ source: "builtin" },
 						)
 					: [];
-			const discoverableToolsForDesc: DiscoverableTool[] = [...discoverableBuiltinTools];
+			const discoverableMCPTools: DiscoverableTool[] = mcpDiscoveryEnabled
+				? collectDiscoverableTools(
+						Array.from(tools.values()).filter(
+							tool => isMCPToolName(tool.name) && !activeToolNames.has(tool.name),
+						),
+						{ source: "mcp" },
+					)
+				: [];
+			const discoverableToolsForDesc: DiscoverableTool[] = [...discoverableBuiltinTools, ...discoverableMCPTools];
 			const promptTools = buildSystemPromptToolMetadata(tools, {
 				search_tool_bm25: { description: renderSearchToolBm25Description(discoverableToolsForDesc) },
 			});
@@ -1838,8 +1851,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				intentField,
 				mcpDiscoveryMode: false,
 				mcpDiscoveryServerSummaries: [],
-				toolDiscoveryActive: effectiveDiscoveryMode === "all",
-				discoverableTools: discoverableBuiltinTools
+				toolDiscoveryActive: effectiveDiscoveryMode === "all" || mcpDiscoveryEnabled,
+				discoverableTools: [...discoverableBuiltinTools, ...discoverableMCPTools]
 					.map(tool => ({ name: tool.name, summary: tool.summary }))
 					.sort((a, b) => a.name.localeCompare(b.name)),
 				eagerTasks,
@@ -1870,11 +1883,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			: toolNamesFromRegistry;
 		const normalizedRequested = requestedToolNames.filter(name => toolRegistry.has(name));
 		const requestedToolNameSet = new Set(normalizedRequested);
-		// Effective discovery mode only covers built-in tools; MCP tool discovery
-		// is quarantined from the GJC public surface.
+		// Generic tool discovery hides non-essential built-ins behind search_tool_bm25.
+		// Legacy MCP discovery remains separately controlled by mcp.discoveryMode so
+		// loaded MCP catalogs can be searched without enabling every hidden built-in.
 		const toolsDiscoveryModeSetting = settings.get("tools.discoveryMode");
 		const effectiveDiscoveryMode: "off" | "all" = toolsDiscoveryModeSetting === "all" ? "all" : "off";
-		const mcpDiscoveryEnabled = false;
+		const mcpDiscoveryEnabled = settings.get("mcp.discoveryMode") === true;
 		const defaultInactiveToolNames = new Set(
 			registeredTools.filter(tool => tool.definition.defaultInactive).map(tool => tool.definition.name),
 		);
@@ -1887,6 +1901,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const discoveryDefaultServerToolNames: string[] = [];
 		let initialSelectedMCPToolNames: string[] = [];
 		let defaultSelectedMCPToolNames: string[] = [];
+		if (mcpDiscoveryEnabled) {
+			const defaultServerNames = new Set(settings.get("mcp.discoveryDefaultServers") ?? []);
+			for (const tool of toolRegistry.values()) {
+				if (!isMCPBridgeTool(tool)) continue;
+				discoverableMCPToolNames.add(tool.name);
+				if (initialRequestedActiveToolNames.includes(tool.name)) {
+					explicitlyRequestedMCPToolNames.push(tool.name);
+				}
+				const serverName = (tool as AgentTool & { mcpServerName?: string }).mcpServerName;
+				if (serverName && defaultServerNames.has(serverName)) {
+					discoveryDefaultServerToolNames.push(tool.name);
+				}
+			}
+		}
 		let initialToolNames = [...initialRequestedActiveToolNames];
 		if (mcpDiscoveryEnabled) {
 			const restoredSelectedMCPToolNames = existingSession.selectedMCPToolNames.filter(name =>
@@ -2247,7 +2275,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			initialSelectedMCPToolNames,
 			defaultSelectedMCPToolNames,
 			persistInitialMCPToolSelection: !hasExistingSession,
-			defaultSelectedMCPServerNames: [],
+			defaultSelectedMCPServerNames: settings.get("mcp.discoveryDefaultServers") ?? [],
 			ttsrManager,
 			obfuscator,
 			agentId: resolvedAgentId,

package/src/session/agent-session.ts

@@ -1786,7 +1786,7 @@ export class AgentSession {
 					high = mid - 1;
 				}
 			}
-			return { message: bestMessage, tokens: Math.min(bestTokens, maxTokens) };
+			return { message: bestMessage, tokens: bestTokens };
 		};
 
 		for (let i = providerMessages.length - 1; i >= 0; i--) {
@@ -1806,9 +1806,11 @@ export class AgentSession {
 				recordSkip("token-limit");
 				if (selected.length === 0) {
 					const truncated = truncateMessageToTokenBudget(sanitized);
-					selected.unshift(truncated.message);
-					approximateTokens = truncated.tokens;
-					skippedReasons["newest-message-truncated"] = (skippedReasons["newest-message-truncated"] ?? 0) + 1;
+					if (truncated.tokens <= maxTokens) {
+						selected.unshift(truncated.message);
+						approximateTokens = truncated.tokens;
+						skippedReasons["newest-message-truncated"] = (skippedReasons["newest-message-truncated"] ?? 0) + 1;
+					}
 				}
 				break;
 			}

package/src/slash-commands/builtin-registry.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ThinkingLevel } from "@gajae-code/agent-core";
+import { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, modelsAreEqual } from "@gajae-code/ai";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import { Spacer, Text } from "@gajae-code/tui";
@@ -379,6 +379,60 @@ function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: st
 		.join("\n\n");
 }
 
+const EFFORT_COMMAND_INPUT_HINT = "[inherit|off|minimal|low|medium|high|xhigh|max]";
+const EFFORT_COMMAND_ACCEPTED_VALUES = ["inherit", "off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+function effortCommandUsage(prefix?: string): string {
+	return [prefix, `Usage: /effort ${EFFORT_COMMAND_INPUT_HINT}`]
+		.filter((line): line is string => Boolean(line))
+		.join("\n");
+}
+
+function formatEffortStatus(runtime: SlashCommandRuntime): string {
+	const current = runtime.session.thinkingLevel ?? ThinkingLevel.Off;
+	const configuredDefault = runtime.settings.get("defaultThinkingLevel");
+	const supported = runtime.session.getAvailableThinkingLevels();
+	return [
+		`Current effective effort: ${current}`,
+		`Configured default effort: ${configuredDefault}`,
+		`Accepted values: ${EFFORT_COMMAND_ACCEPTED_VALUES.join(", ")}`,
+		`Current-model supported levels: ${supported.length > 0 ? supported.join(", ") : "(none reported)"}`,
+	].join("\n");
+}
+
+async function handleEffortCommand(
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+): Promise<SlashCommandResult> {
+	const tokens = command.args.trim().split(/\s+/).filter(Boolean);
+	if (tokens.length === 0) {
+		await runtime.output(formatEffortStatus(runtime));
+		return commandConsumed();
+	}
+	if (tokens.length !== 1) {
+		return usage(effortCommandUsage("Invalid effort input."), runtime);
+	}
+
+	const requestedToken = tokens[0];
+	const requestedLevel = parseThinkingLevel(requestedToken);
+	if (!requestedToken || !requestedLevel) {
+		return usage(effortCommandUsage(`Invalid effort: ${tokens[0] ?? ""}.`), runtime);
+	}
+
+	const levelToApply =
+		requestedLevel === ThinkingLevel.Inherit ? runtime.settings.get("defaultThinkingLevel") : requestedLevel;
+	runtime.session.setThinkingLevel(levelToApply, false);
+	const effectiveLevel = runtime.session.thinkingLevel ?? ThinkingLevel.Off;
+	const requestedLabel =
+		requestedLevel === ThinkingLevel.Inherit ? `${requestedLevel} (${levelToApply})` : requestedLevel;
+	const clampedSuffix =
+		effectiveLevel === levelToApply ? "" : ` Requested ${levelToApply}; effective ${effectiveLevel}.`;
+	await runtime.output(
+		`Reasoning effort set to ${requestedLabel}. Effective effort: ${effectiveLevel}.${clampedSuffix}`,
+	);
+	return commandConsumed();
+}
+
 function refreshStatusLine(ctx: InteractiveModeContext): void {
 	ctx.statusLine.invalidate();
 	ctx.updateEditorTopBorder();
@@ -587,6 +641,29 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "effort",
+		description: "Show or set model reasoning effort",
+		acpDescription: "Show or set model reasoning effort",
+		inlineHint: EFFORT_COMMAND_INPUT_HINT,
+		acpInputHint: EFFORT_COMMAND_INPUT_HINT,
+		allowArgs: true,
+		handle: handleEffortCommand,
+		handleTui: async (command, runtime) => {
+			if (command.args.trim()) {
+				const result = await handleEffortCommand(command, toSlashCommandRuntime(runtime));
+				runtime.ctx.statusLine.invalidate();
+				runtime.ctx.updateEditorBorderColor();
+				runtime.ctx.updateEditorTopBorder();
+				runtime.ctx.editor.setText("");
+				runtime.ctx.ui.requestRender();
+				return result;
+			}
+
+			runtime.ctx.showEffortSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "fast",
 		description: "Toggle priority service tier (OpenAI service_tier=priority, Anthropic speed=fast)",

package/src/utils/pasted-image-path.ts

@@ -0,0 +1,170 @@
+/**
+ * Resolve pasted editor text to an image file path.
+ *
+ * Terminals insert a shell-escaped filesystem path when a file is drag-dropped
+ * onto them (e.g. macOS `Screenshot\ 2026-07-07\ at\ 11.06.38 PM.png`, where
+ * the visible "space" before AM/PM is U+202F and stays unescaped). When the
+ * entire paste is a single path to an existing image file, the interactive
+ * editor attaches the image and inserts an `[image N]` placeholder instead of
+ * leaving the raw path in the prompt.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const IMAGE_FILE_EXTENSION_PATTERN = /\.(?:png|jpe?g|gif|webp)$/i;
+
+export interface DecodePastedPathOptions {
+	/**
+	 * Platform whose path semantics apply when decoding (shell unescaping,
+	 * `file://` drive letters / UNC hosts). Defaults to `process.platform`;
+	 * injectable so tests can pin the win32 contract from any host.
+	 */
+	platform?: NodeJS.Platform;
+	/** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+	homedir?: string;
+}
+
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+	/** Base directory for relative paths. Defaults to `process.cwd()`. */
+	cwd?: string;
+}
+
+/**
+ * Convert a `file://` URI to a filesystem path for the given platform, or
+ * `undefined` when the URI is invalid.
+ *
+ * The production path (injected platform === host platform, always true
+ * outside tests) delegates to Node's `fileURLToPath`. When tests inject a
+ * foreign platform, a mirror of `fileURLToPath`'s rules is applied instead —
+ * Bun (1.3) accepts but ignores `fileURLToPath`'s `windows` option, so the
+ * native call cannot emulate a foreign platform.
+ */
+function decodeFileUrl(candidate: string, platform: NodeJS.Platform): string | undefined {
+	let url: URL;
+	try {
+		url = new URL(candidate);
+	} catch {
+		return undefined;
+	}
+	if (url.protocol !== "file:") return undefined;
+
+	if (platform === process.platform) {
+		try {
+			return fileURLToPath(url);
+		} catch {
+			return undefined;
+		}
+	}
+
+	// Foreign-platform mirror of fileURLToPath (tests only).
+	if (/%2f/i.test(url.pathname) || (platform === "win32" && /%5c/i.test(url.pathname))) return undefined;
+	let pathname: string;
+	try {
+		pathname = decodeURIComponent(url.pathname);
+	} catch {
+		return undefined;
+	}
+	if (platform === "win32") {
+		if (url.hostname && url.hostname !== "localhost") {
+			// UNC: file://server/share/img.png -> \\server\share\img.png
+			return `\\\\${url.hostname}${pathname.replaceAll("/", "\\")}`;
+		}
+		// Drive letter required: file:///C:/x -> C:\x
+		if (!/^\/[A-Za-z]:/.test(pathname)) return undefined;
+		return pathname.slice(1).replaceAll("/", "\\");
+	}
+	if (url.hostname && url.hostname !== "localhost") return undefined;
+	return pathname;
+}
+
+/**
+ * Decode pasted text into a filesystem path candidate. No filesystem access.
+ *
+ * Handles terminal drag-drop shell escaping (`\ `, `\(`, ...; skipped on
+ * win32 where `\` is the path separator), quoted paths, `file://` URIs
+ * (drive-letter, `file://localhost`, and UNC forms on win32), and `~/`
+ * expansion. Returns `undefined` when the text is empty, spans multiple
+ * lines, or is an invalid `file://` URI.
+ */
+export function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined {
+	const platform = options?.platform ?? process.platform;
+	let candidate = text.trim();
+	if (!candidate || /[\r\n]/.test(candidate)) return undefined;
+
+	// Quoted paths (some terminals quote instead of escaping).
+	if (
+		candidate.length >= 2 &&
+		(candidate.startsWith('"') || candidate.startsWith("'")) &&
+		candidate.endsWith(candidate[0])
+	) {
+		candidate = candidate.slice(1, -1);
+	}
+
+	if (candidate.startsWith("file://")) {
+		const decoded = decodeFileUrl(candidate, platform);
+		if (decoded === undefined) return undefined;
+		candidate = decoded;
+	} else if (platform !== "win32") {
+		// Terminal drag-drop escapes shell-special characters (`\ `, `\(`, ...).
+		// Skipped on Windows where `\` is the path separator.
+		candidate = candidate.replace(/\\(.)/g, "$1");
+	}
+
+	if (candidate.startsWith("~/")) {
+		candidate = path.join(options?.homedir ?? os.homedir(), candidate.slice(2));
+	}
+
+	return candidate;
+}
+
+/**
+ * Sniff the file header for a supported image signature (PNG, JPEG, GIF,
+ * WEBP). Prevents existing non-image files with image-looking extensions
+ * (e.g. a text file named `not-image.png`) from being treated as image
+ * candidates — consuming such a paste would lose the raw path when the
+ * image loader later rejects the content.
+ */
+function hasSupportedImageMagic(filePath: string): boolean {
+	let fd: number;
+	try {
+		fd = fs.openSync(filePath, "r");
+	} catch {
+		return false;
+	}
+	try {
+		// Zero-filled; short reads leave trailing zeros so comparisons fail safely.
+		const header = Buffer.alloc(12);
+		fs.readSync(fd, header, 0, 12, 0);
+		if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4e && header[3] === 0x47) return true; // PNG
+		if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) return true; // JPEG
+		const ascii6 = header.toString("latin1", 0, 6);
+		if (ascii6 === "GIF87a" || ascii6 === "GIF89a") return true; // GIF
+		if (header.toString("latin1", 0, 4) === "RIFF" && header.toString("latin1", 8, 12) === "WEBP") return true; // WEBP
+		return false;
+	} catch {
+		return false;
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+/**
+ * Returns the resolved path when the whole pasted text is a single path to an
+ * existing image file (verified by extension AND content signature),
+ * otherwise `undefined` (the paste is inserted as text).
+ */
+export function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined {
+	const candidate = decodePastedPathCandidate(text, options);
+	if (!candidate || !IMAGE_FILE_EXTENSION_PATTERN.test(candidate)) return undefined;
+
+	const resolved = path.resolve(options?.cwd ?? process.cwd(), candidate);
+	try {
+		if (!fs.statSync(resolved).isFile()) return undefined;
+	} catch {
+		return undefined;
+	}
+	if (!hasSupportedImageMagic(resolved)) return undefined;
+	return resolved;
+}