@ottocode/sdk 0.1.314 → 0.1.316

package/src/core/src/tools/builtin/shell.ts

@@ -3,7 +3,7 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { spawn } from 'node:child_process';
 import { z } from 'zod/v3';
 import DESCRIPTION from './shell.txt' with { type: 'text' };
-import { getShellExecutionConfig } from '../bin-manager.ts';
+import { getShellExecutionConfig, type ShellEnvMode } from '../bin-manager.ts';
 import { createToolError, type ToolResponse } from '../error.ts';
 import {
 	injectCoAuthorIntoGitCommit,
@@ -45,7 +45,18 @@ function killProcessTree(pid: number) {
 	}
 }
 
+function forceKillProcessTree(pid: number) {
+	try {
+		process.kill(-pid, 'SIGKILL');
+	} catch {
+		try {
+			process.kill(pid, 'SIGKILL');
+		} catch {}
+	}
+}
+
 const REDIRECTED_SEARCH_COMMANDS = new Set(['grep', 'egrep', 'fgrep', 'rg']);
+const REDIRECTED_GLOB_COMMANDS = new Set(['find', 'fd']);
 
 /**
  * Detect commands that start with a standalone grep-style search binary.
@@ -53,23 +64,78 @@ const REDIRECTED_SEARCH_COMMANDS = new Set(['grep', 'egrep', 'fgrep', 'rg']);
  * with grep/rg are redirected to the dedicated `search` tool.
  */
 export function findRedirectedSearchCommand(cmd: string): string | null {
+	return findRepositoryDiscoveryCommand(cmd, 'search')?.command ?? null;
+}
+
+function commandTokens(segment: string): string[] {
+	const tokens = segment.trim().split(/\s+/).filter(Boolean);
+	let index = 0;
+	while (
+		index < tokens.length &&
+		/^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index] ?? '')
+	) {
+		index++;
+	}
+	if (tokens[index] === 'command') index++;
+	return tokens.slice(index);
+}
+
+function findRepositoryDiscoveryCommand(
+	cmd: string,
+	kind?: 'search' | 'glob',
+): { command: string; tool: 'search' | 'glob' } | null {
 	const segments = cmd.split(/&&|\|\||;|\n/);
 	for (const segment of segments) {
-		const tokens = segment.trim().split(/\s+/);
-		let index = 0;
-		while (
-			index < tokens.length &&
-			/^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index] ?? '')
-		) {
-			index++;
+		const tokens = commandTokens(segment);
+		const bin = tokens[0]?.split('/').pop() ?? '';
+		const second = tokens[1] ?? '';
+		if ((!kind || kind === 'search') && bin === 'git' && second === 'grep') {
+			return { command: 'git grep', tool: 'search' };
+		}
+		if ((!kind || kind === 'search') && REDIRECTED_SEARCH_COMMANDS.has(bin)) {
+			return { command: bin, tool: 'search' };
+		}
+		if ((!kind || kind === 'glob') && REDIRECTED_GLOB_COMMANDS.has(bin)) {
+			return { command: bin, tool: 'glob' };
+		}
+		if ((!kind || kind === 'glob') && bin === 'ls' && segment.includes('**')) {
+			return { command: 'ls **', tool: 'glob' };
 		}
-		if (tokens[index] === 'command') index++;
-		const bin = tokens[index]?.split('/').pop() ?? '';
-		if (REDIRECTED_SEARCH_COMMANDS.has(bin)) return bin;
 	}
 	return null;
 }
 
