@ottocode/sdk 0.1.246 → 0.1.248

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.246",
+	"version": "0.1.248",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -37,6 +37,10 @@
 			"import": "./src/core/src/tools/builtin/bash.ts",
 			"types": "./src/core/src/tools/builtin/bash.ts"
 		},
+		"./tools/builtin/shell": {
+			"import": "./src/core/src/tools/builtin/shell.ts",
+			"types": "./src/core/src/tools/builtin/shell.ts"
+		},
 		"./tools/builtin/finish": {
 			"import": "./src/core/src/tools/builtin/finish.ts",
 			"types": "./src/core/src/tools/builtin/finish.ts"

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

@@ -1,266 +1 @@
-import { tool, type Tool } from 'ai';
-import { spawn } from 'node:child_process';
-import { z } from 'zod/v3';
-import DESCRIPTION from './bash.txt' with { type: 'text' };
-import { getAugmentedPath } from '../bin-manager.ts';
-import { createToolError, type ToolResponse } from '../error.ts';
-import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
-
-function normalizePath(p: string) {
-	const normalized = p.replace(/\\/g, '/');
-	const driveMatch = normalized.match(/^([A-Za-z]):\//);
-	const drivePrefix = driveMatch ? `${driveMatch[1]}:` : '';
-	const rest = driveMatch ? normalized.slice(2) : normalized;
-	const parts = rest.split('/');
-	const stack: string[] = [];
-	for (const part of parts) {
-		if (!part || part === '.') continue;
-		if (part === '..') stack.pop();
-		else stack.push(part);
-	}
-	if (drivePrefix) return `${drivePrefix}/${stack.join('/')}`;
-	return `/${stack.join('/')}`;
-}
-
-function resolveSafePath(projectRoot: string, p: string) {
-	const root = normalizePath(projectRoot);
-	const abs = normalizePath(`${root}/${p || '.'}`);
-	if (!(abs === root || abs.startsWith(`${root}/`))) {
-		throw new Error(`cwd escapes project root: ${p}`);
-	}
-	return abs;
-}
-
-function killProcessTree(pid: number) {
-	try {
-		process.kill(-pid, 'SIGTERM');
-	} catch {
-		try {
-			process.kill(pid, 'SIGTERM');
-		} catch {}
-	}
-}
-
-type BashResult = ToolResponse<{
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-}>;
-
-type BashStreamChunk =
-	| {
-			channel: 'output';
-			delta: string;
-	  }
-	| {
-			result: BashResult;
-	  };
-
-export function buildBashTool(projectRoot: string): {
-	name: string;
-	tool: Tool;
-} {
-	const bash = tool({
-		description: DESCRIPTION,
-
-		inputSchema: z
-			.object({
-				cmd: z.string().describe('Shell command to run (bash -c <cmd>)'),
-				cwd: z
-					.string()
-					.default('.')
-					.describe('Working directory relative to project root'),
-				allowNonZeroExit: z
-					.boolean()
-					.optional()
-					.default(false)
-					.describe('If true, do not throw on non-zero exit'),
-				timeout: z
-					.number()
-					.optional()
-					.default(300000)
-					.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
-			})
-			.strict(),
-		execute(
-			{
-				cmd,
-				cwd,
-				allowNonZeroExit,
-				timeout = 300000,
-			}: {
-				cmd: string;
-				cwd?: string;
-				allowNonZeroExit?: boolean;
-				timeout?: number;
-			},
-			options?: { abortSignal?: AbortSignal },
-		): AsyncIterable<BashStreamChunk> | BashResult {
-			const abortSignal = options?.abortSignal;
-
-			if (abortSignal?.aborted) {
-				return createToolError('Command aborted before execution', 'abort', {
-					cmd,
-				});
-			}
-
-			const absCwd = resolveSafePath(projectRoot, cwd || '.');
-			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
-
-			const proc = spawn(finalCmd, {
-				cwd: absCwd,
-				shell: true,
-				stdio: ['ignore', 'pipe', 'pipe'],
-				env: { ...process.env, PATH: getAugmentedPath() },
-				detached: true,
-			});
-
-			let stdout = '';
-			let stderr = '';
-			let didTimeout = false;
-			let didAbort = false;
-			let settled = false;
-			let done = false;
-			let timeoutId: ReturnType<typeof setTimeout> | null = null;
-			const queue: BashStreamChunk[] = [];
-			let notify: (() => void) | null = null;
-
-			const wake = () => {
-				if (!notify) return;
-				notify();
-				notify = null;
-			};
-
-			const pushDelta = (text: string) => {
-				if (!text) return;
-				queue.push({ channel: 'output', delta: text });
-				wake();
-			};
-
-			const settle = (result: BashResult) => {
-				if (settled) return;
-				settled = true;
-				if (timeoutId) clearTimeout(timeoutId);
-				if (abortSignal) {
-					abortSignal.removeEventListener('abort', onAbort);
-				}
-				queue.push({ result });
-				done = true;
-				wake();
-			};
-
-			const onAbort = () => {
-				if (settled) return;
-				didAbort = true;
-				if (proc.pid) killProcessTree(proc.pid);
-				else proc.kill('SIGTERM');
-			};
-
-			if (abortSignal) {
-				abortSignal.addEventListener('abort', onAbort, { once: true });
-			}
-
-			if (timeout > 0) {
-				timeoutId = setTimeout(() => {
-					didTimeout = true;
-					if (proc.pid) killProcessTree(proc.pid);
-					else proc.kill();
-				}, timeout);
-			}
-
-			proc.stdout?.on('data', (chunk) => {
-				const text = chunk.toString();
-				stdout += text;
-				pushDelta(text);
-			});
-
-			proc.stderr?.on('data', (chunk) => {
-				const text = chunk.toString();
-				stderr += text;
-				pushDelta(text);
-			});
-
-			proc.on('close', (exitCode) => {
-				if (didAbort) {
-					settle(
-						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
-							cmd,
-							stdout,
-							stderr,
-						}),
-					);
-					return;
-				}
-
-				if (didTimeout) {
-					settle(
-						createToolError(
-							`Command timed out after ${timeout}ms: ${cmd}`,
-							'timeout',
-							{
-								parameter: 'timeout',
-								value: timeout,
-								stdout,
-								stderr,
-								suggestion: 'Increase timeout or optimize the command',
-							},
-						),
-					);
-					return;
-				}
-
-				if (exitCode !== 0 && !allowNonZeroExit) {
-					const errorDetail = stderr.trim() || stdout.trim() || '';
-					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
-					settle(
-						createToolError(errorMsg, 'execution', {
-							exitCode,
-							stdout,
-							stderr,
-							cmd,
-							suggestion: 'Check command syntax or use allowNonZeroExit: true',
-						}),
-					);
-					return;
-				}
-
-				settle({
-					ok: true,
-					exitCode: exitCode ?? 0,
-					stdout,
-					stderr,
-				});
-			});
-
-			proc.on('error', (err) => {
-				settle(
-					createToolError(
-						`Command execution failed: ${err.message}`,
-						'execution',
-						{
-							cmd,
-							originalError: err.message,
-						},
-					),
-				);
-			});
-
-			const stream = async function* (): AsyncGenerator<BashStreamChunk> {
-				while (!done || queue.length > 0) {
-					if (queue.length === 0) {
-						await new Promise<void>((resolve) => {
-							notify = resolve;
-						});
-					}
-					while (queue.length > 0) {
-						const chunk = queue.shift();
-						if (chunk) yield chunk;
-					}
-				}
-			};
-
-			return stream();
-		},
-	}) as unknown as Tool;
-	return { name: 'bash', tool: bash };
-}
+export { buildShellTool, buildShellTool as buildBashTool } from './shell.ts';

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

