@sayknow-cli/coding-agent 0.6.5 → 0.6.7

package/src/session/response-language.ts

@@ -0,0 +1,71 @@
+/**
+ * Which language to answer in, detected from the script of the user's message.
+ *
+ * Long tool-heavy turns drift into English: tool output, logs, skill text and context
+ * summaries are English, and the final report follows them. The system prompt states
+ * the rule once; this adds a one-line reminder at the start of each turn, naming the
+ * language, when the message is clearly written in a non-Latin script. Latin-script
+ * languages (English, Spanish, French, German, …) cannot be told apart by script alone,
+ * so they get no reminder and rely on the system prompt rule.
+ */
+
+export interface DetectedLanguage {
+	/** BCP 47 code. */
+	code: string;
+	/** English name, as used in the reminder. */
+	name: string;
+}
+
+/** Scripts that name one language well enough for a reminder. Kana wins over Han: Japanese mixes both. */
+const SCRIPTS: ReadonlyArray<{ pattern: RegExp; language: DetectedLanguage }> = [
+	{ pattern: /\p{Script=Hangul}/gu, language: { code: "ko", name: "Korean" } },
+	{ pattern: /[\p{Script=Hiragana}\p{Script=Katakana}]/gu, language: { code: "ja", name: "Japanese" } },
+	{ pattern: /\p{Script=Han}/gu, language: { code: "zh", name: "Chinese" } },
+	{ pattern: /\p{Script=Cyrillic}/gu, language: { code: "ru", name: "Russian" } },
+	{ pattern: /\p{Script=Arabic}/gu, language: { code: "ar", name: "Arabic" } },
+	{ pattern: /\p{Script=Hebrew}/gu, language: { code: "he", name: "Hebrew" } },
+	{ pattern: /\p{Script=Thai}/gu, language: { code: "th", name: "Thai" } },
+	{ pattern: /\p{Script=Devanagari}/gu, language: { code: "hi", name: "Hindi" } },
+	{ pattern: /\p{Script=Greek}/gu, language: { code: "el", name: "Greek" } },
+];
+
+/** Code, quoted output and links say nothing about the language the user writes in. */
+function proseOnly(text: string): string {
+	return text
+		.replace(/```[\s\S]*?```/g, " ")
+		.replace(/`[^`\n]*`/g, " ")
+		.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, " ")
+		.replace(/https?:\/\/\S+/g, " ")
+		.split("\n")
+		.filter(line => !/^\s*>/.test(line))
+		.join("\n");
+}
+
+/**
+ * The language of `text` when its prose is clearly in a non-Latin script, else
+ * undefined. "Clearly": at least two characters of the script, and — since one CJK
+ * character carries about a word — at least a quarter as many as Latin letters, so a
+ * pasted English log with one Korean word does not count.
+ */
+export function detectResponseLanguage(text: string): DetectedLanguage | undefined {
+	const prose = proseOnly(text);
+	const latin = prose.match(/\p{Script=Latin}/gu)?.length ?? 0;
+	const kana = prose.match(SCRIPTS[1]!.pattern)?.length ?? 0;
+	for (const { pattern, language } of SCRIPTS) {
+		let count = prose.match(pattern)?.length ?? 0;
+		if (language.code === "zh" && kana > 0) continue;
+		// Japanese needs kana to be told from Chinese; with it, its kanji count too.
+		if (language.code === "ja" && kana > 0) count += prose.match(/\p{Script=Han}/gu)?.length ?? 0;
+		if (count >= 2 && count * 4 >= latin) return language;
+	}
+	return undefined;
+}
+
+/** The per-turn reminder for a detected language. */
+export function buildResponseLanguageReminder(language: DetectedLanguage): string {
+	return [
+		"<system-reminder>",
+		`The user wrote in ${language.name}. Write every user-facing message this turn in ${language.name} — progress notes and the final report after tool work included — unless they asked for another language. Keep code, commands, paths and identifiers as they are.`,
+		"</system-reminder>",
+	].join("\n");
+}

package/src/setup/model-onboarding-guidance.ts

@@ -1,8 +1,11 @@
 import { formatProviderCredentialHint } from "@sayknow-cli/ai/stream";
+import { getOAuthProviders } from "@sayknow-cli/ai/utils/oauth";
+import { formatProviderPresetChoices } from "./provider-onboarding";
 
 export const MODEL_ONBOARDING_API_PROVIDER_COMMAND =
 	"/provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>";
-export const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = "/provider add --preset <minimax|minimax-cn|glm>";
+/** Built from the bundled preset catalog, so a new preset shows up here without editing copy. */
+export const MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND = `/provider add --preset <${formatProviderPresetChoices()}>`;
 
 export const MODEL_ONBOARDING_SETUP_COMMAND = "skc setup provider";
 export const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or /login [provider-id]";
@@ -11,40 +14,52 @@ export const MODEL_ONBOARDING_OAUTH_COMMAND = "/provider login [provider-id] or
  * user learns it exists is from the surfaces where they go to add credentials.
  */
 export const MODEL_ONBOARDING_TYPESAFE_COMMAND = "/provider typesafe";
+/** Where the models tried after a blocked one are shown and edited. */
+export const MODEL_ONBOARDING_FALLBACK_COMMAND = "/fallback";
 
 export function formatModelOnboardingGuidance(): string {
 	return [
 		"Model selection only shows configured providers.",
 		"Assignment targets are DEFAULT plus the SKC role agents: EXECUTOR, ARCHITECT, PLANNER, and CRITIC.",
 		"Legacy model-role aliases are compatibility-only and are not shown as assignment targets.",
+		`OAuth/subscription providers: ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
 		`Provider presets: ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND} --preset <preset>).`,
 		`API-compatible custom providers: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}.`,
-		`OAuth/subscription providers: ${MODEL_ONBOARDING_OAUTH_COMMAND}.`,
 		`Typed decisions (not a chat model): ${MODEL_ONBOARDING_TYPESAFE_COMMAND} adds a TypeSafe key.`,
-		"Then run /model to select a configured model or assign it to a target.",
+		`Then run /model to select a configured model or assign it to a target, and ${MODEL_ONBOARDING_FALLBACK_COMMAND} to see what runs when it is blocked.`,
 	].join("\n");
 }
 
 export function formatModelOnboardingInlineHint(): string {
-	return `Add MiniMax/GLM presets with ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND}; custom API providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); OAuth/subscription with ${MODEL_ONBOARDING_OAUTH_COMMAND}; TypeSafe typed decisions with ${MODEL_ONBOARDING_TYPESAFE_COMMAND}; then run /model for DEFAULT, EXECUTOR, ARCHITECT, PLANNER, and CRITIC.`;
+	return `Log in with ${MODEL_ONBOARDING_OAUTH_COMMAND}; presets with ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND}; custom API providers with ${MODEL_ONBOARDING_API_PROVIDER_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND}); TypeSafe typed decisions with ${MODEL_ONBOARDING_TYPESAFE_COMMAND}; then run /model for DEFAULT, EXECUTOR, ARCHITECT, PLANNER, and CRITIC, and ${MODEL_ONBOARDING_FALLBACK_COMMAND} for what runs when a model is blocked.`;
 }
 
 export function formatNoModelOnboardingError(): string {
 	return `No model selected.\n\n${formatModelOnboardingGuidance()}`;
 }
 
