@ottocode/sdk 0.1.305 → 0.1.306

package/package.json

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

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/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/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.