+function repositoryDiscoveryHint(cmd: string): string | undefined {
+	const discovery = findRepositoryDiscoveryCommand(cmd);
+	if (!discovery) return undefined;
+	return discovery.tool === 'search'
+		? `Tip: For repository content search, prefer the search tool instead of shelling out to ${discovery.command}. It is indexed, faster, and returns structured file:line matches.`
+		: `Tip: For repository file discovery, prefer the glob tool instead of shelling out to ${discovery.command}. It returns structured paths and skips common build/cache folders.`;
+}
+
+const SHELL_ENV_HINT =
+	'This command may require environment from your login/interactive shell. If appropriate, retry with envMode: "login-cache" (or "login-fresh" after changing shell config).';
+
+export function detectShellEnvHint(args: {
+	stdout: string;
+	stderr: string;
+	exitCode: number;
+	envMode?: ShellEnvMode;
+}): string | undefined {
+	if (args.envMode && args.envMode !== 'fast') return undefined;
+	if (args.exitCode === 0) return undefined;
+	const text = `${args.stderr}\n${args.stdout}`;
+	const patterns = [
+		/\b[A-Z][A-Z0-9_]{2,}\b[^\n]*(?:not set|not defined|required|missing|must be set)/i,
+		/(?:missing|required|could not find)[^\n]*(?:api key|token|credential|credentials|secret|environment variable|env var)/i,
+		/(?:no credentials|credentials[^\n]*not found|not authenticated|authentication required|please log in|please login)/i,
+		/(?:asdf|nvm|mise|direnv|op|doppler)[^\n]*(?:not found|not loaded|command not found)/i,
+	];
+	return patterns.some((pattern) => pattern.test(text))
+		? SHELL_ENV_HINT
+		: undefined;
+}
+
 export type ShellOutputMode = 'auto' | 'full' | 'tail';
 
 const DEFAULT_TAIL_LINES = 100;
@@ -136,6 +202,9 @@ type ShellResult = ToolResponse<{
 	stderrTruncated?: boolean;
 	stderrOriginalBytes?: number;
 	stderrShownBytes?: number;
+	discoveryHint?: string;
+	envMode?: ShellEnvMode;
+	envHint?: string;
 }>;
 
 type ShellStreamChunk =
@@ -165,7 +234,7 @@ const shellInputSchema = z
 		cmd: z
 			.string()
 			.describe(
-				'Non-interactive shell command to run using the user shell with login/interactive startup loaded',
+				'Non-interactive shell command to run using the user shell. Login PATH is loaded, but interactive startup files are not sourced per command.',
 			),
 		cwd: z
 			.string()
@@ -181,6 +250,13 @@ const shellInputSchema = z
 			.optional()
 			.default(300000)
 			.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
+		envMode: z
+			.enum(['fast', 'login-cache', 'login-fresh'])
+			.optional()
+			.default('fast')
+			.describe(
+				'Environment loading mode. "fast" is the default one-off shell env. "login-cache" reuses a cached environment captured from the user login/interactive shell for commands that need shell-managed credentials. "login-fresh" refreshes that cache.',
+			),
 		outputMode: z
 			.enum(['auto', 'full', 'tail'])
 			.optional()
