@gajae-code/coding-agent 0.17.1 → 0.17.4

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

@@ -3,8 +3,8 @@ import * as path from "node:path";
 import { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, modelsAreEqual } from "@gajae-code/ai/core";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
-import { PET_SKIN_IDS, PET_SKINS, type PetMode, Spacer, Text } from "@gajae-code/tui";
-import { setProjectDir } from "@gajae-code/utils";
+import { PET_SKIN_IDS, PET_SKINS, type PetMode, replaceTabs, Spacer, Text } from "@gajae-code/tui";
+import { sanitizeDisplayLine, setProjectDir } from "@gajae-code/utils";
 import { jobElapsedMs } from "../async";
 import { activateModelProfile, materializeActiveModelProfileAssignments } from "../config/model-profile-activation";
 import { formatModelProfileDisplayLabel } from "../config/model-profiles";
@@ -34,17 +34,28 @@ import { parseUiLanguage, resolveUiLanguage, UI_LANGUAGE_LABELS, UI_LANGUAGES, u
 // W1b/W5b: notification-service and daemon controllers stay off the static
 // import graph; the /notify handlers import them lazily at first use.
 import type { NotificationProvider } from "../sdk/bus/config";
+import type { AgentSession, ExactMcpStatusSnapshot } from "../session/agent-session";
 import { computeCacheMissCostSummary, formatCacheMissSummaryLines } from "../session/cache-economics";
 import { formatProviderSessionImportSummary, runSessionImportCommand } from "../session-import";
-import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
+import {
+	formatModelOnboardingGuidance,
+	MODEL_ONBOARDING_API_PROVIDER_COMMAND,
+} from "../setup/model-onboarding-guidance";
 import {
 	addApiCompatibleProvider,
 	formatProviderPresetList,
 	formatProviderSetupResult,
 	parseProviderCompatibility,
+	reloadAndRefreshDiscoveryCatalog,
 } from "../setup/provider-onboarding";
 import { parseThinkingLevel } from "../thinking";
 import { getDisplayChangelogEntries } from "../utils/changelog";
+import {
+	beginSessionTitleGeneration,
+	invalidateSessionTitleGeneration,
+	isSessionTitleGenerationCurrent,
+} from "../utils/session-title-generation";
+import { buildConversationTitleInput, generateSessionTitle } from "../utils/title-generator";
 import { handleAsideAcp } from "./helpers/aside";
 import { buildAutoroutingStatusReport } from "./helpers/autorouting-status";
 import { buildContextReportText } from "./helpers/context-report";
@@ -140,6 +151,44 @@ function toSlashCommandRuntime(runtime: TuiSlashCommandRuntime): SlashCommandRun
 	};
 }
 