@@ -0,0 +1,273 @@
+import { tool, type Tool } from 'ai';
+import { spawn } from 'node:child_process';
+import { z } from 'zod/v3';
+import DESCRIPTION from './shell.txt' with { type: 'text' };
+import { getAugmentedPath } from '../bin-manager.ts';
+import { createToolError, type ToolResponse } from '../error.ts';
+import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
+
+function normalizePath(p: string) {
+	const normalized = p.replace(/\\/g, '/');
+	const driveMatch = normalized.match(/^([A-Za-z]):\//);
+	const drivePrefix = driveMatch ? `${driveMatch[1]}:` : '';
+	const rest = driveMatch ? normalized.slice(2) : normalized;
+	const parts = rest.split('/');
+	const stack: string[] = [];
+	for (const part of parts) {
+		if (!part || part === '.') continue;
+		if (part === '..') stack.pop();
+		else stack.push(part);
+	}
+	if (drivePrefix) return `${drivePrefix}/${stack.join('/')}`;
+	return `/${stack.join('/')}`;
+}
+
+function resolveSafePath(projectRoot: string, p: string) {
+	const root = normalizePath(projectRoot);
+	const abs = normalizePath(`${root}/${p || '.'}`);
+	if (!(abs === root || abs.startsWith(`${root}/`))) {
+		throw new Error(`cwd escapes project root: ${p}`);
+	}
+	return abs;
+}
+
+function killProcessTree(pid: number) {
+	try {
+		process.kill(-pid, 'SIGTERM');
+	} catch {
+		try {
+			process.kill(pid, 'SIGTERM');
+		} catch {}
+	}
+}
+
+type ShellResult = ToolResponse<{
+	exitCode: number;
+	stdout: string;
+	stderr: string;
+}>;
+
+type ShellStreamChunk =
+	| {
+			channel: 'output';
+			delta: string;
+	  }
+	| {
+			result: ShellResult;
+	  };
+
+const shellInputSchema = z
+	.object({
+		cmd: z
+			.string()
+			.describe('Non-interactive shell command to run (bash -c <cmd>)'),
+		cwd: z
+			.string()
+			.default('.')
+			.describe('Working directory relative to project root'),
+		allowNonZeroExit: z
+			.boolean()
+			.optional()
+			.default(false)
+			.describe('If true, do not throw on non-zero exit'),
+		timeout: z
+			.number()
+			.optional()
+			.default(300000)
+			.describe('Timeout in milliseconds (default: 300000 = 5 minutes)'),
+	})
+	.strict();
+
+type ShellInput = z.infer<typeof shellInputSchema>;
+
+type ShellToolFactory = (definition: {
+	description: string;
+	inputSchema: typeof shellInputSchema;
+	execute(
+		input: ShellInput,
+		options?: { abortSignal?: AbortSignal },
+	): AsyncIterable<ShellStreamChunk> | ShellResult;
+}) => Tool;
+
+export function buildShellTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	const createTool = tool as unknown as ShellToolFactory;
+	const shell = createTool({
+		description: DESCRIPTION,
+		inputSchema: shellInputSchema,
+		execute(
+			{ cmd, cwd, allowNonZeroExit, timeout = 300000 }: ShellInput,
+			options?: { abortSignal?: AbortSignal },
+		): AsyncIterable<ShellStreamChunk> | ShellResult {
+			const abortSignal = options?.abortSignal;
+
+			if (abortSignal?.aborted) {
+				return createToolError('Command aborted before execution', 'abort', {
+					cmd,
+				});
+			}
+
+			const absCwd = resolveSafePath(projectRoot, cwd || '.');
+			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
+
+			const proc = spawn(finalCmd, {
+				cwd: absCwd,
+				shell: true,
+				stdio: ['ignore', 'pipe', 'pipe'],
+				env: { ...process.env, PATH: getAugmentedPath() },
+				detached: true,
+			});
+
+			let stdout = '';
+			let stderr = '';
+			let didTimeout = false;
+			let didAbort = false;
+			let settled = false;
+			let done = false;
+			let timeoutId: ReturnType<typeof setTimeout> | null = null;
+			const queue: ShellStreamChunk[] = [];
+			let notify: (() => void) | null = null;
+
+			const wake = () => {
+				if (!notify) return;
+				notify();
+				notify = null;
+			};
+
+			const pushDelta = (text: string) => {
+				if (!text) return;
+				queue.push({ channel: 'output', delta: text });
+				wake();
+			};
+
+			const settle = (result: ShellResult) => {
+				if (settled) return;
+				settled = true;
+				if (timeoutId) clearTimeout(timeoutId);
+				if (abortSignal) {
+					abortSignal.removeEventListener('abort', onAbort);
+				}
+				queue.push({ result });
+				done = true;
+				wake();
+			};
+
+			const onAbort = () => {
+				if (settled) return;
+				didAbort = true;
+				if (proc.pid) killProcessTree(proc.pid);
+				else proc.kill('SIGTERM');
+			};
+
+			if (abortSignal) {
+				abortSignal.addEventListener('abort', onAbort, { once: true });
+			}
+
+			if (timeout > 0) {
+				timeoutId = setTimeout(() => {
+					didTimeout = true;
+					if (proc.pid) killProcessTree(proc.pid);
+					else proc.kill();
+				}, timeout);
+			}
+
+			proc.stdout?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stdout += text;
+				pushDelta(text);
+			});
+
+			proc.stderr?.on('data', (chunk) => {
+				const text = chunk.toString();
+				stderr += text;
+				pushDelta(text);
+			});
+
+			proc.on('close', (exitCode) => {
+				if (didAbort) {
+					settle(
+						createToolError(`Command aborted by user: ${cmd}`, 'abort', {
+							cmd,
+							stdout,
+							stderr,
+						}),
+					);
+					return;
+				}
+
+				if (didTimeout) {
+					settle(
+						createToolError(
+							`Command timed out after ${timeout}ms: ${cmd}`,
+							'timeout',
+							{
+								parameter: 'timeout',
+								value: timeout,
+								stdout,
+								stderr,
+								suggestion: 'Increase timeout or optimize the command',
+							},
+						),
+					);
+					return;
+				}
+
+				if (exitCode !== 0 && !allowNonZeroExit) {
+					const errorDetail = stderr.trim() || stdout.trim() || '';
+					const errorMsg = `Command failed with exit code ${exitCode}${errorDetail ? `\n\n${errorDetail}` : ''}`;
+					settle(
+						createToolError(errorMsg, 'execution', {
+							exitCode,
+							stdout,
+							stderr,
+							cmd,
+							suggestion: 'Check command syntax or use allowNonZeroExit: true',
+						}),
+					);
+					return;
+				}
+
+				settle({
+					ok: true,
+					exitCode: exitCode ?? 0,
+					stdout,
+					stderr,
+				});
+			});
+
+			proc.on('error', (err) => {
+				settle(
+					createToolError(
+						`Command execution failed: ${err.message}`,
+						'execution',
+						{
+							cmd,
+							originalError: err.message,
+						},
+					),
+				);
+			});
+
+			const stream = async function* (): AsyncGenerator<ShellStreamChunk> {
+				while (!done || queue.length > 0) {
+					if (queue.length === 0) {
+						await new Promise<void>((resolve) => {
+							notify = resolve;
+						});
+					}
+					while (queue.length > 0) {
+						const chunk = queue.shift();
+						if (chunk) yield chunk;
+					}
+				}
+			};
+
+			return stream();
+		},
+	}) as unknown as Tool;
+	return { name: 'shell', tool: shell };
+}
+
+export const buildBashTool = buildShellTool;

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