+/**
+ * Missing credentials for the provider the session tried to call. The fix for that
+ * provider comes first; the ways to add a different provider follow as alternatives.
+ */
 export function formatNoCredentialOnboardingError(providerId: string): string {
-	const lines = [
-		`No credentials found for ${providerId}.`,
-		"",
-		`For MiniMax/GLM presets, configure credentials with ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND} --preset <preset>).`,
-		`For custom API-compatible providers, use ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}.`,
-		`For OAuth/subscription providers, use ${MODEL_ONBOARDING_OAUTH_COMMAND} (interactive; not available in headless/print mode).`,
-	];
-	const headlessHint = formatProviderCredentialHint(providerId);
-	if (headlessHint) lines.push(headlessHint);
+	const lines = [`No credentials found for ${providerId}.`, ""];
+	const canLogIn = getOAuthProviders().some(provider => provider.id === providerId);
+	const credentialHint = formatProviderCredentialHint(providerId);
+	if (canLogIn) {
+		lines.push(`Log in to ${providerId}: /login ${providerId} (interactive; not available in headless/print mode).`);
+	}
+	if (credentialHint) lines.push(credentialHint);
+	if (!canLogIn && !credentialHint) {
+		lines.push(`Add an API key for ${providerId} (the env var or apiKey its models.yml entry names).`);
+	}
 	lines.push(
-		"Then run /model to select a configured model or assign it to DEFAULT, EXECUTOR, ARCHITECT, PLANNER, or CRITIC.",
+		"",
+		"Or use another provider:",
+		`- OAuth/subscription: ${MODEL_ONBOARDING_OAUTH_COMMAND} (interactive; not available in headless/print mode).`,
+		`- Presets: ${MODEL_ONBOARDING_PROVIDER_PRESET_COMMAND} (or ${MODEL_ONBOARDING_SETUP_COMMAND} --preset <preset>).`,
+		`- API-compatible: ${MODEL_ONBOARDING_API_PROVIDER_COMMAND}.`,
+		`Then run /model to select a configured model or assign it to DEFAULT, EXECUTOR, ARCHITECT, PLANNER, or CRITIC. With another provider logged in, a blocked model falls back automatically (${MODEL_ONBOARDING_FALLBACK_COMMAND}).`,
 	);
 	return lines.join("\n");
 }