+async function regenerateSessionTitle(runtime: SlashCommandRuntime): Promise<SlashCommandResult> {
+	try {
+		const generation = beginSessionTitleGeneration(runtime.sessionManager);
+		const input = buildConversationTitleInput(runtime.session.messages);
+		if (!input) {
+			return usage("Nothing to summarize yet — pass a title: /rename <title>", runtime);
+		}
+
+		const generated = await generateSessionTitle(
+			input,
+			runtime.session.modelRegistry,
+			runtime.settings,
+			runtime.session.credentialSessionId,
+			runtime.session.model,
+			provider => runtime.session.agent.metadataForProvider(provider),
+		);
+		if (
+			!isSessionTitleGenerationCurrent(runtime.sessionManager, generation) ||
+			buildConversationTitleInput(runtime.session.messages) !== input
+		)
+			return commandConsumed();
+		if (!generated) {
+			return usage("Could not generate a session title — pass one: /rename <title>", runtime);
+		}
+
+		const stored = await runtime.sessionManager.setSessionName(generated, "user");
+		if (!stored) {
+			await runtime.output("Session name not changed (a user-set name takes precedence).");
+			return commandConsumed();
+		}
+		await runtime.notifyTitleChanged?.();
+		await runtime.output(`Session renamed to ${generated}.`);
+		return commandConsumed();
+	} catch (err) {
+		return usage(`Rename failed: ${errorMessage(err)}`, runtime);
+	}
+}
+
 async function updateSessionStar(
 	starred: boolean,
 	command: ParsedSlashCommand,
@@ -171,6 +220,7 @@ function parseProviderSetupSlashArgs(args: string): {
 	apiKeyEnv?: string;
 	rejectedRawApiKey: boolean;
 	force: boolean;
+	discover: boolean;
 	models: string[];
 } {
 	const tokens = args.split(/\s+/).filter(Boolean);
@@ -182,9 +232,11 @@ function parseProviderSetupSlashArgs(args: string): {
 		apiKeyEnv?: string;
 		rejectedRawApiKey: boolean;
 		force: boolean;
+		discover: boolean;
 		models: string[];
 	} = {
 		force: false,
+		discover: false,
 		models: [],
 		rejectedRawApiKey: false,
 	};
@@ -194,6 +246,10 @@ function parseProviderSetupSlashArgs(args: string): {
 			result.force = true;
 			continue;
 		}
+		if (token === "--discover") {
+			result.discover = true;
+			continue;
+		}
 		if (!token.startsWith("-") && !result.preset) {
 			result.preset = token;
 			continue;
@@ -231,13 +287,43 @@ function providerSetupUsage(): string {
 		"Provider onboarding",
 		"Presets: /provider add --preset <id> [--force]",
 		"Aliases include minimax, zai, alibaba, cline, command-code, and goat.",
-		"API providers: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model> [--force]",
+		`API providers: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} [--force]`,
 		`Available presets:\n${formatProviderPresetList()}`,
 		"OAuth/subscription providers: /provider login [provider-id] or /login [provider-id]",
 		"Headless OAuth callbacks can be pasted with /login <redirect URL or code>.",
 	].join("\n");
 }
 
+function exactMcpDisplayName(name: string): string {
+	const sanitized = replaceTabs(sanitizeDisplayLine(name));
+	return sanitized || "<unnamed>";
+}
+
+function renderExactMcpStatus(snapshot: ExactMcpStatusSnapshot): string {
+	if (snapshot.servers.length === 0) {
+		return snapshot.startup === "no-servers-declared"
+			? "MCP servers: the config declares none."
+			: "MCP servers: not started yet.";
+	}
+	const servers = snapshot.servers.map(server => ({ ...server, name: exactMcpDisplayName(server.name) }));
+	// Server names and counts vary in width, so pad to the widest of each column;
+	// an unaligned table is unreadable once more than a couple of servers connect.
+	const nameWidth = Math.max(...servers.map(server => server.name.length));
+	const transportWidth = Math.max(...servers.map(server => server.transport.length));
+	const stateWidth = Math.max(...servers.map(server => server.state.length));
+	const countWidth = Math.max(...servers.map(server => String(server.toolCount).length));
+	const lines = [`MCP servers (${snapshot.startup}):`];
+	for (const server of servers) {
+		const count = String(server.toolCount).padStart(countWidth);
+		const unit = server.toolCount === 1 ? "tool" : "tools";
+		lines.push(
+			`  ${server.name.padEnd(nameWidth)}  ${server.transport.padEnd(transportWidth)}  ` +
+				`${server.state.padEnd(stateWidth)}  ${count} ${unit}`,
+		);
+	}
+	return lines.join("\n");
+}
+
 function formatModelAssignmentSummary(runtime: SlashCommandRuntime): string {
 	const agentModelOverrides = runtime.settings.get("task.agentModelOverrides");
 	const lines = ["Model assignments:"];
@@ -1619,6 +1705,121 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "mcp",
+		description: "Show MCP server status for this session",
+		allowArgs: true,
+		subcommands: [
+			{ name: "status", description: "Show MCP server status for this session" },
+			{ name: "list", description: "Alias for status" },
+			{ name: "suspend", description: "Suspend one server for this session" },
+			{ name: "resume", description: "Resume one suspended server" },
+			{ name: "reconnect", description: "Reconnect one server" },
+		],
+		// Exact MCP command surface yields its namespace without the exact capability: no `handle`, so the ACP dispatcher
+		// neither advertises nor routes it. Controls stay on the terminal surface.
+		handleTui: async (command, runtime) => {
+			// This builtin is installed statically, but the exact MCP capability is
+			// granted only to root interactive --mcp-config sessions. Preserve the
+			// pristine command namespace for every other session.
+			if (!runtime.ctx.session.hasExactMcpControls) return { prompt: command.text };
+			runtime.ctx.editor.setText("");
+			const args = command.args.trim() ? command.args.trim().split(/\s+/) : [];
+			const subcommand = args[0] ?? "";
+			// `list` is what every other MCP-capable tool calls this, so accept it
+			// rather than punishing the habit with an error.
+			if (
+				subcommand !== "" &&
+				subcommand !== "status" &&
+				subcommand !== "list" &&
+				subcommand !== "suspend" &&
+				subcommand !== "resume" &&
+				subcommand !== "reconnect"
+			) {
+				runtime.ctx.showError(
+					`Unknown subcommand: ${exactMcpDisplayName(subcommand)}. Usage: /mcp [status|list|suspend <name>|resume <name>|reconnect <name>]`,
+				);
+				return commandConsumed();
+			}
+			if (subcommand === "suspend" || subcommand === "resume" || subcommand === "reconnect") {
+				const name = args[1];
+				if (!name || args.length !== 2) {
+					runtime.ctx.showError(`Server name required. Usage: /mcp ${subcommand} <name>`);
+					return commandConsumed();
+				}
+				let result: Awaited<ReturnType<AgentSession["controlExactMcpServer"]>>;
+				try {
+					result = await runtime.ctx.session.controlExactMcpServer(subcommand, name);
+				} catch (error) {
+					if ((error as { code?: string } | undefined)?.code === "busy") {
+						runtime.ctx.showWarning(`MCP ${subcommand} is unavailable while this session is busy.`);
+						return commandConsumed();
+					}
+					runtime.ctx.showError(`MCP ${subcommand} failed.`);
+					return commandConsumed();
+				}
+				if (!result) {
+					runtime.ctx.showWarning(
+						"MCP controls are not available in this session. Start gjc with --mcp-config <absolute-path> to enable them.",
+					);
+					return commandConsumed();
+				}
+				const displayName = exactMcpDisplayName(result.name);
+				switch (result.status) {
+					case "suspended":
+						runtime.ctx.showStatus(`MCP server "${displayName}" suspended for this session.`);
+						break;
+					case "resumed":
+						runtime.ctx.showStatus(`MCP server "${displayName}" resumed (${result.toolCount} tools).`);
+						break;
+					case "reconnected":
+						runtime.ctx.showStatus(`MCP server "${displayName}" reconnected (${result.toolCount} tools).`);
+						break;
+					case "already-suspended":
+						runtime.ctx.showWarning(`MCP server "${displayName}" is already suspended.`);
+						break;
+					case "not-suspended":
+						runtime.ctx.showWarning(`MCP server "${displayName}" is not suspended.`);
+						break;
+					case "unknown-server":
+						runtime.ctx.showError(`Unknown MCP server: ${displayName}`);
+						break;
+					case "unavailable":
+						runtime.ctx.showError(
+							result.action === "resume"
+								? `MCP server "${displayName}" could not be resumed and remains suspended.`
+								: `MCP server "${displayName}" could not be reconnected.`,
+						);
+						break;
+				}
+				return commandConsumed();
+			}
+			if (args.length > 1) {
+				runtime.ctx.showError(`Usage: /mcp ${subcommand || "status"}`);
+				return commandConsumed();
+			}
+			let snapshot: Awaited<ReturnType<AgentSession["getExactMcpStatusSnapshot"]>>;
+			try {
+				snapshot = await runtime.ctx.session.getExactMcpStatusSnapshot();
+			} catch (error) {
+				if ((error as { code?: string } | undefined)?.code === "busy") {
+					runtime.ctx.showWarning(
+						"MCP status is unavailable while this session is busy. Try again once it settles.",
+					);
+					return commandConsumed();
+				}
+				throw error;
+			}
+			if (!snapshot) {
+				runtime.ctx.showWarning(
+					"MCP status is not available in this session. Start gjc with --mcp-config <absolute-path> to enable it.",
+				);
+				return commandConsumed();
+			}
+			runtime.ctx.showStatus(renderExactMcpStatus(snapshot));
+			return commandConsumed();
+		},
+	},
 	{
 		name: "agents",
 		description: "Open Agent Control Center dashboard",
@@ -1652,6 +1853,19 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "fork",
+		description: "Choose an earlier prompt to continue in a new session",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			if (command.args.trim()) {
+				runtime.ctx.showError("Usage: /fork");
+				return;
+			}
+			await runtime.ctx.handleForkCommand();
+		},
+	},
 
 	{
 		name: "provider",
@@ -1685,7 +1899,7 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			}
 			if (!parsed.preset) {
 				if (!parsed.apiKeyEnv) missing.push("--api-key-env");
-				if (parsed.models.length === 0) missing.push("--model");
+				if (parsed.models.length === 0 && !parsed.discover) missing.push("--model or --discover");
 			}
 			if (missing.length > 0) {
 				return usage(
@@ -1701,10 +1915,24 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 					baseUrl: parsed.baseUrl,
 					apiKeyEnv: parsed.apiKeyEnv,
 					models: parsed.models,
+					discover: parsed.discover,
 					force: parsed.force,
 				});
-				await runtime.session.modelRegistry.refresh("offline", runtime.session.credentialSessionId);
-				await runtime.output(formatProviderSetupResult(result));
+				let recoveryHint: string | null = null;
+				if (result.discoveryEnabled && !result.preset) {
+					recoveryHint = await reloadAndRefreshDiscoveryCatalog(
+						runtime.session.modelRegistry,
+						result.providerId,
+						runtime.session.credentialSessionId,
+					);
+				} else {
+					await runtime.session.modelRegistry.refresh("offline", runtime.session.credentialSessionId);
+				}
+				await runtime.output(
+					recoveryHint
+						? `${formatProviderSetupResult(result)}\n${recoveryHint}`
+						: formatProviderSetupResult(result),
+				);
 				await runtime.notifyConfigChanged?.();
 				return commandConsumed();
 			} catch (err) {
@@ -1742,10 +1970,25 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 						baseUrl: parsed.baseUrl,
 						apiKeyEnv: parsed.apiKeyEnv,
 						models: parsed.models,
+						discover: parsed.discover,
 						force: parsed.force,
+						authStorage: runtime.ctx.session.modelRegistry.authStorage,
 					});