@@ -0,0 +1,13 @@
+- Execute a non-interactive shell command using `bash -lc`
+- Returns `stdout`, `stderr`, and `exitCode`
+- `cwd` is relative to the project root and sandboxed within it
+
+**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.
+
+## Usage tips
+
+- Chain commands with `&&` to fail-fast.
+- For long outputs, redirect to a file and `read` it back.
+- For long-running non-interactive commands, set an appropriate `timeout` and ensure the command exits on its own.
+- Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential shell chains when you need results separately.
+- Never use `shell` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.

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

@@ -1,4 +1,4 @@
-- Manage persistent terminals for long-running processes (dev servers, watchers, build processes)
+- Manage interactive and persistent terminals (REPLs, prompts, dev servers, watchers)
 - Returns terminal information and output
 - Supports creating, reading, writing, listing, and killing terminals
 
@@ -7,7 +7,7 @@
 ### start
 - Spawns a new persistent terminal (interactive shell by default)
 - Returns terminal ID for future operations
-- Use for processes that need to stay alive (dev servers, watchers, logs)
+- Use for commands that need stdin, a TTY, interactive input, or persistence across turns
 - Before starting, call `terminal(operation: "list")` to see if a matching service is already running
 - Provide a clear `purpose` or `title` (e.g. "web dev server port 9100") so humans can recognize it
 - Parameters:
