@ottocode/sdk 0.1.315 → 0.1.316

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.315",
+	"version": "0.1.316",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",

package/src/core/src/providers/resolver.ts

@@ -211,6 +211,7 @@ export async function resolveModel(
 		return createZaiModel(model, {
 			apiKey: config.apiKey,
 			baseURL: config.baseURL,
+			fetch: config.customFetch,
 		});
 	}
 
@@ -218,6 +219,7 @@ export async function resolveModel(
 		return createZaiCodingModel(model, {
 			apiKey: config.apiKey,
 			baseURL: config.baseURL,
+			fetch: config.customFetch,
 		});
 	}
 

package/src/core/src/tools/bin-manager.ts

@@ -15,6 +15,16 @@ let cachedLoginPath: {
 	path: string | null;
 } | null = null;
 
+let cachedLoginEnv: {
+	key: string;
+	env: NodeJS.ProcessEnv | null;
+} | null = null;
+
+export type ShellEnvMode = 'fast' | 'login-cache' | 'login-fresh';
+
+const ENV_JSON_START = '___OTTO_ENV_JSON_START___';
+const ENV_JSON_END = '___OTTO_ENV_JSON_END___';
+
 export { getAgiBinDir } from './bin-manager/paths.ts';
 
 async function whichBinary(name: string): Promise<string | null> {
@@ -72,29 +82,35 @@ export function getUserShell(): string {
 	return process.env.SHELL || '/bin/bash';
 }
 
-function getShellRcBootstrap(shell: string): string {
-	const shellName = shell.split('/').pop() || '';
-	if (shellName.includes('zsh')) {
-		return 'if [ -f "$HOME/.zshrc" ]; then . "$HOME/.zshrc"; fi';
-	}
-	if (shellName.includes('bash')) {
-		return 'if [ -f "$HOME/.bashrc" ]; then . "$HOME/.bashrc"; fi';
-	}
-	return '';
-}
-
-function getInteractiveShellFlag(shell: string): string {
-	const shellName = shell.split('/').pop() || '';
-	if (shellName.includes('bash')) return '-ic';
-	return '-ilc';
-}
-
-export function getShellExecutionConfig(cmd: string): {
+export function getShellExecutionConfig(
+	cmd: string,
+	options?: { envMode?: ShellEnvMode },
+): {
+	command: string;
+	args: string[];
+	env: NodeJS.ProcessEnv;
+};
+export function getShellExecutionConfig(
+	cmd: string,
+	options: { envMode?: ShellEnvMode } = {},
+): {
 	command: string;
 	args: string[];
 	env: NodeJS.ProcessEnv;
 } {
-	const env = { ...process.env, PATH: getAugmentedPath() };
+	const envMode = options.envMode ?? 'fast';
+	const loginEnv =
+		envMode === 'fast' ? null : getLoginShellEnv(envMode === 'login-fresh');
+	const env = {
+		...process.env,
+		...(loginEnv ?? {}),
+		PATH: mergePaths([
+			getAgiBinDir(),
+			loginEnv?.PATH,
+			getLoginShellPath(),
+			process.env.PATH,
+		]),
+	};
 	if (process.platform === 'win32') {
 		return {
 			command: getUserShell(),
@@ -106,11 +122,56 @@ export function getShellExecutionConfig(cmd: string): {
 	const command = getUserShell();
 	return {
 		command,
-		args: [getInteractiveShellFlag(command), 'eval "$OTTO_SHELL_COMMAND"'],
+		args: ['-c', 'eval "$OTTO_SHELL_COMMAND"'],
 		env: { ...env, OTTO_SHELL_COMMAND: cmd },
 	};
 }
 
+function getLoginShellEnv(refresh: boolean): NodeJS.ProcessEnv | null {
+	const home = process.env.HOME || homedir();
+	const userShell = getUserShell();
+	const cacheKey = [home, userShell, process.env.PATH || ''].join('\0');
+	if (!refresh && cachedLoginEnv?.key === cacheKey) return cachedLoginEnv.env;
+
+	if (process.platform === 'win32') {
+		cachedLoginEnv = { key: cacheKey, env: { ...process.env } };
+		return cachedLoginEnv.env;
+	}
+	try {
+		const output = execFileSync(
+			userShell,
+			[
+				'-ic',
+				`printf '%s\n' ${JSON.stringify(ENV_JSON_START)}; env; printf '%s\n' ${JSON.stringify(ENV_JSON_END)}`,
+			],
+			{
+				timeout: 10000,
+				stdio: ['ignore', 'pipe', 'ignore'],
+				env: {
+					...process.env,
+					HOME: home,
+					USER: process.env.USER || '',
+					SHELL: userShell,
+				},
+			},
+		).toString();
+		const start = output.indexOf(ENV_JSON_START);
+		const end = output.indexOf(ENV_JSON_END, start + ENV_JSON_START.length);
+		if (start >= 0 && end > start) {
+			const env: NodeJS.ProcessEnv = {};
+			const body = output.slice(start + ENV_JSON_START.length, end).trim();
+			for (const line of body.split('\n')) {
+				const separator = line.indexOf('=');
+				if (separator <= 0) continue;
+				env[line.slice(0, separator)] = line.slice(separator + 1);
+			}
+			cachedLoginEnv = { key: cacheKey, env };
+			return env;
+		}
+	} catch {}
+	return null;
+}
+
 function getLoginShellPath(): string | null {
 	const home = process.env.HOME || homedir();
 	const userShell = getUserShell();
@@ -131,10 +192,8 @@ function getLoginShellPath(): string | null {
 
 	for (const shell of shellCandidates) {
 		try {
-			const rcBootstrap = getShellRcBootstrap(shell);
-			const pathCommand = `${rcBootstrap ? `${rcBootstrap}\n` : ''}echo "___PATH___:$PATH"`;
-			const result = execFileSync(shell, ['-ilc', pathCommand], {
-				timeout: 5000,
+			const result = execFileSync(shell, ['-lc', 'echo "___PATH___:$PATH"'], {
+				timeout: 1500,
 				stdio: ['ignore', 'pipe', 'ignore'],
 				env: {
 					...process.env,
@@ -157,19 +216,15 @@ function getLoginShellPath(): string | null {
 }
 
 export function getAugmentedPath(): string {
-	const sep = process.platform === 'win32' ? ';' : ':';
-	const binDir = getAgiBinDir();
-	const current = process.env.PATH || '';
-	const loginPath = getLoginShellPath();
+	return mergePaths([getAgiBinDir(), getLoginShellPath(), process.env.PATH]);
+}
 
+function mergePaths(paths: Array<string | null | undefined>): string {
+	const sep = process.platform === 'win32' ? ';' : ':';
 	const seen = new Set<string>();
 	const parts: string[] = [];
 
-	for (const p of [
-		binDir,
-		...(loginPath ? loginPath.split(sep) : []),
-		...current.split(sep),
-	]) {
+	for (const p of paths.flatMap((path) => (path ? path.split(sep) : []))) {
 		if (p && !seen.has(p)) {
 			seen.add(p);
 			parts.push(p);

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,6 +45,16 @@ 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']);
 
@@ -103,6 +113,29 @@ function repositoryDiscoveryHint(cmd: string): string | undefined {
 		: `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;
@@ -170,6 +203,8 @@ type ShellResult = ToolResponse<{
 	stderrOriginalBytes?: number;
 	stderrShownBytes?: number;
 	discoveryHint?: string;
+	envMode?: ShellEnvMode;
+	envHint?: string;
 }>;
 
 type ShellStreamChunk =
@@ -199,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()
@@ -215,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()
@@ -270,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,
@@ -297,6 +340,7 @@ export function buildShellTool(projectRoot: string): {
 						cwd: absCwd,
 						allowNonZeroExit,
 						timeout,
+						envMode,
 						outputMode,
 						tailLines,
 						maxOutputBytes,
@@ -305,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'],
@@ -318,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;
 
@@ -382,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);
 				}
@@ -390,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) {
@@ -404,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);
 			}
 
@@ -428,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 }),
@@ -452,6 +551,7 @@ export function buildShellTool(projectRoot: string): {
 								value: timeout,
 								stdout,
 								stderr,
+								envMode,
 								...(outputMode === 'tail' || outputMode === 'auto'
 									? { outputMode, tailLines, maxOutputBytes }
 									: { outputMode, maxOutputBytes }),
@@ -462,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 }),
@@ -483,16 +585,17 @@ export function buildShellTool(projectRoot: string): {
 				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,7 +1,16 @@
-- 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.

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[] = [
 	{
@@ -214,6 +243,33 @@ export function applyOfficialKimiCatalogMetadata<
 	};
 }
 
+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> {
@@ -231,6 +287,10 @@ export function mergeManualCatalog(
 	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;
 	}

package/src/providers/src/zai-client.ts

@@ -4,6 +4,7 @@ import { catalog } from './catalog-merged.ts';
 export type ZaiProviderConfig = {
 	apiKey?: string;
 	baseURL?: string;
+	fetch?: typeof fetch;
 };
 
 export function createZaiModel(model: string, config?: ZaiProviderConfig) {
@@ -21,6 +22,7 @@ export function createZaiModel(model: string, config?: ZaiProviderConfig) {
 		name: entry?.label ?? 'Z.AI',
 		baseURL,
 		headers,
+		fetch: config?.fetch,
 	});
 
 	return instance(model);
@@ -44,6 +46,7 @@ export function createZaiCodingModel(
 		name: entry?.label ?? 'Z.AI Coding',
 		baseURL,
 		headers,
+		fetch: config?.fetch,
 	});
 
 	return instance(model);