@@ -236,6 +312,7 @@ export function buildShellTool(projectRoot: string): {
 				cwd,
 				allowNonZeroExit,
 				timeout = 300000,
+				envMode = 'fast',
 				outputMode = 'auto',
 				tailLines = DEFAULT_TAIL_LINES,
 				maxOutputBytes = DEFAULT_MAX_OUTPUT_BYTES,
@@ -263,6 +340,7 @@ export function buildShellTool(projectRoot: string): {
 						cwd: absCwd,
 						allowNonZeroExit,
 						timeout,
+						envMode,
 						outputMode,
 						tailLines,
 						maxOutputBytes,
@@ -271,7 +349,7 @@ export function buildShellTool(projectRoot: string): {
 				) as AsyncIterable<ShellStreamChunk> | ShellResult;
 			}
 
-			const shellConfig = getShellExecutionConfig(finalCmd);
+			const shellConfig = getShellExecutionConfig(finalCmd, { envMode });
 			const proc = spawn(shellConfig.command, shellConfig.args, {
 				cwd: absCwd,
 				stdio: ['ignore', 'pipe', 'pipe'],
@@ -284,8 +362,11 @@ export function buildShellTool(projectRoot: string): {
 			let didTimeout = false;
 			let didAbort = false;
 			let settled = false;
+			let terminating = false;
 			let done = false;
 			let timeoutId: ReturnType<typeof setTimeout> | null = null;
+			let killEscalationId: ReturnType<typeof setTimeout> | null = null;
+			let fallbackSettleId: ReturnType<typeof setTimeout> | null = null;
 			const queue: ShellStreamChunk[] = [];
 			let notify: (() => void) | null = null;
 
@@ -348,6 +429,8 @@ export function buildShellTool(projectRoot: string): {
 					details.maxOutputBytes = maxOutputBytes;
 				}
 				if (timeoutId) clearTimeout(timeoutId);
+				if (killEscalationId) clearTimeout(killEscalationId);
+				if (fallbackSettleId) clearTimeout(fallbackSettleId);
 				if (abortSignal) {
 					abortSignal.removeEventListener('abort', onAbort);
 				}
@@ -356,11 +439,54 @@ export function buildShellTool(projectRoot: string): {
 				wake();
 			};
 
+			const abortResult = () =>
+				createToolError(`Command aborted by user: ${cmd}`, 'abort', {
+					cmd,
+					stdout,
+					stderr,
+					envMode,
+					...(outputMode === 'tail' || outputMode === 'auto'
+						? { outputMode, tailLines, maxOutputBytes }
+						: { outputMode, maxOutputBytes }),
+				});
+
+			const timeoutResult = () =>
+				createToolError(
+					`Command timed out after ${timeout}ms: ${cmd}`,
+					'timeout',
+					{
+						parameter: 'timeout',
+						value: timeout,
+						stdout,
+						stderr,
+						envMode,
+						...(outputMode === 'tail' || outputMode === 'auto'
+							? { outputMode, tailLines, maxOutputBytes }
+							: { outputMode, maxOutputBytes }),
+						suggestion: 'Increase timeout or optimize the command',
+					},
+				);
+
+			const terminate = (fallbackResult: () => ShellResult) => {
+				if (terminating) return;
+				terminating = true;
+				if (proc.pid) {
+					killProcessTree(proc.pid);
+					killEscalationId = setTimeout(() => {
+						if (proc.pid) forceKillProcessTree(proc.pid);
+					}, 1000);
+				} else {
+					proc.kill('SIGTERM');
+				}
+				fallbackSettleId = setTimeout(() => {
+					settle(fallbackResult());
+				}, 2000);
+			};
+
 			const onAbort = () => {
 				if (settled) return;
 				didAbort = true;
-				if (proc.pid) killProcessTree(proc.pid);
-				else proc.kill('SIGTERM');
+				terminate(abortResult);
 			};
 
 			if (abortSignal) {
@@ -370,8 +496,7 @@ export function buildShellTool(projectRoot: string): {
 			if (timeout > 0) {
 				timeoutId = setTimeout(() => {
 					didTimeout = true;
-					if (proc.pid) killProcessTree(proc.pid);
-					else proc.kill();
+					terminate(timeoutResult);
 				}, timeout);
 			}
 
@@ -394,12 +519,20 @@ export function buildShellTool(projectRoot: string): {
 			});
 
 			proc.on('close', (exitCode) => {
+				const resolvedExitCode = exitCode ?? 0;
+				const envHint = detectShellEnvHint({
+					stdout,
+					stderr,
+					exitCode: resolvedExitCode,
+					envMode,
+				});
 				if (didAbort) {
 					settle(
 						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
 							cmd,
 							stdout,
 							stderr,
+							envMode,
 							...(outputMode === 'tail' || outputMode === 'auto'
 								? { outputMode, tailLines, maxOutputBytes }
 								: { outputMode, maxOutputBytes }),
@@ -418,6 +551,7 @@ export function buildShellTool(projectRoot: string): {
 								value: timeout,
 								stdout,
 								stderr,
+								envMode,
 								...(outputMode === 'tail' || outputMode === 'auto'
 									? { outputMode, tailLines, maxOutputBytes }
 									: { outputMode, maxOutputBytes }),
@@ -428,15 +562,17 @@ export function buildShellTool(projectRoot: string): {
 					return;
 				}
 
-				if (exitCode !== 0 && !allowNonZeroExit) {
+				if (resolvedExitCode !== 0 && !allowNonZeroExit) {
 					const errorDetail = stderr.trim() || stdout.trim() || '';
-					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
+					const errorMsg = `Command failed with exit code ${resolvedExitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
 					settle(
 						createToolError(errorMsg, 'execution', {
-							exitCode,
+							exitCode: resolvedExitCode,
 							stdout,
 							stderr,
 							cmd,
+							envMode,
+							...(envHint ? { envHint } : {}),
 							...(outputMode === 'tail' || outputMode === 'auto'
 								? { outputMode, tailLines, maxOutputBytes }
 								: { outputMode, maxOutputBytes }),
@@ -446,17 +582,20 @@ export function buildShellTool(projectRoot: string): {
 					return;
 				}
 
+				const discoveryHint = repositoryDiscoveryHint(finalCmd);
 				settle({
 					ok: true,
-					exitCode: exitCode ?? 0,
+					exitCode: resolvedExitCode,
 					stdout,
 					stderr,
+					envMode,
+					...(discoveryHint ? { discoveryHint } : {}),
+					...(envHint ? { envHint } : {}),
 					...(outputMode === 'tail' || outputMode === 'auto'
 						? { outputMode, tailLines, maxOutputBytes }
 						: { outputMode, maxOutputBytes }),
 				});
 			});
-
 			proc.on('error', (err) => {
 				settle(
 					createToolError(

package/src/core/src/tools/builtin/shell.txt

@@ -1,13 +1,27 @@
-- Execute a non-interactive shell command using the user's shell with login/interactive startup loaded
+- Execute a non-interactive shell command using the user's shell
 - Returns `stdout`, `stderr`, and `exitCode`
 - `cwd` is relative to the project root and sandboxed within it
 
+The shell tool loads the user's login PATH once for command lookup, but it does not source interactive startup files for every command. Use `terminal` when you need an interactive shell, a TTY, or a persistent process.
+
+`envMode` controls extra environment loading:
+- `fast` (default): fastest one-off shell environment plus cached login PATH.
+- `login-cache`: reuses a cached environment captured from the user's login/interactive shell. Use this only when a prior fast command reports missing credentials/environment, or when the user explicitly asks to load shell startup environment.
+- `login-fresh`: refreshes that login/interactive shell environment cache before running the command.
+
+If a fast command fails with an `envHint`, retry once with `envMode: "login-cache"` when appropriate. Do not use login env modes for normal repository discovery, simple build/test commands, or as a blanket default.
+
 **Use `shell` for one-off, non-interactive commands.** These may be short-lived checks or long-running commands that finish on their own and do not require stdin. For commands that need interactive input, a TTY, or persistence across turns, use the `terminal` tool instead.
 
 For repository discovery, use `search` for content/code search and `glob` for filename/path discovery. Reserve `shell` for execution, builds, tests, diagnostics, and other command-line tasks.
 
 **Strongly prefer the `search` tool over `grep`/`rg`, and `glob` over `find`.** The `search` tool is indexed and faster, returns structured `file:line` matches, and supports regex, `glob` includes, `path` scoping, and `ignoreCase` — use it for all repository content search. Only fall back to `grep`/`rg` via shell for cases `search` cannot handle (e.g. gitignored files like node_modules or build output). Pipelines that filter program output (e.g. `ps aux | grep node`) are fine.
 
+Mapping from common shell habits:
+- `grep -r` / `rg` / `git grep` over repo files → use `search`.
+- `find` / `fd` / recursive `ls` for filenames → use `glob`.
+- Build, test, package manager, diagnostics, process inspection → use `shell`.
+
 ## Usage tips
 
 - Chain commands with `&&` to fail-fast.

package/src/core/src/tools/loader.ts

@@ -142,7 +142,14 @@ async function discoverStaticProjectTools(
 
 	const discoveryPromise = (async () => {
 		const tools = new Map<string, Tool>();
-		for (const { name, tool } of buildFsTools(projectRoot))
+		const fsTools = buildFsTools(projectRoot);
+		for (const { name, tool } of fsTools.filter(({ name }) => name === 'read'))
+			tools.set(name, tool);
+		// Put apply_patch before exact replacement tools so models see it as the
+		// default editing path after reading files.
+		const ap = buildApplyPatchTool(projectRoot);
+		tools.set(ap.name, ap.tool);
+		for (const { name, tool } of fsTools.filter(({ name }) => name !== 'read'))
 			tools.set(name, tool);
 		for (const { name, tool } of buildGitTools(projectRoot))
 			tools.set(name, tool);
@@ -155,9 +162,6 @@ async function discoverStaticProjectTools(
 		tools.set(search.name, search.tool);
 		const glob = buildGlobTool(projectRoot);
 		tools.set(glob.name, glob.tool);
-		// Patch/apply
-		const ap = buildApplyPatchTool(projectRoot);
-		tools.set(ap.name, ap.tool);
 		// Todo tracking
 		tools.set('update_todos', updateTodosTool);
 		// Web search

package/src/index.ts

@@ -81,6 +81,7 @@ export type {
 } from './providers/src/index.ts';
 export {
 	isBuiltInProviderId,
+	resolveBuiltInProviderCatalogId,
 	getProviderSettings,
 	getProviderDefinition,
 	hasConfiguredProvider,
@@ -162,13 +163,9 @@ export { createOpencodeModel } from './providers/src/index.ts';
 export type { OpencodeProviderConfig } from './providers/src/index.ts';
 export {
 	createKimiModel,
-	createMoonshotModel,
 	readKimiApiKeyFromEnv,
 } from './providers/src/index.ts';
-export type {
-	KimiProviderConfig,
-	MoonshotProviderConfig,
-} from './providers/src/index.ts';
+export type { KimiProviderConfig } from './providers/src/index.ts';
 export { createMinimaxModel } from './providers/src/index.ts';
 export type { MinimaxProviderConfig } from './providers/src/index.ts';
 export {

package/src/prompts/src/agents/build.txt

@@ -8,8 +8,8 @@ You help with coding and build tasks.
 
 Pick the right tool for the job (each tool's description has its full contract):
 
-- Use the exact-replacement editing tools available to you for targeted changes in existing files.
-- Use patch-style editing for structural diffs, file add/delete/rename, or multi-file changes when that capability is available.
+- Prefer `apply_patch` for code and text changes when it is available. It gives the clearest diff preview and handles targeted, structural, and multi-file edits.
+- Use exact-replacement tools (`edit`/`multiedit`) when a patch would be awkward, when you have a precise replacement block, or after patch attempts fail.
 - Use `write` only for NEW files or >70% full-file rewrites. Never use it for targeted edits.
 
 **Always read a file immediately before editing it.** Memory and earlier context are not reliable — the file may have changed.

package/src/prompts/src/providers/{moonshot.txt → kimi.txt}

@@ -1,4 +1,4 @@
-You are Kimi, an agentic coding assistant by Moonshot AI operating in otto in Thinking mode. Precise, safe, helpful.
+You are Kimi, an agentic coding assistant operating in otto in Thinking mode. Precise, safe, helpful.
 
 # Reasoning
 

package/src/prompts/src/providers.ts

@@ -14,7 +14,7 @@ import PROVIDER_ANTHROPIC from './providers/anthropic.txt' with {
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import PROVIDER_GOOGLE from './providers/google.txt' with { type: 'text' };
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-import PROVIDER_MOONSHOT from './providers/moonshot.txt' with { type: 'text' };
+import PROVIDER_KIMI from './providers/kimi.txt' with { type: 'text' };
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import PROVIDER_DEFAULT from './providers/default.txt' with { type: 'text' };
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
@@ -24,7 +24,7 @@ const FAMILY_PROMPTS: Record<string, string> = {
 	openai: PROVIDER_OPENAI,
 	anthropic: PROVIDER_ANTHROPIC,
 	google: PROVIDER_GOOGLE,
-	moonshot: PROVIDER_MOONSHOT,
+	kimi: PROVIDER_KIMI,
 	glm: PROVIDER_GLM,
 	minimax: PROVIDER_DEFAULT,
 };
@@ -142,9 +142,9 @@ export async function providerBasePrompt(
 		const result = PROVIDER_GOOGLE.trim();
 		return { prompt: result, resolvedType: 'google' };
 	}
-	if (id === 'moonshot') {
-		const result = PROVIDER_MOONSHOT.trim();
-		return { prompt: result, resolvedType: 'moonshot' };
+	if (id === 'kimi') {
+		const result = PROVIDER_KIMI.trim();
+		return { prompt: result, resolvedType: 'kimi' };
 	}
 	if (id === 'zai' || id === 'zai-coding') {
 		const result = PROVIDER_GLM.trim();

package/src/providers/src/catalog-manual.ts

@@ -13,6 +13,35 @@ type CatalogMap = Partial<Record<BuiltInProviderId, ProviderCatalogEntry>>;
 
 const OLLAMA_CLOUD_ID: BuiltInProviderId = 'ollama-cloud';
 const OTTOROUTER_ID: BuiltInProviderId = 'ottorouter';
+const ZAI_CODING_ID: BuiltInProviderId = 'zai-coding';
+
+const ZAI_CODING_MODEL_ORDER = [
+	'glm-5.2',
+	'glm-5.1',
+	'glm-5-turbo',
+	'glm-5',
+	'glm-4.7',
+	'glm-4.5-air',
+	'glm-5v-turbo',
+];
+
+const ZAI_CODING_MANUAL_MODELS: ModelInfo[] = [
+	{
+		id: 'glm-5',
+		ownedBy: 'zai',
+		label: 'GLM-5',
+		modalities: { input: ['text'], output: ['text'] },
+		toolCall: true,
+		reasoningText: true,
+		attachment: false,
+		temperature: true,
+		releaseDate: '2026-02-11',
+		lastUpdated: '2026-02-11',
+		openWeights: true,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		limit: { context: 204_800, output: 131_072 },
+	},
+];
 
 const XAI_GROK_CLI_MODELS: ModelInfo[] = [
 	{
@@ -46,7 +75,7 @@ const OWNER_NPM: Record<ModelOwner, string> = {
 	google: '@ai-sdk/google',
 	openrouter: '@openrouter/ai-sdk-provider',
 	xai: '@ai-sdk/xai',
-	moonshot: '@ai-sdk/openai-compatible',
+	kimi: '@ai-sdk/openai-compatible',
 	qwen: '@ai-sdk/openai-compatible',
 	zai: '@ai-sdk/openai-compatible',
 	minimax: '@ai-sdk/anthropic',
@@ -162,26 +191,85 @@ const DEPRECATED_KIMI_MODEL_IDS = new Set([
 	'kimi-k2-turbo-preview',
 ]);
 
+const KIMI_MANUAL_MODELS: ModelInfo[] = [
+	{
+		id: 'kimi-k2.7-code-highspeed',
+		ownedBy: 'kimi',
+		label: 'Kimi K2.7 Code Highspeed',
+		modalities: { input: ['text', 'image', 'video'], output: ['text'] },
+		toolCall: true,
+		reasoningText: true,
+		attachment: true,
+		temperature: false,
+		knowledge: '2025-01',
+		openWeights: true,
+		cost: { input: 1.9, output: 8, cacheRead: 0.38 },
+		limit: { context: 262_144, output: 262_144 },
+	},
+];
+
 export function filterAvailableKimiModels(models: ModelInfo[]): ModelInfo[] {
 	return models.filter((model) => !DEPRECATED_KIMI_MODEL_IDS.has(model.id));
 }
 
+function appendKimiManualModels(models: ModelInfo[]): ModelInfo[] {
+	const manualById = new Map(
+		KIMI_MANUAL_MODELS.map((model) => [model.id, model]),
+	);
+	const mergedModels = models.map((model) => {
+		const override = manualById.get(model.id);
+		return override ? { ...model, ...override } : model;
+	});
+	const existingIds = new Set(mergedModels.map((model) => model.id));
+	const missingModels = KIMI_MANUAL_MODELS.filter(
+		(model) => !existingIds.has(model.id),
+	);
+	return missingModels.length
+		? [...mergedModels, ...missingModels]
+		: mergedModels;
+}
+
 export function applyOfficialKimiCatalogMetadata<
 	T extends ProviderCatalogEntry,
 >(entry: T | undefined): T | undefined {
 	if (!entry) return undefined;
-	const env = Array.from(
-		new Set(['KIMI_API_KEY', 'MOONSHOT_API_KEY', ...(entry.env ?? [])]),
-	);
+	const env = Array.from(new Set(['KIMI_API_KEY', ...(entry.env ?? [])]));
 	return {
 		...entry,
-		models: filterAvailableKimiModels(entry.models),
-		label: entry.label === 'Moonshot AI' ? 'Kimi' : entry.label,
+		models: appendKimiManualModels(filterAvailableKimiModels(entry.models)),
+		label: 'Kimi',
 		env,
 		doc: 'https://platform.kimi.ai/docs/api/overview.md',
 	};
 }
 
+export function applyZaiCodingCatalogMetadata<T extends ProviderCatalogEntry>(
+	entry: T | undefined,
+): T | undefined {
+	if (!entry) return undefined;
+	const order = new Map(
+		ZAI_CODING_MODEL_ORDER.map((modelId, index) => [modelId, index]),
+	);
+	const modelById = new Map(entry.models.map((model) => [model.id, model]));
+	for (const model of ZAI_CODING_MANUAL_MODELS) {
+		if (!modelById.has(model.id)) modelById.set(model.id, model);
+	}
+	const models = Array.from(modelById.values()).sort((a, b) => {
+		const orderA = order.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+		const orderB = order.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+		if (orderA !== orderB) return orderA - orderB;
+		return a.id.localeCompare(b.id);
+	});
+	return {
+		...entry,
+		models,
+		label: 'Z.AI Coding Plan',
+		env: ['ZAI_CODING_API_KEY'],
+		api: 'https://api.z.ai/api/coding/paas/v4',
+		doc: 'https://docs.z.ai/devpack/overview',
+	};
+}
+
 export function mergeManualCatalog(
 	base: CatalogMap,
 ): Record<BuiltInProviderId, ProviderCatalogEntry> {
@@ -195,9 +283,13 @@ export function mergeManualCatalog(
 	if (xaiEntry) {
 		merged.xai = xaiEntry;
 	}
-	const moonshotEntry = applyOfficialKimiCatalogMetadata(merged.moonshot);
-	if (moonshotEntry) {
-		merged.moonshot = moonshotEntry;
+	const kimiEntry = applyOfficialKimiCatalogMetadata(merged.kimi);
+	if (kimiEntry) {
+		merged.kimi = kimiEntry;
+	}
+	const zaiCodingEntry = applyZaiCodingCatalogMetadata(merged[ZAI_CODING_ID]);
+	if (zaiCodingEntry) {
+		merged[ZAI_CODING_ID] = zaiCodingEntry;
 	}
 	if (manualEntry) {
 		merged[OTTOROUTER_ID] = manualEntry;