-					await runtime.ctx.session.modelRegistry.refresh("offline", runtime.ctx.session.credentialSessionId);
-					runtime.ctx.showStatus(formatProviderSetupResult(result));
+					let recoveryHint: string | null = null;
+					if (result.discoveryEnabled && !result.preset) {
+						recoveryHint = await reloadAndRefreshDiscoveryCatalog(
+							runtime.ctx.session.modelRegistry,
+							result.providerId,
+							runtime.ctx.session.credentialSessionId,
+						);
+					} else {
+						await runtime.ctx.session.modelRegistry.refresh("offline", runtime.ctx.session.credentialSessionId);
+					}
+					runtime.ctx.showStatus(
+						recoveryHint
+							? `${formatProviderSetupResult(result)}\n${recoveryHint}`
+							: formatProviderSetupResult(result),
+					);
 				} catch (err) {
 					runtime.ctx.showError(`Provider setup failed: ${errorMessage(err)}`);
 				}
@@ -2134,11 +2377,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	},
 	{
 		name: "rename",
-		description: "Rename the current session",
-		inlineHint: "<title>",
+		description: "Rename the current session, or regenerate the title from the conversation",
+		inlineHint: "[title]",
 		allowArgs: true,
 		handle: async (command, runtime) => {
-			if (!command.args) return usage("Usage: /rename <title>", runtime);
+			if (!command.args) return regenerateSessionTitle(runtime);
+			invalidateSessionTitleGeneration(runtime.sessionManager);
 			const ok = await runtime.sessionManager.setSessionName(command.args, "user");
 			if (!ok) {
 				await runtime.output("Session name not changed (a user-set name takes precedence).");
@@ -2151,8 +2395,8 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		handleTui: async (command, runtime) => {
 			const title = command.args.trim();
 			if (!title) {
-				runtime.ctx.showError("Usage: /rename <title>");
 				runtime.ctx.editor.setText("");
+				await runtime.ctx.handleRenameCommand();
 				return;
 			}
 			runtime.ctx.editor.setText("");
@@ -2230,7 +2474,7 @@ export function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string):
 	return [
 		"Unknown slash command: /provicer.",
 		"Did you mean /provider?",
-		"Run: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>",
+		`Run: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}`,
 	].join("\n");
 }
 

package/src/task/index.ts

@@ -1786,13 +1786,25 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		const parentProfileDefinition = parentActiveModelProfile
 			? this.session.modelRegistry?.getModelProfile?.(parentActiveModelProfile)
 			: undefined;
+		const parentProfileBindings = parentProfileDefinition
+			? resolveProfileBindings(parentProfileDefinition)
+			: undefined;
+		const parentProfileBinding =
+			parentProfileBindings?.agentModelOverrides[
+				agentName as keyof typeof parentProfileBindings.agentModelOverrides
+			];
 		const parentOwnedModelProfile =
 			parentProfileDefinition &&
-			Object.hasOwn(resolveProfileBindings(parentProfileDefinition).agentModelOverrides, agentName)
+			parentProfileBindings &&
+			Object.hasOwn(parentProfileBindings.agentModelOverrides, agentName)
 				? parentActiveModelProfile
 				: undefined;
 		const modelOverride = resolveAgentModelPatterns({
-			settingsOverride: settingsModelOverride,
+			// Profile bindings are runtime-owned and may not be present in the
+			// persisted settings view exposed to detached task construction.
+			// Keep explicit task settings authoritative, then inherit the active
+			// profile's role binding before falling back to the parent model.
+			settingsOverride: settingsModelOverride ?? parentProfileBinding,
 			agentModel: effectiveAgent.model,
 			settings: this.session.settings,
 			activeModelPattern: parentActiveModelPattern,

package/src/thinking.ts

@@ -1,8 +1,27 @@
 import { type ResolvedThinkingLevel, ThinkingLevel } from "@gajae-code/agent-core/thinking";
-import { clampThinkingLevelForModel, type Effort, THINKING_EFFORTS } from "@gajae-code/ai/model-thinking";
+import {
+	clampThinkingLevelForModel,
+	type Effort,
+	getMiniMaxThinkingMode,
+	THINKING_EFFORTS,
+} from "@gajae-code/ai/model-thinking";
 import type { Model } from "@gajae-code/ai/types";
+import { getThinkingLevelMetadata as getLevelMetadata, type ThinkingLevelMetadata } from "./thinking-metadata";
 
-export { getThinkingLevelMetadata, type ThinkingLevelMetadata } from "./thinking-metadata";
+export type { ThinkingLevelMetadata } from "./thinking-metadata";
+
+export function getThinkingLevelMetadata(level: ThinkingLevel, model?: Model): ThinkingLevelMetadata {
+	const mode = model && getMiniMaxThinkingMode(model);
+	if (mode === "always-on") {
+		return { value: level, label: "always on", description: "Reasoning is always on; effort control is unsupported" };
+	}
+	if (mode === "toggle" && level !== ThinkingLevel.Inherit) {
+		return level === ThinkingLevel.Off
+			? { value: level, label: "off", description: "Disable thinking (disabled)" }
+			: { value: level, label: "on", description: "Enable thinking (adaptive); no effort or token budget" };
+	}
+	return getLevelMetadata(level);
+}
 
 const THINKING_LEVELS = new Set<string>([ThinkingLevel.Inherit, ThinkingLevel.Off, ...THINKING_EFFORTS]);
 const EFFORT_LEVELS = new Set<string>(THINKING_EFFORTS);