@@ -51,22 +51,25 @@
 - Parameters:
   - terminalId (required): Terminal ID to kill
 
-## When to Use Terminal vs Bash
+## When to Use Terminal vs Shell
 
 ### Use terminal for:
+- Interactive commands that need stdin or a TTY: REPLs, prompts, shells, debuggers
 - Dev servers: npm run dev, bun dev
 - File watchers: bun test --watch, nodemon
 - Build watchers: bun build --watch
 - Log tailing: tail -f logs/app.log
 - Background services: docker compose up
 - Any process that needs to stay alive and produce continuous output
+- Any process you need to read from or write to across turns
 
-### Use bash for:
+### Use shell for:
 - Status checks: git status, ls, ps
 - One-off commands: mkdir, rm, curl
 - Quick scripts: bun run build, git commit
 - File operations: cat, sed, awk
-- Short-lived commands with immediate output
+- Non-interactive long-running commands that finish on their own (set an appropriate timeout)
+- Any command that does not need stdin, a TTY, or follow-up interaction
 
 ## Example Workflow
 
@@ -83,7 +86,7 @@
 
 ## Notes
 
-- Terminals persist across multiple LLM turns (unlike bash commands)
+- Terminals persist across multiple LLM turns (unlike shell commands)
 - Maximum 10 terminals per session
 - Exited terminals auto-cleanup after 5 minutes
 - Output is buffered (last 500 lines kept)

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

@@ -4,7 +4,7 @@ import { finishTool } from './builtin/finish.ts';
 import { buildFsTools } from './builtin/fs/index.ts';
 import { buildGitTools } from './builtin/git.ts';
 import { progressUpdateTool } from './builtin/progress.ts';
-import { buildBashTool } from './builtin/bash.ts';
+import { buildShellTool } from './builtin/shell.ts';
 import { buildRipgrepTool } from './builtin/ripgrep.ts';
 import { buildGlobTool } from './builtin/glob.ts';
 import { buildApplyPatchTool } from './builtin/patch.ts';