package/src/setup/provider-onboarding.ts

@@ -103,6 +103,11 @@ export function formatProviderPresetList(): string {
 		.join("\n");
 }
 
+/** `minimax|minimax-cn|…` — the preset ids for a `--preset <…>` usage line, in catalog order. */
+export function formatProviderPresetChoices(): string {
+	return PROVIDER_PRESETS.map(preset => preset.id).join("|");
+}
+
 export function parseModelList(values: readonly string[]): string[] {
 	const models = values
 		.flatMap(value => value.split(","))

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

@@ -45,6 +45,7 @@ import { formatSessionImportSummary, runSessionImportCommand } from "../session-
 import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
 import {
 	addApiCompatibleProvider,
+	formatProviderPresetChoices,
 	formatProviderPresetList,
 	formatProviderSetupResult,
 	parseProviderCompatibility,
@@ -207,6 +208,102 @@ async function updateSessionStar(
 	return commandConsumed();
 }
 
+const FALLBACK_USAGE =
+	"Usage: /fallback [add <model> | remove <number|model> | clear | auto on|off]\n" +
+	"Models listed here run, in order, after the default model when it is blocked (no login, quota, auth or server errors).";
+
+/** Show or edit what runs when the default model is blocked. */
+async function handleFallbackCommand(
+	command: ParsedSlashCommand,
+	runtime: SlashCommandRuntime,
+): Promise<SlashCommandResult> {
+	const { verb, rest } = parseSubcommand(command.args);
+	const added = runtime.settings.get("fallback.models");
+	const save = async (models: string[], message: string): Promise<SlashCommandResult> => {
+		runtime.settings.set("fallback.models", models);
+		await runtime.notifyConfigChanged?.();
+		await runtime.output(`${message}\n\n${formatFallbackChain(runtime)}`);
+		return commandConsumed();
+	};
+	switch (verb) {
+		case "":
+		case "show":
+		case "list":
+			await runtime.output(formatFallbackChain(runtime));
+			return commandConsumed();
+		case "add": {
+			if (!rest) return usage(FALLBACK_USAGE, runtime);
+			const resolution = await resolveModelCommandSelection(runtime, rest);
+			if (!resolution.ok) return usage(resolution.failure.message, runtime);
+			const { model, thinkingLevel } = resolution.selection;
+			const selector = formatModelSelectorValue(`${model.provider}/${model.id}`, thinkingLevel);
+			if (added.includes(selector)) {
+				await runtime.output(`${selector} is already a fallback.\n\n${formatFallbackChain(runtime)}`);
+				return commandConsumed();
+			}
+			return save([...added, selector], `Added fallback: ${selector}`);
+		}
+		case "remove":
+		case "rm": {
+			const index = /^\d+$/.test(rest) ? Number(rest) - 1 : added.indexOf(rest);
+			const target = added[index];
+			if (!rest || target === undefined) {
+				return usage(
+					added.length === 0
+						? "No fallback models are set. Add one with /fallback add <model>."
+						: `Remove by number (1-${added.length}) or exact selector: ${added.join(", ")}`,
+					runtime,
+				);
+			}
+			return save(
+				added.filter((_, position) => position !== index),
+				`Removed fallback: ${target}`,
+			);
+		}
+		case "clear":
+			return save([], "Cleared fallback models.");
+		case "auto": {
+			const value = rest.toLowerCase();
+			if (value !== "on" && value !== "off") return usage("Usage: /fallback auto on|off", runtime);
+			runtime.settings.set("fallback.auto", value === "on");
+			await runtime.notifyConfigChanged?.();
+			await runtime.output(`Automatic fallback ${value}.\n\n${formatFallbackChain(runtime)}`);
+			return commandConsumed();
+		}
+		default:
+			return usage(FALLBACK_USAGE, runtime);
+	}
+}
+
+function formatFallbackChain(runtime: SlashCommandRuntime): string {
+	const auto = runtime.settings.get("fallback.auto");
+	const added = new Set(runtime.settings.get("fallback.models"));
+	const { entries, activeIndex, appendedFrom } = runtime.session.getDefaultFallbackChain();
+	const width = Math.max(0, ...entries.map(entry => entry.length));
+	const lines = [`Model fallback (automatic: ${auto ? "on" : "off"})`];
+	if (entries.length === 0) lines.push("  (no default model)");
+	entries.forEach((entry, index) => {
+		const source = index < appendedFrom ? (index === 0 ? "default" : "chain") : added.has(entry) ? "added" : "auto";
+		const inUse = index === activeIndex ? "  ← in use" : "";
+		lines.push(`  ${index + 1}. ${entry.padEnd(width)}  ${source}${inUse}`);
+	});
+	if (entries.length === 1) {
+		lines.push(
+			auto
+				? "  Nothing to fall back to yet: log in to another provider (/login) or add one with /fallback add <model>."
+				: "  Nothing to fall back to: add a model with /fallback add <model> or turn on /fallback auto on.",
+		);
+	}
+	if (auto && runtime.settings.get("enabledModels").length > 0) {
+		lines.push("  enabledModels restricts this session, so automatic picks are off; added models still apply.");
+	}
+	lines.push(
+		`Each model gets ${runtime.settings.get("fallback.maxAttempts")} tries; a blocked or exhausted account first hands over to the provider's next logged-in account (order: ${runtime.session.modelRegistry.authStorage.getCredentialRankingMode()}).`,
+		"/fallback add <model> · remove <n> · clear · auto on|off",
+	);
+	return lines.join("\n");
+}
+
 function parseProviderSetupSlashArgs(args: string): {
 	preset?: string;
 	compat?: string;
@@ -273,8 +370,7 @@ function parseProviderSetupSlashArgs(args: string): {
 function providerSetupUsage(): string {
 	return [
 		"Provider onboarding",
-		"Presets: /provider add --preset <minimax|minimax-cn|glm> [--force]",
-		"Aliases: /provider add minimax, /provider add minimax-cn, /provider add glm, /provider add zai (writes glm-proxy)",
+		`Presets: /provider add --preset <${formatProviderPresetChoices()}> [--force]`,
 		"API providers: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model> [--force]",
 		`Available presets:\n${formatProviderPresetList()}`,
 		"OAuth/subscription providers: /provider login [provider-id] or /login [provider-id]",
@@ -931,6 +1027,20 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "fallback",
+		description: "Show or edit the models tried when the default model is blocked",
+		inlineHint: "[add <model> | remove <n> | clear | auto on|off]",
+		acpInputHint: "[add <model> | remove <n> | clear | auto on|off]",
+		subcommands: [
+			{ name: "add", description: "Add a fallback model after the default chain" },
+			{ name: "remove", description: "Remove an added fallback by number or selector" },
+			{ name: "clear", description: "Remove every added fallback" },
+			{ name: "auto", description: "Turn automatic fallback to other logged-in providers on or off" },
+		],
+		allowArgs: true,
+		handle: handleFallbackCommand,
+	},
 	{
 		name: "effort",
 		description: "Show or set model reasoning effort",

package/src/tools/index.ts

@@ -47,6 +47,7 @@ import { FindTool } from "./find";
 import { GithubTool } from "./gh";
 import { IrcTool } from "./irc";
 import { JobTool } from "./job";
+import { LocateTool } from "./locate";
 import { MonitorTool } from "./monitor";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { ReadTool } from "./read";
@@ -88,6 +89,7 @@ export * from "./gh";
 export * from "./image-gen";
 export * from "./irc";
 export * from "./job";
+export * from "./locate";
 export * from "./monitor";
 export * from "./read";
 export * from "./recipe";
@@ -473,6 +475,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	github: GithubTool.createIf,
 	find: s => new FindTool(s),
 	search: s => new SearchTool(s),
+	locate: LocateTool.createIf,
 	lsp: LspTool.createIf,
 	browser: s => new BrowserTool(s),
 	...(isComputerLoadablePlatform() ? { computer: ComputerTool.createIf } : {}),