@ottocode/sdk 0.1.304 → 0.1.306

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/sdk",
-	"version": "0.1.304",
+	"version": "0.1.306",
 	"description": "AI agent SDK for building intelligent assistants - tree-shakable and comprehensive",
 	"author": "nitishxyz",
 	"license": "MIT",
@@ -105,7 +105,7 @@
 		"@ai-sdk/provider": "3.0.10",
 		"@ai-sdk/provider-utils": "4.0.27",
 		"@ai-sdk/xai": "3.0.93",
-		"@ff-labs/fff-bun": "0.9.3",
+		"@ff-labs/fff-bun": "0.9.4",
 		"@modelcontextprotocol/sdk": "1.27.1",
 		"@openauthjs/openauth": "0.4.3",
 		"@openrouter/ai-sdk-provider": "1.5.4",

package/src/core/src/index.ts

@@ -55,6 +55,7 @@ export { buildTerminalTool } from './tools/builtin/terminal';
 export {
 	buildLazyToolsRecord,
 	buildLoadFirstPartyToolsTool,
+	buildMCPManagerTool,
 	buildSimulatorTool,
 	getLazyToolDefinitions,
 } from './tools/lazy/index';

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

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { spawn, execSync } from 'node:child_process';
+import { spawn, execFileSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import {
 	clearCachedBinaries,
@@ -10,7 +10,10 @@ import { fileExists, isExecutable } from './bin-manager/filesystem.ts';
 import { getAgiBinDir, getBinaryFileName } from './bin-manager/paths.ts';
 import { extractFromVendor } from './bin-manager/vendor.ts';
 
-let cachedLoginPath: string | null = null;
+let cachedLoginPath: {
+	key: string;
+	path: string | null;
+} | null = null;
 
 export { getAgiBinDir } from './bin-manager/paths.ts';
 
@@ -64,15 +67,61 @@ export function clearBinaryCache(): void {
 	clearCachedBinaries();
 }
 
-function getLoginShellPath(): string | null {
-	if (cachedLoginPath !== null) return cachedLoginPath;
+export function getUserShell(): string {
+	if (process.platform === 'win32') return process.env.COMSPEC || 'cmd.exe';
+	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): {
+	command: string;
+	args: string[];
+	env: NodeJS.ProcessEnv;
+} {
+	const env = { ...process.env, PATH: getAugmentedPath() };
 	if (process.platform === 'win32') {
-		cachedLoginPath = process.env.PATH || '';
-		return cachedLoginPath;
+		return {
+			command: getUserShell(),
+			args: ['/d', '/s', '/c', cmd],
+			env,
+		};
 	}
 
+	const command = getUserShell();
+	return {
+		command,
+		args: [getInteractiveShellFlag(command), 'eval "$OTTO_SHELL_COMMAND"'],
+		env: { ...env, OTTO_SHELL_COMMAND: cmd },
+	};
+}
+
+function getLoginShellPath(): string | null {
 	const home = process.env.HOME || homedir();
+	const userShell = getUserShell();
+	const cacheKey = [home, userShell, process.env.PATH || ''].join('\0');
+	if (cachedLoginPath?.key === cacheKey) return cachedLoginPath.path;
+
+	if (process.platform === 'win32') {
+		cachedLoginPath = { key: cacheKey, path: process.env.PATH || '' };
+		return cachedLoginPath.path;
+	}
+
 	const shellCandidates = [
 		process.env.SHELL,
 		'/bin/zsh',
@@ -82,21 +131,28 @@ function getLoginShellPath(): string | null {
 
 	for (const shell of shellCandidates) {
 		try {
-			const result = execSync(`${shell} -ilc 'echo "___PATH___:$PATH"'`, {
+			const rcBootstrap = getShellRcBootstrap(shell);
+			const pathCommand = `${rcBootstrap ? `${rcBootstrap}\n` : ''}echo "___PATH___:$PATH"`;
+			const result = execFileSync(shell, ['-ilc', pathCommand], {
 				timeout: 5000,
 				stdio: ['ignore', 'pipe', 'ignore'],
-				env: { HOME: home, USER: process.env.USER || '', SHELL: shell },
+				env: {
+					...process.env,
+					HOME: home,
+					USER: process.env.USER || '',
+					SHELL: shell,
+				},
 			});
 			const output = result.toString();
 			const match = output.match(/___PATH___:(.*)/);
 			if (match?.[1]?.trim()) {
-				cachedLoginPath = match[1].trim();
-				return cachedLoginPath;
+				cachedLoginPath = { key: cacheKey, path: match[1].trim() };
+				return cachedLoginPath.path;
 			}
 		} catch {}
 	}
 
-	cachedLoginPath = null;
+	cachedLoginPath = { key: cacheKey, path: null };
 	return null;
 }
 

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

@@ -26,7 +26,10 @@ export const IGNORE_PATTERNS: string[] = [
 ];
 
 export function defaultIgnoreGlobs(extra?: string[]): string[] {
-	const base = IGNORE_PATTERNS.map((p) => `!${p}*`);
+	const base = IGNORE_PATTERNS.flatMap((p) => {
+		const pattern = p.replace(/\/$/, '');
+		return [`${pattern}/**`, `**/${pattern}/**`];
+	});
 	if (Array.isArray(extra) && extra.length) return base.concat(extra);
 	return base;
 }

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 { getAugmentedPath } from '../bin-manager.ts';
+import { getShellExecutionConfig } from '../bin-manager.ts';
 import { createToolError, type ToolResponse } from '../error.ts';
 import { injectCoAuthorIntoGitCommit } from './git-identity.ts';
 
@@ -47,17 +47,6 @@ export type ShellOutputMode = 'auto' | 'full' | 'tail';
 const DEFAULT_TAIL_LINES = 100;
 const DEFAULT_MAX_OUTPUT_BYTES = 128_000;
 
-function looksLikeRepositorySearchCommand(cmd: string): boolean {
-	const normalized = cmd.replace(/\s+/g, ' ').trim();
-	return (
-		/(^|[;&|()]\s*)(rg|ripgrep)(\s|$)/.test(normalized) ||
-		/(^|[;&|()]\s*)grep\s+.*\s(-R|-r|--recursive)(\s|$)/.test(normalized) ||
-		/(^|[;&|()]\s*)find\s+(\.|\.\/|\$PWD|\S*\/).*(-name|-iname|-path|-type)/.test(
-			normalized,
-		)
-	);
-}
-
 type CompactTextResult = {
 	text: string;
 	truncated: boolean;
@@ -147,7 +136,9 @@ const shellInputSchema = z
 	.object({
 		cmd: z
 			.string()
-			.describe('Non-interactive shell command to run (bash -c <cmd>)'),
+			.describe(
+				'Non-interactive shell command to run using the user shell with login/interactive startup loaded',
+			),
 		cwd: z
 			.string()
 			.default('.')
@@ -231,18 +222,6 @@ export function buildShellTool(projectRoot: string): {
 				});
 			}
 
-			if (looksLikeRepositorySearchCommand(cmd)) {
-				return createToolError(
-					'This looks like repository discovery. Use the search tool for content/code search or glob for filename/path discovery.',
-					'validation',
-					{
-						cmd,
-						suggestion:
-							'Use search for file contents, or glob for file and path discovery.',
-					},
-				);
-			}
-
 			const absCwd = resolveSafePath(projectRoot, cwd || '.');
 			const finalCmd = injectCoAuthorIntoGitCommit(cmd);
 			const shellExecutor = shellExecutorContext.getStore();
@@ -261,11 +240,11 @@ export function buildShellTool(projectRoot: string): {
 				) as AsyncIterable<ShellStreamChunk> | ShellResult;
 			}
 
-			const proc = spawn(finalCmd, {
+			const shellConfig = getShellExecutionConfig(finalCmd);
+			const proc = spawn(shellConfig.command, shellConfig.args, {
 				cwd: absCwd,
-				shell: true,
 				stdio: ['ignore', 'pipe', 'pipe'],
-				env: { ...process.env, PATH: getAugmentedPath() },
+				env: shellConfig.env,
 				detached: true,
 			});
 

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

@@ -1,4 +1,4 @@
-- Execute a non-interactive shell command using `bash -lc`
+- Execute a non-interactive shell command using the user's shell with login/interactive startup loaded
 - Returns `stdout`, `stderr`, and `exitCode`
 - `cwd` is relative to the project root and sandboxed within it
 

package/src/core/src/tools/lazy/index.ts

@@ -10,3 +10,4 @@ export {
 	type LazyToolDefinition,
 } from './registry.ts';
 export { buildSimulatorTool } from './simulator.ts';
+export { buildMCPManagerTool } from './mcp-manager.ts';

package/src/core/src/tools/lazy/mcp-manager.ts

@@ -0,0 +1,385 @@
+import { tool, type Tool } from 'ai';
+import { z } from 'zod/v3';
+import { getGlobalConfigDir } from '../../../../config/src/paths.ts';
+import {
+	addMCPServerToConfig,
+	getMCPManager,
+	initializeMCP,
+	loadMCPConfig,
+	removeMCPServerFromConfig,
+} from '../../mcp/lifecycle.ts';
+import type {
+	MCPScope,
+	MCPServerConfig,
+	MCPServerStatus,
+	MCPTransport,
+} from '../../mcp/types.ts';
+import { createToolError } from '../error.ts';
+
+const mcpActions = [
+	'list',
+	'add',
+	'update',
+	'remove',
+	'enable',
+	'disable',
+] as const;
+
+type MCPManagerAction = (typeof mcpActions)[number];
+
+type ServerSummary = {
+	name: string;
+	transport: MCPTransport;
+	scope: MCPScope;
+	disabled: boolean;
+	command?: string;
+	args?: string[];
+	url?: string;
+	connected: boolean;
+	tools: string[];
+	error?: string;
+};
+
+function summarizeServer(
+	server: MCPServerConfig,
+	status?: MCPServerStatus,
+): ServerSummary {
+	return {
+		name: server.name,
+		transport: server.transport ?? 'stdio',
+		scope: server.scope ?? 'global',
+		disabled: server.disabled ?? false,
+		...(server.command ? { command: server.command } : {}),
+		...(server.args?.length ? { args: server.args } : {}),
+		...(server.url ? { url: server.url } : {}),
+		connected: status?.connected ?? false,
+		tools: status?.tools ?? [],
+		...(status?.error ? { error: status.error } : {}),
+	};
+}
+
+async function getStatuses(): Promise<MCPServerStatus[]> {
+	const manager = getMCPManager();
+	if (!manager) return [];
+	try {
+		return await manager.getStatusAsync();
+	} catch {
+		return [];
+	}
+}
+
+async function startServer(
+	projectRoot: string,
+	server: MCPServerConfig,
+): Promise<MCPServerStatus | undefined> {
+	let manager = getMCPManager();
+	if (!manager) {
+		manager = await initializeMCP({ servers: [] }, projectRoot);
+	}
+	if (!manager.started) {
+		manager.setProjectRoot(projectRoot);
+	}
+	await manager.restartServer(server);
+	const statuses = await manager.getStatusAsync();
+	return statuses.find((status) => status.name === server.name);
+}
+
+async function stopServer(name: string): Promise<void> {
+	const manager = getMCPManager();
+	if (!manager) return;
+	await manager.stopServer(name);
+}
+
+type MCPManagerInput = {
+	action: MCPManagerAction;
+	name?: string;
+	scope?: MCPScope;
+	transport?: MCPTransport;
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	start?: boolean;
+};
+
+function validateServerInput(
+	input: MCPManagerInput,
+	existing?: MCPServerConfig,
+):
+	| { ok: true; server: MCPServerConfig }
+	| { ok: false; error: ReturnType<typeof createToolError> } {
+	const name = input.name?.trim();
+	if (!name) {
+		return {
+			ok: false,
+			error: createToolError('name is required', 'validation', {
+				parameter: 'name',
+			}),
+		};
+	}
+
+	const transport: MCPTransport =
+		input.transport ?? existing?.transport ?? 'stdio';
+	const command = input.command ?? existing?.command;
+	const url = input.url ?? existing?.url;
+
+	if (transport === 'stdio' && !command) {
+		return {
+			ok: false,
+			error: createToolError(
+				'command is required for stdio transport',
+				'validation',
+				{ parameter: 'command' },
+			),
+		};
+	}
+	if (transport === 'stdio' && command && /^https?:\/\//i.test(command)) {
+		return {
+			ok: false,
+			error: createToolError(
+				'stdio transport requires a local command, not a URL. Use http or sse transport for remote servers.',
+				'validation',
+				{ parameter: 'command', value: command },
+			),
+		};
+	}
+	if ((transport === 'http' || transport === 'sse') && !url) {
+		return {
+			ok: false,
+			error: createToolError(
+				'url is required for http/sse transport',
+				'validation',
+				{ parameter: 'url' },
+			),
+		};
+	}
+
+	const scope: MCPScope =
+		input.scope ?? existing?.scope ?? ('global' as MCPScope);
+	const args = input.args ?? existing?.args;
+	const env = input.env ?? existing?.env;
+	const headers = input.headers ?? existing?.headers;
+
+	const server: MCPServerConfig = {
+		name,
+		transport,
+		scope,
+		...(command ? { command } : {}),
+		...(args?.length ? { args } : {}),
+		...(env && Object.keys(env).length ? { env } : {}),
+		...(url ? { url } : {}),
+		...(headers && Object.keys(headers).length ? { headers } : {}),
+		...(existing?.oauth ? { oauth: existing.oauth } : {}),
+		...(existing?.cwd ? { cwd: existing.cwd } : {}),
+		...(existing?.disabled ? { disabled: existing.disabled } : {}),
+	};
+
+	return { ok: true, server };
+}
+
+/**
+ * Build the `mcp_manager` lazy tool which lets an agent list, add, update,
+ * remove, enable, or disable MCP servers in the otto project (.otto/config.json)
+ * or global (~/.config/otto/config.json) configuration.
+ */
+export function buildMCPManagerTool(projectRoot: string): {
+	name: string;
+	tool: Tool;
+} {
+	return {
+		name: 'mcp_manager',
+		tool: tool({
+			description: `Manage otto MCP (Model Context Protocol) servers.
+
+Actions:
+- list: list configured MCP servers with scope, disabled flag, and connection status
+- add: add a new MCP server (upserts if the name already exists)
+- update: update an existing MCP server; omitted fields keep their current values
+- remove: stop and delete an MCP server from config
+- enable: clear the disabled flag and start the server
+- disable: set the disabled flag and stop the server
+
+Scope:
+- "project" writes to <project>/.otto/config.json (shared with the repo)
+- "global" writes to the user's global otto config (default)
+
+Transports:
+- stdio requires "command" (plus optional "args"/"env")
+- http/sse require "url" (plus optional "headers")
+
+Set "start": true on add/update to start the server immediately. Newly started servers expose their tools via load_mcp_tools on the next session turn.`,
+			inputSchema: z.object({
+				action: z.enum(mcpActions).describe('Operation to perform.'),
+				name: z
+					.string()
+					.optional()
+					.describe('MCP server name (required for all actions except list).'),
+				scope: z
+					.enum(['global', 'project'])
+					.optional()
+					.describe(
+						'Config scope: "project" (.otto/config.json) or "global" (default for new servers).',
+					),
+				transport: z
+					.enum(['stdio', 'http', 'sse'])
+					.optional()
+					.describe('Transport type (default stdio).'),
+				command: z
+					.string()
+					.optional()
+					.describe('Executable for stdio transport (e.g. "bunx").'),
+				args: z
+					.array(z.string())
+					.optional()
+					.describe('Arguments for the stdio command.'),
+				env: z
+					.record(z.string())
+					.optional()
+					.describe('Environment variables for the stdio command.'),
+				url: z
+					.string()
+					.optional()
+					.describe('Server URL for http/sse transport.'),
+				headers: z
+					.record(z.string())
+					.optional()
+					.describe('HTTP headers for http/sse transport.'),
+				start: z
+					.boolean()
+					.optional()
+					.describe('Start the server immediately after add/update.'),
+			}),
+			execute: async (input: MCPManagerInput) => {
+				const globalConfigDir = getGlobalConfigDir();
+				const action = input.action;
+
+				if (action === 'list') {
+					const config = await loadMCPConfig(projectRoot, globalConfigDir);
+					const statuses = await getStatuses();
+					return {
+						ok: true,
+						servers: config.servers.map((server) =>
+							summarizeServer(
+								server,
+								statuses.find((status) => status.name === server.name),
+							),
+						),
+					};
+				}
+
+				const name = input.name?.trim();
+				if (!name) {
+					return createToolError(
+						`name is required for action "${action}"`,
+						'validation',
+						{ parameter: 'name' },
+					);
+				}
+
+				const config = await loadMCPConfig(projectRoot, globalConfigDir);
+				const existing = config.servers.find((server) => server.name === name);
+
+				if (action === 'add' || action === 'update') {
+					if (action === 'update' && !existing) {
+						return createToolError(
+							`MCP server "${name}" not found`,
+							'not_found',
+							{ parameter: 'name', value: name },
+						);
+					}
+					const validated = validateServerInput(input, existing);
+					if (!validated.ok) return validated.error;
+					const server = validated.server;
+
+					if (existing && existing.scope !== server.scope) {
+						await removeMCPServerFromConfig(projectRoot, name, globalConfigDir);
+					}
+					await addMCPServerToConfig(projectRoot, server, globalConfigDir);
+
+					if (input.start) {
+						try {
+							const status = await startServer(projectRoot, server);
+							return {
+								ok: true,
+								action,
+								server: summarizeServer(server, status),
+							};
+						} catch (err) {
+							const msg = err instanceof Error ? err.message : String(err);
+							return {
+								ok: true,
+								action,
+								server: summarizeServer(server),
+								startError: msg,
+							};
+						}
+					}
+					return { ok: true, action, server: summarizeServer(server) };
+				}
+
+				if (!existing) {
+					return createToolError(
+						`MCP server "${name}" not found`,
+						'not_found',
+						{ parameter: 'name', value: name },
+					);
+				}
+
+				if (action === 'remove') {
+					try {
+						await stopServer(name);
+					} catch {}
+					const removed = await removeMCPServerFromConfig(
+						projectRoot,
+						name,
+						globalConfigDir,
+					);
+					if (!removed) {
+						return createToolError(
+							`MCP server "${name}" not found in any config file`,
+							'not_found',
+							{ parameter: 'name', value: name },
+						);
+					}
+					return { ok: true, action, name };
+				}
+
+				if (action === 'enable') {
+					const server: MCPServerConfig = { ...existing, disabled: false };
+					await addMCPServerToConfig(projectRoot, server, globalConfigDir);
+					try {
+						const status = await startServer(projectRoot, server);
+						return {
+							ok: true,
+							action,
+							server: summarizeServer(server, status),
+						};
+					} catch (err) {
+						const msg = err instanceof Error ? err.message : String(err);
+						return {
+							ok: true,
+							action,
+							server: summarizeServer(server),
+							startError: msg,
+						};
+					}
+				}
+
+				if (action === 'disable') {
+					const server: MCPServerConfig = { ...existing, disabled: true };
+					await addMCPServerToConfig(projectRoot, server, globalConfigDir);
+					try {
+						await stopServer(name);
+					} catch {}
+					return { ok: true, action, server: summarizeServer(server) };
+				}
+
+				return createToolError(`Unknown action "${action}"`, 'validation', {
+					parameter: 'action',
+					value: action,
+				});
+			},
+		}),
+	};
+}

package/src/core/src/tools/lazy/registry.ts

@@ -1,6 +1,7 @@
 import type { Tool } from 'ai';
 import { buildCopyAttachmentTool } from '../builtin/fs/copy-attachment.ts';
 import { buildReadImageTool } from '../builtin/fs/read-image.ts';
+import { buildMCPManagerTool } from './mcp-manager.ts';
 import { buildSimulatorTool } from './simulator.ts';
 import { buildLoadToolsTool, type LazyToolBrief } from './load-tools.ts';
 
@@ -28,6 +29,12 @@ export function getLazyToolDefinitions(): LazyToolDefinition[] {
 				'Copy an original uploaded chat attachment into the project without recompression.',
 			build: buildCopyAttachmentTool,
 		},
+		{
+			name: 'mcp_manager',
+			description:
+				'Manage otto MCP servers: list, add, update, remove, enable, or disable servers in project (.otto/config.json) or global config.',
+			build: buildMCPManagerTool,
+		},
 	];
 }
 

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

@@ -1,6 +1,5 @@
 import { tool, type Tool } from 'ai';
 import { z } from 'zod/v3';
-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';
@@ -148,7 +147,6 @@ async function discoverStaticProjectTools(
 		for (const { name, tool } of buildGitTools(projectRoot))
 			tools.set(name, tool);
 		// Built-ins
-		tools.set('finish', finishTool);
 		tools.set('progress_update', progressUpdateTool);
 		const shell = buildShellTool(projectRoot);
 		tools.set(shell.name, shell.tool);

package/src/index.ts

@@ -310,6 +310,7 @@ export { buildGitTools } from './core/src/index.ts';
 export {
 	buildLazyToolsRecord,
 	buildLoadFirstPartyToolsTool,
+	buildMCPManagerTool,
 	buildSimulatorTool,
 	getLazyToolDefinitions,
 } from './core/src/index.ts';

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

@@ -2,7 +2,7 @@ You help with coding and build tasks.
 
 - Be precise and practical. Inspect before editing; prefer small, targeted diffs.
 - Keep tool inputs short; avoid long prose inside tool parameters.
-- Stream a short summary of what you did, then call `finish`.
+- Stream a short summary of what you did, then stop.
 
 ## Editing workflow
 

package/src/prompts/src/base.txt

@@ -26,9 +26,8 @@ When instructions conflict, obey (highest → lowest):
 
 ## Finishing your turn
 
-Every response ends with a call to the `finish` tool. The answer/work you already streamed IS your final response — `finish` just signals the turn is over.
+Your turn ends when you stop calling tools. The answer/work you already streamed IS your final response.
 
-- For questions and conversational replies: answer directly, then call `finish`. The answer IS the response; no separate summary.
-- For substantive work (edits, multi-tool runs): briefly describe the outcome (what changed, key files, how to verify), then call `finish`.
+- For questions and conversational replies: answer directly. The answer IS the response; no separate summary.
+- For substantive work (edits, multi-tool runs): briefly describe the outcome (what changed, key files, how to verify), then stop.
 - NEVER label your response with "Summary:" or similar prefixes. NEVER add a recap to trivial replies — the direct answer is sufficient.
-- You MUST call `finish` as your last action. Don't call it before your text response finishes streaming.

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

@@ -50,4 +50,4 @@ Independent operations (multiple reads, multiple searches, `git_status` + `git_d
 
 # Finishing
 
-Stream a short summary of what you did, then call the `finish` tool. Never call `finish` without first streaming a summary.
+Stream a short summary of what you did, then stop. Your turn ends when you stop calling tools.

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

@@ -62,4 +62,4 @@ Independent operations (multiple reads, multiple searches, `git_status` + `git_d
 
 # Finishing
 
-Stream a short summary of what you did, then call the `finish` tool. Never call `finish` without first streaming a summary.
+Stream a short summary of what you did, then stop. Your turn ends when you stop calling tools.

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

@@ -62,4 +62,4 @@ Independent operations (multiple reads, multiple searches, `git_status` + `git_d
 
 # Finishing
 
-Stream a short summary of what you did, then call the `finish` tool. Never call `finish` without first streaming a summary.
+Stream a short summary of what you did, then stop. Your turn ends when you stop calling tools.

package/src/providers/src/openai-oauth-client.ts

@@ -25,9 +25,6 @@ type OpenAIOAuthSessionState = {
 	model?: string;
 	status?: string;
 	incompleteReason?: string;
-	turnState?: string;
-	installationId?: string;
-	windowId?: string;
 };
 
 const openAIOAuthSessionState = new Map<string, OpenAIOAuthSessionState>();
@@ -214,17 +211,6 @@ function writeSessionState(sessionId: string, next: OpenAIOAuthSessionState) {
 	openAIOAuthSessionState.set(sessionId, next);
 }
 
-function mergeSessionState(sessionId: string, next: OpenAIOAuthSessionState) {
-	writeSessionState(sessionId, {
-		...readSessionState(sessionId),
-		...next,
-	});
-}
-
-function getCodexWindowId(sessionId: string) {
-	return `${sessionId}:0`;
-}
-
 function rewriteRequestBody(
 	body: string,
 	sessionId?: string,
@@ -237,17 +223,6 @@ function rewriteRequestBody(
 			return { body: changed ? JSON.stringify(parsed) : body, model };
 		}
 
-		const clientMetadata =
-			parsed.client_metadata && typeof parsed.client_metadata === 'object'
-				? (parsed.client_metadata as Record<string, unknown>)
-				: {};
-		if (clientMetadata['x-codex-installation-id'] !== CODEX_INSTALLATION_ID) {
-			parsed.client_metadata = {
-				...clientMetadata,
-				'x-codex-installation-id': CODEX_INSTALLATION_ID,
-			};
-			changed = true;
-		}
 		if (typeof parsed.prompt_cache_key !== 'string') {
 			parsed.prompt_cache_key = sessionId;
 			changed = true;
@@ -384,9 +359,6 @@ function trackResponseEvent(data: string, sessionId?: string) {
 				model: responseModel ?? prior?.model,
 				status: responseStatus ?? type,
 				incompleteReason,
-				turnState: prior?.turnState,
-				installationId: prior?.installationId,
-				windowId: prior?.windowId,
 			});
 			logOpenAIOAuth(
 				`tracked response event type=${type ?? 'unknown'} responseId=${responseId} session=${sessionId} status=${responseStatus ?? 'unknown'} incompleteReason=${incompleteReason ?? 'none'}`,
@@ -692,10 +664,6 @@ function buildHeaders(
 	sessionId?: string,
 ): Headers {
 	const headers = new Headers(init?.headers);
-	const prior = readSessionState(sessionId);
-	const windowId = sessionId
-		? (prior?.windowId ?? getCodexWindowId(sessionId))
-		: undefined;
 	headers.delete('Authorization');
 	headers.delete('authorization');
 	headers.set('authorization', `Bearer ${accessToken}`);
@@ -710,30 +678,10 @@ function buildHeaders(
 	}
 	if (sessionId) {
 		headers.set('session_id', sessionId);
-		headers.set('thread_id', sessionId);
-		headers.set('x-codex-window-id', windowId ?? getCodexWindowId(sessionId));
-		if (prior?.turnState) {
-			headers.set('x-codex-turn-state', prior.turnState);
-		}
 	}
 	return headers;
 }
 
-function trackCodexResponseHeaders(response: Response, sessionId?: string) {
-	if (!sessionId) return;
-	const turnState = response.headers.get('x-codex-turn-state') ?? undefined;
-	if (!turnState) return;
-	const windowId = getCodexWindowId(sessionId);
-	mergeSessionState(sessionId, {
-		turnState,
-		installationId: CODEX_INSTALLATION_ID,
-		windowId,
-	});
-	logOpenAIOAuth(
-		`tracked x-codex-turn-state for session=${sessionId} window=${windowId}`,
-	);
-}
-
 export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 	let currentOAuth = config.oauth;
 
@@ -770,9 +718,6 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 					model: requestModel,
 					status: prior?.status,
 					incompleteReason: prior?.incompleteReason,
-					turnState: prior?.turnState,
-					installationId: prior?.installationId,
-					windowId: prior?.windowId,
 				});
 			}
 		}
@@ -830,9 +775,6 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 			bodyCharsApprox: requestBodySize,
 			model: requestModel,
 		});
-		if (isResponsesRequest) {
-			trackCodexResponseHeaders(response, config.sessionId);
-		}
 		if (!response.ok && response.status !== 401) {
 			loggerWarn('[openai-oauth] non-OK response', {
 				sessionId: config.sessionId,
@@ -892,9 +834,6 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 						requestStartedAt: retryStartedAt,
 					},
 				);
-				if (isResponsesRequest) {
-					trackCodexResponseHeaders(retryResponse, config.sessionId);
-				}
 				loggerDebug('[openai-oauth] retry response received', {
 					sessionId: config.sessionId,
 					target: isResponsesRequest ? 'codex.responses' : 'other',

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

@@ -1,12 +0,0 @@
-import { z } from 'zod/v3';
-import { tool } from 'ai';
-import DESCRIPTION from './finish.txt' with { type: 'text' };
-import type { ToolResponse } from '../error.ts';
-
-export const finishTool = tool({
-	description: DESCRIPTION,
-	inputSchema: z.object({}),
-	async execute(): Promise<ToolResponse<{ done: true }>> {
-		return { ok: true, done: true };
-	},
-});

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

@@ -1,15 +0,0 @@
-Signal the end of your turn. Call this as the LAST action of every response, after your text/work has finished streaming.
-
-## How it works
-
-Your text response IS the final answer. `finish` is just the end-of-turn signal — it does NOT produce visible output to the user.
-
-- For questions and conversational replies: answer directly, then call `finish`. No separate summary.
-- For substantive work (edits, multi-tool runs): briefly describe the outcome, then call `finish`.
-
-## Never
-
-- NEVER add a "Summary:" label (or "Result:", "Done:", etc.) to your response. The direct answer is the response.
-- NEVER recap trivial single-sentence answers. "15" or "Yes" is a complete reply on its own.
-- NEVER call `finish` before your text finishes streaming.
-- NEVER forget to call `finish` — without it the system hangs waiting for more output.