@@ -147,8 +147,8 @@ async function discoverStaticProjectTools(
 		// Built-ins
 		tools.set('finish', finishTool);
 		tools.set('progress_update', progressUpdateTool);
-		const bash = buildBashTool(projectRoot);
-		tools.set(bash.name, bash.tool);
+		const shell = buildShellTool(projectRoot);
+		tools.set(shell.name, shell.tool);
 		// Search
 		const rg = buildRipgrepTool(projectRoot);
 		tools.set(rg.name, rg.tool);

package/src/index.ts

@@ -40,6 +40,18 @@ export type {
 // Providers (from internal providers module)
 // =======================
 export { catalog } from './providers/src/index.ts';
+export {
+	DEFAULT_REMOTE_MODEL_CATALOG_URL,
+	getModelCatalogCachePath,
+	mergeCachedModelCatalog,
+	normalizeModelCatalogPayload,
+	readCachedModelCatalog,
+	writeCachedModelCatalog,
+} from './providers/src/index.ts';
+export type {
+	CachedModelCatalog,
+	CachedProviderCatalogEntry,
+} from './providers/src/index.ts';
 export {
 	isProviderId,
 	providerIds,

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

@@ -18,13 +18,13 @@ Pick the right tool for the job (each tool's description has its full contract):
 
 After making changes:
 
-1. Run project-specific build/lint/test commands with `bash` (check `package.json`, `README.md`, or `AGENTS.md` for the right command).
+1. Run project-specific build/lint/test commands with `shell` (check `package.json`, `README.md`, or `AGENTS.md` for the right command).
 2. Review diffs with `git_status` / `git_diff`.
 3. Do NOT commit unless the user explicitly asks. It is very important to only commit when asked.
 
 ## Terminal tool — when to use
 
-- Prefer `terminal` over `bash` for long-lived processes (dev servers, watchers, log tailing). `bash` is for one-off commands with immediate output.
+- Prefer `terminal` over `shell` for interactive or persistent processes (dev servers, watchers, log tailing). `shell` is for one-off non-interactive commands.
 - List existing terminals before starting a new one; reuse when possible to avoid duplicate services.
 - Give each terminal a clear `purpose` / `title` (e.g. "web dev server 9100").
 - Mention active terminals (purpose, command, port) in your responses so humans know what's running.

package/src/prompts/src/modes/guided.txt

@@ -4,7 +4,7 @@ GUIDED MODE is active. This OVERRIDES all conciseness and brevity instructions.
 The user is NOT a developer. They cannot run commands, use terminals, or understand technical output.
 
 YOU MUST:
-- USE YOUR TOOLS to execute every action. Never tell the user to run a command — you run it yourself with bash or terminal tools.
+- USE YOUR TOOLS to execute every action. Never tell the user to run a command — you run it yourself with shell or terminal tools.
 - NEVER ask permission or say "Want me to...?" — just do it immediately.
 - NEVER respond with just instructions or steps. Every response must include actual tool calls that do the work.
 - Check if services are already running before starting them. If not running, start them yourself.
@@ -12,7 +12,7 @@ YOU MUST:
 - Tell the user the exact URL to open and what they'll see there.
 - Explain what you DID (past tense) in simple language — not what they should do.
 - If something fails, fix it yourself silently. Only tell the user once it's resolved.
-- Use the terminal tool (not bash) for long-running services so they persist.
+- Use the terminal tool (not shell) for interactive or persistent services so they persist.
 - Verbose, friendly responses are expected in this mode — ignore any "be concise" instructions.
 
 WRONG response: "Run `bun dev` in the project root, then open http://localhost:9100"

package/src/prompts/src/providers/anthropic.txt

@@ -62,7 +62,7 @@ user: which file contains the implementation of foo?
 assistant: src/foo.c
 </example>
 
-When you run a non-trivial bash command — especially one that changes state — briefly explain what it does and why, so the user knows what's happening.
+When you run a non-trivial shell command — especially one that changes state — briefly explain what it does and why, so the user knows what's happening.
 
 # Proactiveness
 
@@ -99,7 +99,7 @@ For software engineering requests (bugs, features, refactors, explanations):
 1. Use `update_todos` to plan multi-step work.
 2. Explore the codebase with the search tools (`glob`, `ripgrep`, `tree`, `read`). Batch independent searches in parallel.
 3. Implement the solution.
-4. Verify — run the project's build/lint/test commands with `bash`. Check `README.md` / `AGENTS.md` to find the right command.
+4. Verify — run the project's build/lint/test commands with `shell`. Check `README.md` / `AGENTS.md` to find the right command.
 5. Review diffs with `git_status` / `git_diff`.
 6. NEVER commit unless the user explicitly asks.
 

package/src/prompts/src/providers/default.txt

@@ -27,7 +27,7 @@ You are a coding agent running in otto, a terminal-based coding assistant. Preci
 1. Understand — use `glob`, `ripgrep`, `tree`, `read` to map the code. Batch independent searches.
 2. Plan — use `update_todos` for multi-step work. Mark one step `in_progress` at a time.
 3. Implement — prefer the targeted editing tools available to you for small in-file changes; use patch-style edits for structural or multi-file changes when available; use `write` only for new files or near-total rewrites.
-4. Verify — run project-specific build/lint/test commands via `bash`. Check `README.md` / `AGENTS.md` for the right command.
+4. Verify — run project-specific build/lint/test commands via `shell`. Check `README.md` / `AGENTS.md` for the right command.
 5. Review — `git_status` / `git_diff`. Do NOT commit unless asked.
 
 # Direct file references

package/src/prompts/src/providers/glm.txt

@@ -39,7 +39,7 @@ Your reasoning is powerful, but it can override what you actually read. Guard ag
 1. Understand — use `glob`, `ripgrep`, `tree`, `read` to map the code. Batch independent searches.
 2. Plan — use `update_todos` for multi-step work. Mark one step `in_progress` at a time.
 3. Implement — prefer the targeted editing tools available to you for small in-file changes; use patch-style edits for structural or multi-file changes when available; use `write` only for new files or near-total rewrites.
-4. Verify — run project-specific build/lint/test commands via `bash`. Check `README.md` / `AGENTS.md` for the right command.
+4. Verify — run project-specific build/lint/test commands via `shell`. Check `README.md` / `AGENTS.md` for the right command.
 5. Review — `git_status` / `git_diff`. Do NOT commit unless asked.
 
 # Direct file references

package/src/prompts/src/providers/google.txt

@@ -30,7 +30,7 @@ For bug fixes, features, refactors, or explanations:
 1. **Understand requirements** — features, UX, platform, constraints. Ask targeted clarification questions if critical info is missing.
 2. **Propose plan.** Present a concise high-level summary (type, core purpose, key technologies, main features, visual/UX approach). For visual assets, describe the strategy for placeholders (geometric shapes, procedural patterns, open-source assets).
 3. **User approval.** Obtain approval before implementing.
-4. **Implement** autonomously. Scaffold with `bash` (`npm init`, `npx create-react-app`, etc.). Create placeholder assets when needed; aim for a visually coherent prototype.
+4. **Implement** autonomously. Scaffold with `shell` (`npm init`, `npx create-react-app`, etc.). Create placeholder assets when needed; aim for a visually coherent prototype.
 5. **Verify** against the original request and approved plan. Fix bugs, deviations, placeholders. Ensure the build produces no compile errors.
 6. **Solicit feedback** — provide start-up instructions and ask for feedback.
 
@@ -48,14 +48,14 @@ For bug fixes, features, refactors, or explanations:
 
 ## Security and safety
 
-- **Explain critical commands.** Before executing `bash` commands that modify the file system or system state, briefly explain purpose and potential impact. Don't ask permission — the user will confirm via dialog.
+- **Explain critical commands.** Before executing `shell` commands that modify the file system or system state, briefly explain purpose and potential impact. Don't ask permission — the user will confirm via dialog.
 - **Security first.** Apply security best practices. Never expose, log, or commit secrets, API keys, or sensitive information.
 
 ## Tool usage
 
 - **Parallelism.** Execute multiple independent tool calls in parallel when feasible (e.g. codebase searches).
-- **Command execution.** Use `bash` for shell commands; explain modifying commands first.
-- **Background processes.** Use `&` for long-running processes that don't stop on their own (e.g. `node server.js &`). If unsure, ask. Prefer the `terminal` tool for processes you'll monitor over multiple turns.
+- **Command execution.** Use `shell` for non-interactive shell commands; explain modifying commands first.
+- **Background processes.** Prefer the `terminal` tool for interactive or persistent processes you'll monitor over multiple turns. Use `shell` only for non-interactive commands that finish on their own.
 - **Interactive commands.** Avoid commands that require user interaction (e.g. `git rebase -i`). Prefer non-interactive versions (`npm init -y`).
 - **Confirmations.** If the user cancels a tool call, respect their choice — don't retry unless they ask again.
 
@@ -78,7 +78,7 @@ model: [tool_call: ls for path '/path/to/project']
 
 <example>
 user: start the server implemented in server.js
-model: [tool_call: bash for 'node server.js &' because it must run in the background]
+model: [tool_call: terminal for 'node server.js' because it must stay running]
 </example>
 
 <example>
@@ -105,7 +105,7 @@ user: Yes
 model:
 [tool_call: use the appropriate available file-editing tool to apply the refactoring to 'src/auth.py']
 Refactoring complete. Running verification...
-[tool_call: bash for 'ruff check src/auth.py && pytest']
+[tool_call: shell for 'ruff check src/auth.py && pytest']
 (After verification passes)
 All checks passed. This is a stable checkpoint.
 </example>
@@ -125,7 +125,7 @@ Now I'll look for existing or related test files to understand current testing c
 (After reviewing existing tests and the file content)
 [tool_call: write to create /path/to/someFile.test.ts with the test code]
 I've written the tests. Now I'll run the project's test command to verify them.
-[tool_call: bash for 'npm run test']
+[tool_call: shell for 'npm run test']
 </example>
 
 <example>

package/src/prompts/src/providers/moonshot.txt

@@ -39,7 +39,7 @@ Your reasoning is powerful, but it can override what you actually read. Guard ag
 1. Understand — use `glob`, `ripgrep`, `tree`, `read` to map the code. Batch independent searches.
 2. Plan — use `update_todos` for multi-step work. Mark one step `in_progress` at a time.
 3. Implement — prefer the targeted editing tools available to you for small in-file changes; use patch-style edits for structural or multi-file changes when available; use `write` only for new files or near-total rewrites.
-4. Verify — run project-specific build/lint/test commands via `bash`. Check `README.md` / `AGENTS.md` for the right command.
+4. Verify — run project-specific build/lint/test commands via `shell`. Check `README.md` / `AGENTS.md` for the right command.
 5. Review — `git_status` / `git_diff`. Do NOT commit unless asked.
 
 # Direct file references

package/src/providers/src/catalog.ts

@@ -881,6 +881,32 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 128000,
 					},
 				},
+				{
+					id: 'gpt-5.5',
+					ownedBy: 'openai',
+					label: 'GPT-5.5',
+					modalities: {
+						input: ['text', 'image', 'pdf'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: false,
+					knowledge: '2025-12-01',
+					releaseDate: '2026-04-23',
+					lastUpdated: '2026-04-23',
+					openWeights: false,
+					cost: {
+						input: 5,
+						output: 30,
+						cacheRead: 0.5,
+					},
+					limit: {
+						context: 1050000,
+						output: 130000,
+					},
+				},
 				{
 					id: 'gpt-image-1',
 					ownedBy: 'openai',
@@ -2813,7 +2839,7 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					},
 				},
 				{
-					id: 'gemma-4-26b-it',
+					id: 'gemma-4-26b-a4b-it',
 					ownedBy: 'google',
 					label: 'Gemma 4 26B',
 					modalities: {
@@ -4934,6 +4960,31 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 262144,
 					},
 				},
+				{
+					id: 'moonshotai/kimi-k2.6',
+					ownedBy: 'moonshot',
+					label: 'Kimi K2.6',
+					modalities: {
+						input: ['text', 'image'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: true,
+					releaseDate: '2026-04-20',
+					lastUpdated: '2026-04-20',
+					openWeights: true,
+					cost: {
+						input: 0.95,
+						output: 4,
+						cacheRead: 0.16,
+					},
+					limit: {
+						context: 262144,
+						output: 262144,
+					},
+				},
 				{
 					id: 'nousresearch/hermes-3-llama-3.1-405b:free',
 					label: 'Hermes 3 405B Instruct (free)',
@@ -5707,9 +5758,9 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-03-17',
 					openWeights: false,
 					cost: {
-						input: 7.5e-7,
-						output: 0.0000045,
-						cacheRead: 7.5e-8,
+						input: 0.75,
+						output: 4.5,
+						cacheRead: 0.075,
 					},
 					limit: {
 						context: 400000,
@@ -5733,9 +5784,9 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 					lastUpdated: '2026-03-17',
 					openWeights: false,
 					cost: {
-						input: 2e-7,
-						output: 0.00000125,
-						cacheRead: 2e-8,
+						input: 0.2,
+						output: 1.25,
+						cacheRead: 0.02,
 					},
 					limit: {
 						context: 400000,
@@ -8141,6 +8192,31 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 256000,
 					},
 				},
+				{
+					id: 'hy3-preview-free',
+					label: 'Hy3 preview Free',
+					modalities: {
+						input: ['text'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: false,
+					temperature: true,
+					knowledge: '2025-06',
+					releaseDate: '2026-04-20',
+					lastUpdated: '2026-04-20',
+					openWeights: true,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+					},
+					limit: {
+						context: 256000,
+						output: 64000,
+					},
+				},
 				{
 					id: 'kimi-k2',
 					ownedBy: 'moonshot',
@@ -8245,6 +8321,56 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 262144,
 					},
 				},
+				{
+					id: 'kimi-k2.6',
+					ownedBy: 'moonshot',
+					label: 'Kimi K2.6',
+					modalities: {
+						input: ['text', 'image', 'video'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: true,
+					knowledge: '2024-10',
+					releaseDate: '2026-04-21',
+					lastUpdated: '2026-04-21',
+					openWeights: true,
+					cost: {
+						input: 0.95,
+						output: 4,
+						cacheRead: 0.16,
+					},
+					limit: {
+						context: 262144,
+						output: 65536,
+					},
+				},
+				{
+					id: 'ling-2.6-flash-free',
+					label: 'Ling 2.6 Flash Free',
+					modalities: {
+						input: ['text'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: false,
+					attachment: false,
+					temperature: true,
+					knowledge: '2025-06',
+					releaseDate: '2026-04-21',
+					lastUpdated: '2026-04-21',
+					openWeights: true,
+					cost: {
+						input: 0,
+						output: 0,
+					},
+					limit: {
+						context: 262100,
+						output: 32800,
+					},
+				},
 				{
 					id: 'mimo-v2-flash-free',
 					label: 'MiMo V2 Flash Free',
@@ -8430,6 +8556,32 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						npm: '@ai-sdk/anthropic',
 					},
 				},
+				{
+					id: 'minimax-m2.7',
+					ownedBy: 'minimax',
+					label: 'MiniMax M2.7',
+					modalities: {
+						input: ['text'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: false,
+					temperature: true,
+					knowledge: '2025-01',
+					releaseDate: '2026-03-18',
+					lastUpdated: '2026-03-18',
+					openWeights: true,
+					cost: {
+						input: 0.3,
+						output: 1.2,
+						cacheRead: 0.06,
+					},
+					limit: {
+						context: 204800,
+						output: 131072,
+					},
+				},
 				{
 					id: 'nemotron-3-super-free',
 					label: 'Nemotron 3 Super Free',
@@ -8505,7 +8657,7 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 65536,
 					},
 					provider: {
-						npm: '@ai-sdk/alibaba',
+						npm: '@ai-sdk/anthropic',
 					},
 				},
 				{
@@ -8534,7 +8686,7 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 65536,
 					},
 					provider: {
-						npm: '@ai-sdk/alibaba',
+						npm: '@ai-sdk/anthropic',
 					},
 				},
 				{
@@ -9458,6 +9610,32 @@ export const catalog: Partial<Record<BuiltInProviderId, ProviderCatalogEntry>> =
 						output: 262144,
 					},
 				},
+				{
+					id: 'kimi-k2.6',
+					ownedBy: 'moonshot',
+					label: 'Kimi K2.6',
+					modalities: {
+						input: ['text', 'image', 'video'],
+						output: ['text'],
+					},
+					toolCall: true,
+					reasoningText: true,
+					attachment: true,
+					temperature: true,
+					knowledge: '2025-01',
+					releaseDate: '2026-04-21',
+					lastUpdated: '2026-04-21',
+					openWeights: true,
+					cost: {
+						input: 0.95,
+						output: 4,
+						cacheRead: 0.16,
+					},
+					limit: {
+						context: 262144,
+						output: 262144,
+					},
+				},
 			],
 			label: 'Moonshot AI',
 			env: ['MOONSHOT_API_KEY'],

package/src/providers/src/index.ts

@@ -1,5 +1,17 @@
 export { isProviderAuthorized, ensureProviderEnv } from './authorization.ts';
 export { catalog } from './catalog-merged.ts';
+export {
+	DEFAULT_REMOTE_MODEL_CATALOG_URL,
+	getModelCatalogCachePath,
+	mergeCachedModelCatalog,
+	normalizeModelCatalogPayload,
+	readCachedModelCatalog,
+	writeCachedModelCatalog,
+} from './model-catalog-cache.ts';
+export type {
+	CachedModelCatalog,
+	CachedProviderCatalogEntry,
+} from './model-catalog-cache.ts';
 export type {
 	BuiltInProviderId,
 	ProviderId,

package/src/providers/src/model-catalog-cache.ts

@@ -0,0 +1,107 @@
+import { getGlobalConfigDir, joinPath } from '../../config/src/paths.ts';
+import type { ModelInfo, ProviderId } from '../../types/src/index.ts';
+
+export type CachedProviderCatalogEntry = {
+	id: ProviderId;
+	label?: string;
+	models: ModelInfo[];
+};
+
+export type CachedModelCatalog = {
+	version: 1;
+	updatedAt: string;
+	providers: Record<string, CachedProviderCatalogEntry>;
+};
+
+export const DEFAULT_REMOTE_MODEL_CATALOG_URL =
+	'https://ottocode.io/catalog/models.json';
+
+export function getModelCatalogCachePath(): string {
+	return joinPath(getGlobalConfigDir(), 'models-catalog.json');
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function normalizeProviderEntry(
+	id: string,
+	value: unknown,
+): CachedProviderCatalogEntry | null {
+	if (!isRecord(value)) return null;
+	const models = Array.isArray(value.models)
+		? value.models.filter(
+				(model): model is ModelInfo =>
+					isRecord(model) && typeof model.id === 'string',
+			)
+		: [];
+	return {
+		id: (typeof value.id === 'string' ? value.id : id) as ProviderId,
+		label: typeof value.label === 'string' ? value.label : undefined,
+		models,
+	};
+}
+
+export function normalizeModelCatalogPayload(
+	payload: unknown,
+): Record<string, CachedProviderCatalogEntry> {
+	if (!isRecord(payload)) return {};
+	const source = isRecord(payload.providers) ? payload.providers : payload;
+	const providers: Record<string, CachedProviderCatalogEntry> = {};
+	for (const [id, value] of Object.entries(source)) {
+		const entry = normalizeProviderEntry(id, value);
+		if (entry) providers[id] = entry;
+	}
+	return providers;
+}
+
+export async function readCachedModelCatalog(): Promise<CachedModelCatalog | null> {
+	try {
+		const file = Bun.file(getModelCatalogCachePath());
+		if (!(await file.exists())) return null;
+		const payload = await file.json();
+		const providers = normalizeModelCatalogPayload(payload);
+		return {
+			version: 1,
+			updatedAt:
+				isRecord(payload) && typeof payload.updatedAt === 'string'
+					? payload.updatedAt
+					: new Date(0).toISOString(),
+			providers,
+		};
+	} catch {
+		return null;
+	}
+}
+
+export async function writeCachedModelCatalog(
+	providers: Record<string, CachedProviderCatalogEntry>,
+): Promise<void> {
+	const path = getModelCatalogCachePath();
+	const dir = path.slice(0, path.lastIndexOf('/'));
+	await import('node:fs/promises').then((fs) =>
+		fs.mkdir(dir, { recursive: true }),
+	);
+	await Bun.write(
+		path,
+		JSON.stringify(
+			{
+				version: 1,
+				updatedAt: new Date().toISOString(),
+				providers,
+			},
+			null,
+			2,
+		),
+	);
+}
+
+export async function mergeCachedModelCatalog(
+	providers: Record<string, CachedProviderCatalogEntry>,
+): Promise<void> {
+	const existing = await readCachedModelCatalog();
+	await writeCachedModelCatalog({
+		...(existing?.providers ?? {}),
+		...providers,
+	});
+}

package/src/providers/src/oauth-models.ts

@@ -21,6 +21,7 @@ const OAUTH_MODEL_IDS: Partial<Record<ProviderId, string[]>> = {
 		'gpt-5.3-codex',
 		'gpt-5.4',
 		'gpt-5.4-mini',
+		'gpt-5.5',
 	],
 };
 

package/src/providers/src/registry.ts

@@ -133,7 +133,7 @@ export function getProviderDefinition(
 			source: 'built-in',
 			compatibility: BUILTIN_COMPATIBILITY[provider],
 			family: BUILTIN_FAMILY[provider],
-			baseURL: normalizeOptionalText(settings?.baseURL),
+			baseURL: normalizeOptionalText(settings?.baseURL) ?? entry.api,
 			apiKey: normalizeOptionalText(settings?.apiKey),
 			apiKeyEnv:
 				normalizeOptionalText(settings?.apiKeyEnv) ?? providerEnvVar(provider),

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

@@ -1,12 +0,0 @@
-- Execute a one-off shell command using `bash -lc`
-- Returns `stdout`, `stderr`, and `exitCode`
-- `cwd` is relative to the project root and sandboxed within it
-
-**Use `bash` for short-lived commands.** For long-running processes (dev servers, watchers, log tailing) use the `terminal` tool instead — terminals persist across turns.
-
-## Usage tips
-
-- Chain commands with `&&` to fail-fast.
-- For long outputs, redirect to a file and `read` it back.
-- Batch independent checks (e.g. `git status && git diff`) in parallel tool calls rather than sequential bash chains when you need results separately.
-- Never use `bash` with `sed`/`awk` for programmatic file editing — use the dedicated file-editing tools instead.