@ottocode/sdk 0.1.272 → 0.1.274

package/package.json

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

package/src/core/src/tools/builtin/fs/copy-into.ts

@@ -11,6 +11,19 @@ import {
 import { assertFreshRead, rememberFileWrite } from './read-tracker.ts';
 import { createToolError, type ToolResponse } from '../../error.ts';
 
+const lineEndpointSchema = z.union([
+	z.number().int().min(1),
+	z.literal('end'),
+	z.literal('eof'),
+]);
+
+const insertAtLineSchema = z.union([
+	z.number().int().min(1),
+	z.literal('append'),
+	z.literal('end'),
+	z.literal('eof'),
+]);
+
 const copyIntoSchema = z.object({
 	sourcePath: z
 		.string()
@@ -20,21 +33,16 @@ const copyIntoSchema = z.object({
 		.int()
 		.min(1)
 		.describe('First source line to copy, 1-indexed and inclusive.'),
-	endLine: z
-		.number()
-		.int()
-		.min(1)
-		.describe('Last source line to copy, 1-indexed and inclusive.'),
+	endLine: lineEndpointSchema.describe(
+		'Last source line to copy, 1-indexed and inclusive. Use "end" or "eof" to copy through the end of the file.',
+	),
 	targetPath: z
 		.string()
 		.describe('Relative target file path within the project.'),
-	insertAtLine: z
-		.number()
-		.int()
-		.min(1)
+	insertAtLine: insertAtLineSchema
 		.optional()
 		.describe(
-			'Line to insert before, 1-indexed. Use totalLines + 1 to append.',
+			'Line to insert before, 1-indexed. Use "append" to add to the end.',
 		),
 	mode: z
 		.enum(['insert_before', 'insert_after', 'replace_range'])
@@ -47,15 +55,15 @@ const copyIntoSchema = z.object({
 		.min(1)
 		.optional()
 		.describe('First target line to replace when mode is replace_range.'),
-	targetEndLine: z
-		.number()
-		.int()
-		.min(1)
+	targetEndLine: lineEndpointSchema
 		.optional()
-		.describe('Last target line to replace when mode is replace_range.'),
+		.describe(
+			'Last target line to replace when mode is replace_range. Use "end" or "eof" to replace through the end of the file.',
+		),
 });
 
 type CopyIntoInput = z.infer<typeof copyIntoSchema>;
+type LineEndpoint = z.infer<typeof lineEndpointSchema>;
 
 function splitLinesForEdit(content: string): {
 	lines: string[];
@@ -83,27 +91,37 @@ function validateRelativePath(path: string, label: string): string | undefined {
 	return undefined;
 }
 
+function resolveEndLine(value: LineEndpoint, lineCount: number): number {
+	if (typeof value === 'number') return Math.min(value, lineCount);
+	return lineCount;
+}
+
 function getLineRange(
 	lines: string[],
 	startLine: number,
-	endLine: number,
-): string[] {
-	if (startLine > endLine) {
-		throw new Error('startLine must be less than or equal to endLine.');
+	endLineInput: LineEndpoint,
+): { copied: string[]; endLine: number } {
+	if (startLine > lines.length) {
+		throw new Error(
+			`Source start line ${startLine} exceeds source file length (${lines.length} lines). Use read to confirm line numbers first.`,
+		);
 	}
-	if (endLine > lines.length) {
+
+	const endLine = resolveEndLine(endLineInput, lines.length);
+	if (startLine > endLine) {
 		throw new Error(
-			`Source range ${startLine}-${endLine} exceeds source file length (${lines.length} lines).`,
+			`startLine must be less than or equal to endLine. Source file has ${lines.length} lines; use endLine: "end" to copy through EOF.`,
 		);
 	}
-	return lines.slice(startLine - 1, endLine);
+
+	return { copied: lines.slice(startLine - 1, endLine), endLine };
 }
 
 function applyCopiedLines(
 	input: CopyIntoInput,
 	targetLines: string[],
 	copied: string[],
-): string[] {
+): { lines: string[]; targetRange: string } {
 	const mode = input.mode ?? 'insert_before';
 	if (mode === 'replace_range') {
 		if (
@@ -114,21 +132,30 @@ function applyCopiedLines(
 				'targetStartLine and targetEndLine are required when mode is replace_range.',
 			);
 		}
-		if (input.targetStartLine > input.targetEndLine) {
+		if (input.targetStartLine > targetLines.length) {
 			throw new Error(
-				'targetStartLine must be less than or equal to targetEndLine.',
+				`Target start line ${input.targetStartLine} exceeds target file length (${targetLines.length} lines). Use insertAtLine: "append" to append instead.`,
 			);
 		}
-		if (input.targetEndLine > targetLines.length) {
+
+		const targetEndLine = resolveEndLine(
+			input.targetEndLine,
+			targetLines.length,
+		);
+		if (input.targetStartLine > targetEndLine) {
 			throw new Error(
-				`Target range ${input.targetStartLine}-${input.targetEndLine} exceeds target file length (${targetLines.length} lines).`,
+				`targetStartLine must be less than or equal to targetEndLine. Target file has ${targetLines.length} lines; use targetEndLine: "end" to replace through EOF.`,
 			);
 		}
-		return [
-			...targetLines.slice(0, input.targetStartLine - 1),
-			...copied,
-			...targetLines.slice(input.targetEndLine),
-		];
+
+		return {
+			lines: [
+				...targetLines.slice(0, input.targetStartLine - 1),
+				...copied,
+				...targetLines.slice(targetEndLine),
+			],
+			targetRange: `${input.targetStartLine}-${targetEndLine}`,
+		};
 	}
 
 	if (input.insertAtLine === undefined) {
@@ -136,25 +163,31 @@ function applyCopiedLines(
 			'insertAtLine is required for insert_before and insert_after modes.',
 		);
 	}
-	if (input.insertAtLine > targetLines.length + 1) {
-		throw new Error(
-			`insertAtLine ${input.insertAtLine} exceeds append position (${targetLines.length + 1}).`,
-		);
-	}
 
-	const insertIndex =
-		mode === 'insert_after' ? input.insertAtLine : input.insertAtLine - 1;
-	if (insertIndex > targetLines.length) {
+	const insertAtLine =
+		typeof input.insertAtLine === 'number'
+			? Math.min(
+					input.insertAtLine,
+					mode === 'insert_after' ? targetLines.length : targetLines.length + 1,
+				)
+			: mode === 'insert_after'
+				? targetLines.length
+				: targetLines.length + 1;
+	const insertIndex = mode === 'insert_after' ? insertAtLine : insertAtLine - 1;
+	if (insertIndex < 0 || insertIndex > targetLines.length) {
 		throw new Error(
-			`insertAtLine ${input.insertAtLine} with insert_after exceeds target file length (${targetLines.length} lines).`,
+			`insertAtLine ${String(input.insertAtLine)} is outside the target file. Use insertAtLine: "append" to append.`,
 		);
 	}
 
-	return [
-		...targetLines.slice(0, insertIndex),
-		...copied,
-		...targetLines.slice(insertIndex),
-	];
+	return {
+		lines: [
+			...targetLines.slice(0, insertIndex),
+			...copied,
+			...targetLines.slice(insertIndex),
+		],
+		targetRange: `${insertAtLine}`,
+	};
 }
 
 export function buildCopyIntoTool(projectRoot: string): {
@@ -168,6 +201,9 @@ export function buildCopyIntoTool(projectRoot: string): {
 			ToolResponse<{
 				sourcePath: string;
 				targetPath: string;
+				sourceRange: string;
+				targetRange: string;
+				mode: string;
 				linesCopied: number;
 				bytes: number;
 				artifact: unknown;
@@ -206,15 +242,19 @@ export function buildCopyIntoTool(projectRoot: string): {
 					readFile(targetAbs, 'utf-8'),
 				]);
 				const source = splitLinesForEdit(sourceContent);
-				const copiedLines = getLineRange(
+				const sourceRange = getLineRange(
 					source.lines,
 					input.startLine,
 					input.endLine,
 				);
 				const target = splitLinesForEdit(targetContent);
-				const nextLines = applyCopiedLines(input, target.lines, copiedLines);
+				const applied = applyCopiedLines(
+					input,
+					target.lines,
+					sourceRange.copied,
+				);
 				const nextNormalized = joinLinesForEdit(
-					nextLines,
+					applied.lines,
 					target.trailingNewline,
 				);
 				const nextContent = convertToLineEnding(
@@ -241,7 +281,10 @@ export function buildCopyIntoTool(projectRoot: string): {
 					ok: true,
 					sourcePath: input.sourcePath,
 					targetPath: input.targetPath,
-					linesCopied: copiedLines.length,
+					sourceRange: `${input.startLine}-${sourceRange.endLine}`,
+					targetRange: applied.targetRange,
+					mode: input.mode ?? 'insert_before',
+					linesCopied: sourceRange.copied.length,
 					bytes: nextContent.length,
 					artifact,
 				};

package/src/core/src/tools/builtin/fs/copy-into.txt

@@ -6,6 +6,9 @@ Rules:
 - Source and target paths must be relative paths within the project.
 - You must read the target file first in the current session before modifying it.
 - Line numbers are 1-indexed and inclusive.
-- `insertAtLine` inserts before that line. Use `insertAtLine: totalLines + 1` to append.
+- `endLine` may be a line number, `"end"`, or `"eof"`. Prefer `"end"` over guessed sentinel values like `999`.
+- `insertAtLine` inserts before that line. Use `"append"` to add to the end.
 - Use `mode: "replace_range"` with `targetStartLine` and `targetEndLine` to replace target lines.
+- `targetEndLine` may be a line number, `"end"`, or `"eof"`.
+- If an end line is past EOF, it is treated as EOF. Start lines must still exist.
 - This tool does not use the system clipboard.

package/src/prompts/src/agents/research.txt

@@ -2,11 +2,7 @@ You are a research assistant with access to session history and codebase search
 
 ## Primary Job
 
-Help users find information from past sessions and the codebase.
-
-## Critical: "This Session" Means Parent Session
-
-When the user refers to "this session", they mean the PARENT SESSION, not this research chat. **ALWAYS call `get_parent_session` FIRST** for these questions.
+Help users find information from past sessions, session history, and the codebase.
 
 ## Database Structure
 
@@ -16,12 +12,11 @@ When the user refers to "this session", they mean the PARENT SESSION, not this r
 
 ## Available Tools
 
-1. **get_parent_session** - USE FIRST for "this session" questions. Returns parent session's messages.
-2. **get_session_context** - Get details about ANY session by ID.
-3. **query_sessions** - List/search sessions by agent, type, date range.
-4. **query_messages** - Search messages across sessions.
-5. **search_history** - Full-text search across ALL message content.
-6. **present_action** - Present clickable session links at the end.
+1. **search_history** - Full-text search across message content.
+2. **query_sessions** - List/search sessions by agent, type, date range.
+3. **query_messages** - Search messages across sessions.
+4. **get_session_context** - Get details about a specific session by ID.
+5. **present_action** - Present clickable session links when relevant.
 
 ## Codebase Tools
 
@@ -29,22 +24,24 @@ When the user refers to "this session", they mean the PARENT SESSION, not this r
 
 ## Research Strategy
 
-**"What did we do" questions:**
-1. Call `get_parent_session`
-2. Summarize key activities
-
 **"Find past work on X" questions:**
-1. Use `search_history` with keywords
-2. Then `get_session_context` on promising sessions
+1. Use `search_history` with focused keywords.
+2. Use `query_sessions` or `query_messages` to narrow by agent, dates, or tool usage.
+3. Use `get_session_context` on promising sessions.
+
+**"What did we do" questions:**
+1. Search session history for the topic the user mentions.
+2. Open the most relevant sessions.
+3. Summarize concrete activities and outcomes.
 
 **"What tools were used" questions:**
-1. Call `get_parent_session`
-2. Look at `toolCalls` in response
+1. Use `query_messages` with `toolName` when the tool is known.
+2. Use `get_session_context` for relevant sessions to inspect tool calls.
 
 ## Response Guidelines
 
-1. Be specific - quote actual content
-2. Cite sources - reference session IDs and timestamps
-3. Summarize clearly - findings may be injected into another session
-4. Don't hallucinate - only report what you find
-5. **Use `present_action`** at the end with links to relevant sessions
+1. Be specific - quote actual content when helpful.
+2. Cite sources - reference session titles, IDs, and timestamps.
+3. Summarize clearly and avoid over-explaining.
+4. Don't hallucinate - only report what you find.
+5. Use `present_action` only when session links would help the user navigate.

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

@@ -31,7 +31,7 @@ export type OpenAIOAuthConfig = {
 };
 
 function shouldDebugOpenAIOAuth() {
-	return false;
+	return process.env.OTTO_OPENAI_OAUTH_DEBUG === '1';
 }
 
 function logOpenAIOAuth(message: string) {
@@ -40,6 +40,45 @@ function logOpenAIOAuth(message: string) {
 	}
 }
 
+function summarizeError(error: unknown): Record<string, unknown> {
+	if (error instanceof Error) {
+		return { name: error.name, message: error.message };
+	}
+	if (error && typeof error === 'object') {
+		const err = error as Record<string, unknown>;
+		return {
+			name: typeof err.name === 'string' ? err.name : undefined,
+			message: typeof err.message === 'string' ? err.message : undefined,
+			code: typeof err.code === 'string' ? err.code : undefined,
+		};
+	}
+	return { message: String(error) };
+}
+
+function getBodySize(body: unknown): number | undefined {
+	if (typeof body === 'string') return body.length;
+	if (body instanceof URLSearchParams) return body.toString().length;
+	if (body instanceof Blob) return body.size;
+	if (body instanceof ArrayBuffer) return body.byteLength;
+	if (ArrayBuffer.isView(body)) return body.byteLength;
+	return undefined;
+}
+
+async function previewResponseBody(
+	response: Response,
+): Promise<string | undefined> {
+	try {
+		const text = await response.clone().text();
+		const normalized = text.replace(/\s+/g, ' ').trim();
+		if (!normalized) return undefined;
+		return normalized.length > 500
+			? `${normalized.slice(0, 500)}…`
+			: normalized;
+	} catch {
+		return undefined;
+	}
+}
+
 function shouldUsePreviousResponseId() {
 	return process.env.OTTO_OPENAI_OAUTH_PREVIOUS_RESPONSE_ID === '1';
 }
@@ -335,6 +374,7 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 		input: Parameters<typeof fetch>[0],
 		init?: Parameters<typeof fetch>[1],
 	): Promise<Response> => {
+		const requestStartedAt = Date.now();
 		const validated = await ensureValidToken(currentOAuth, config.projectRoot);
 		currentOAuth = validated.oauth;
 
@@ -373,18 +413,70 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 			validated.accountId,
 			config.sessionId,
 		);
+		const requestBodySize = getBodySize(requestInit?.body);
+		const method = requestInit?.method ?? 'POST';
+		loggerDebug('[openai-oauth] request start', {
+			sessionId: config.sessionId,
+			target: isResponsesRequest ? 'codex.responses' : 'other',
+			method,
+			bodyCharsApprox: requestBodySize,
+			model: requestModel,
+		});
 
-		const response = await fetch(targetUrl, {
-			...requestInit,
-			headers,
-			// @ts-expect-error Bun-specific fetch option
-			timeout: false,
+		let response: Response;
+		try {
+			response = await fetch(targetUrl, {
+				...requestInit,
+				headers,
+				// @ts-expect-error Bun-specific fetch option
+				timeout: false,
+			});
+		} catch (error) {
+			loggerWarn('[openai-oauth] request failed before response', {
+				sessionId: config.sessionId,
+				target: isResponsesRequest ? 'codex.responses' : 'other',
+				method,
+				bodyCharsApprox: requestBodySize,
+				model: requestModel,
+				durationMs: Date.now() - requestStartedAt,
+				error: summarizeError(error),
+			});
+			throw error;
+		}
+		loggerDebug('[openai-oauth] response received', {
+			sessionId: config.sessionId,
+			target: isResponsesRequest ? 'codex.responses' : 'other',
+			status: response.status,
+			statusText: response.statusText,
+			ok: response.ok,
+			durationMs: Date.now() - requestStartedAt,
+			bodyCharsApprox: requestBodySize,
+			model: requestModel,
 		});
+		if (!response.ok && response.status !== 401) {
+			loggerWarn('[openai-oauth] non-OK response', {
+				sessionId: config.sessionId,
+				target: isResponsesRequest ? 'codex.responses' : 'other',
+				status: response.status,
+				statusText: response.statusText,
+				durationMs: Date.now() - requestStartedAt,
+				bodyCharsApprox: requestBodySize,
+				model: requestModel,
+				bodyPreview: await previewResponseBody(response),
+			});
+		}
 		const trackedResponse = isResponsesRequest
 			? trackResponsesStream(response, config.sessionId)
 			: response;
 
 		if (response.status === 401) {
+			loggerWarn('[openai-oauth] 401 response, refreshing token and retrying', {
+				sessionId: config.sessionId,
+				target: isResponsesRequest ? 'codex.responses' : 'other',
+				durationMs: Date.now() - requestStartedAt,
+				bodyCharsApprox: requestBodySize,
+				model: requestModel,
+			});
 			try {
 				const refreshedFromDisk = await getAuth('openai', config.projectRoot);
 				if (
@@ -406,18 +498,48 @@ export function createOpenAIOAuthFetch(config: OpenAIOAuthConfig) {
 					config.sessionId,
 				);
 
+				const retryStartedAt = Date.now();
 				const retryResponse = await fetch(targetUrl, {
 					...requestInit,
 					headers: retryHeaders,
 					// @ts-expect-error Bun-specific fetch option
 					timeout: false,
 				});
+				loggerDebug('[openai-oauth] retry response received', {
+					sessionId: config.sessionId,
+					target: isResponsesRequest ? 'codex.responses' : 'other',
+					status: retryResponse.status,
+					statusText: retryResponse.statusText,
+					ok: retryResponse.ok,
+					durationMs: Date.now() - retryStartedAt,
+					bodyCharsApprox: requestBodySize,
+					model: requestModel,
+				});
+				if (!retryResponse.ok) {
+					loggerWarn('[openai-oauth] retry non-OK response', {
+						sessionId: config.sessionId,
+						target: isResponsesRequest ? 'codex.responses' : 'other',
+						status: retryResponse.status,
+						statusText: retryResponse.statusText,
+						durationMs: Date.now() - retryStartedAt,
+						bodyCharsApprox: requestBodySize,
+						model: requestModel,
+						bodyPreview: await previewResponseBody(retryResponse),
+					});
+				}
 				return isResponsesRequest
 					? trackResponsesStream(retryResponse, config.sessionId)
 					: retryResponse;
-			} catch {
-				console.error(
+			} catch (error) {
+				loggerWarn(
 					'[openai-oauth] 401 retry failed, returning original 401 response',
+					{
+						sessionId: config.sessionId,
+						target: isResponsesRequest ? 'codex.responses' : 'other',
+						bodyCharsApprox: requestBodySize,
+						model: requestModel,
+						error: summarizeError(error),
+					},
 				);
 				return response;
 			}