@ottocode/server 0.1.221 → 0.1.223

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.221",
+	"version": "0.1.223",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -49,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.221",
-		"@ottocode/database": "0.1.221",
+		"@ottocode/sdk": "0.1.223",
+		"@ottocode/database": "0.1.223",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.3.6"

package/src/openapi/paths/sessions.ts

@@ -78,6 +78,31 @@ export const sessionsPaths = {
 		},
 	},
 	'/v1/sessions/{sessionId}': {
+		get: {
+			tags: ['sessions'],
+			operationId: 'getSession',
+			summary: 'Get a single session by ID',
+			parameters: [
+				{
+					in: 'path',
+					name: 'sessionId',
+					required: true,
+					schema: { type: 'string' },
+				},
+				projectQueryParam(),
+			],
+			responses: {
+				200: {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: { $ref: '#/components/schemas/Session' },
+						},
+					},
+				},
+				404: errorResponse(),
+			},
+		},
 		patch: {
 			tags: ['sessions'],
 			operationId: 'updateSession',

package/src/openapi/schemas.ts

@@ -66,6 +66,7 @@ export const schemas = {
 			totalOutputTokens: { type: 'integer', nullable: true },
 			totalCachedTokens: { type: 'integer', nullable: true },
 			totalCacheCreationTokens: { type: 'integer', nullable: true },
+			currentContextTokens: { type: 'integer', nullable: true },
 			totalToolTimeMs: { type: 'integer', nullable: true },
 			toolCounts: {
 				type: 'object',

package/src/routes/sessions.ts

@@ -104,6 +104,43 @@ export function registerSessionsRoutes(app: Hono) {
 		}
 	});
 
+	// Get single session
+	app.get('/v1/sessions/:sessionId', async (c) => {
+		try {
+			const sessionId = c.req.param('sessionId');
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+			const db = await getDb(cfg.projectRoot);
+			const rows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+			if (!rows.length) {
+				return c.json(
+					{ error: { message: 'Session not found', status: 404 } },
+					404,
+				);
+			}
+			const r = rows[0];
+			let counts: Record<string, unknown> | undefined;
+			if (r.toolCountsJson) {
+				try {
+					const parsed = JSON.parse(r.toolCountsJson);
+					if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+						counts = parsed as Record<string, unknown>;
+					}
+				} catch {}
+			}
+			const { toolCountsJson: _toolCountsJson, ...rest } = r;
+			return c.json(counts ? { ...rest, toolCounts: counts } : rest);
+		} catch (err) {
+			logger.error('Failed to get session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
 	// Update session preferences
 	app.patch('/v1/sessions/:sessionId', async (c) => {
 		try {

package/src/runtime/agent/oauth-codex-continuation.ts

@@ -24,10 +24,6 @@ const INTERMEDIATE_PROGRESS_PATTERNS: RegExp[] = [
 	/\b(and|then)\s+continue\b/i,
 ];
 
-/**
- * Detects whether assistant text looks like an intermediate progress update
- * (e.g. "Next I'll inspect...") rather than a final user-facing completion.
- */
 export function looksLikeIntermediateProgressText(text: string): boolean {
 	const trimmed = text.trim();
 	if (!trimmed) return false;
@@ -44,11 +40,15 @@ function isTruncatedResponse(
 	return rawFinishReason === 'max_output_tokens';
 }
 
-/**
- * Decides whether an OpenAI OAuth Codex turn should auto-continue to recover
- * only from hard truncation. Other completion behavior is handled by
- * stream step limits and prompt alignment, not synthetic continuation turns.
- */
+const MAX_UNCLEAN_EOF_RETRIES = 1;
+
+function isUncleanEof(input: OauthCodexContinuationInput): boolean {
+	if (input.finishReason && input.finishReason !== 'unknown') return false;
+	if (input.firstToolSeen) return true;
+	if (looksLikeIntermediateProgressText(input.lastAssistantText)) return true;
+	return false;
+}
+
 export function decideOauthCodexContinuation(
 	input: OauthCodexContinuationInput,
 ): OauthCodexContinuationDecision {
@@ -68,5 +68,12 @@ export function decideOauthCodexContinuation(
 		return { shouldContinue: true, reason: 'truncated' };
 	}
 
+	if (
+		isUncleanEof(input) &&
+		input.continuationCount < MAX_UNCLEAN_EOF_RETRIES
+	) {
+		return { shouldContinue: true, reason: 'unclean-eof' };
+	}
+
 	return { shouldContinue: false };
 }

package/src/runtime/agent/runner.ts

@@ -1,5 +1,5 @@
 import { hasToolCall, stepCountIs, streamText } from 'ai';
-import { messages, messageParts } from '@ottocode/database/schema';
+import { messages, messageParts, sessions } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish, subscribe } from '../../events/bus.ts';
 import { debugLog, time } from '../debug/index.ts';
@@ -243,7 +243,7 @@ async function runAssistant(opts: RunOpts) {
 
 	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
 	const stopWhenCondition = isOpenAIOAuth
-		? stepCountIs(48)
+		? stepCountIs(20)
 		: hasToolCall('finish');
 
 	try {
@@ -423,55 +423,68 @@ async function runAssistant(opts: RunOpts) {
 		});
 
 		if (continuationDecision.shouldContinue) {
-			debugLog(
-				`[RUNNER] WARNING: Stream ended without finish. reason=${continuationDecision.reason ?? 'unknown'}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
-			);
-
-			debugLog(
-				`[RUNNER] Auto-continuing (${continuationCount + 1}/${MAX_CONTINUATIONS})...`,
-			);
+			const sessRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, opts.sessionId))
+				.limit(1);
+			const sessionInputTokens = Number(sessRows[0]?.totalInputTokens ?? 0);
+			const MAX_SESSION_INPUT_TOKENS = 800_000;
+			if (sessionInputTokens > MAX_SESSION_INPUT_TOKENS) {
+				debugLog(
+					`[RUNNER] Token budget exceeded (${sessionInputTokens} > ${MAX_SESSION_INPUT_TOKENS}), stopping continuation.`,
+				);
+			} else {
+				debugLog(
+					`[RUNNER] WARNING: Stream ended without finish. reason=${continuationDecision.reason ?? 'unknown'}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
+				);
 
-			try {
-				await completeAssistantMessage({}, opts, db);
-			} catch (err) {
 				debugLog(
-					`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
+					`[RUNNER] Auto-continuing (${continuationCount + 1}/${MAX_CONTINUATIONS})...`,
 				);
-			}
 
-			const continuationMessageId = crypto.randomUUID();
-			await db.insert(messages).values({
-				id: continuationMessageId,
-				sessionId: opts.sessionId,
-				role: 'assistant',
-				status: 'pending',
-				agent: opts.agent,
-				provider: opts.provider,
-				model: opts.model,
-				createdAt: Date.now(),
-			});
+				try {
+					await completeAssistantMessage({}, opts, db);
+				} catch (err) {
+					debugLog(
+						`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
+					);
+				}
 
-			publish({
-				type: 'message.created',
-				sessionId: opts.sessionId,
-				payload: {
+				const continuationMessageId = crypto.randomUUID();
+				await db.insert(messages).values({
 					id: continuationMessageId,
+					sessionId: opts.sessionId,
 					role: 'assistant',
+					status: 'pending',
 					agent: opts.agent,
 					provider: opts.provider,
 					model: opts.model,
-				},
-			});
+					createdAt: Date.now(),
+				});
 
-			enqueueAssistantRun(
-				{
-					...opts,
-					assistantMessageId: continuationMessageId,
-					continuationCount: continuationCount + 1,
-				},
-				runSessionLoop,
-			);
-			return;
+				publish({
+					type: 'message.created',
+					sessionId: opts.sessionId,
+					payload: {
+						id: continuationMessageId,
+						role: 'assistant',
+						agent: opts.agent,
+						provider: opts.provider,
+						model: opts.model,
+					},
+				});
+
+				enqueueAssistantRun(
+					{
+						...opts,
+						assistantMessageId: continuationMessageId,
+						continuationCount: continuationCount + 1,
+					},
+					runSessionLoop,
+				);
+				return;
+			}
 		}
 		if (
 			continuationDecision.reason === 'max-continuations-reached' &&

package/src/runtime/provider/index.ts

@@ -25,7 +25,7 @@ export async function resolveModel(
 	},
 ) {
 	if (provider === 'openai') {
-		return resolveOpenAIModel(model, cfg);
+		return resolveOpenAIModel(model, cfg, options?.sessionId);
 	}
 	if (provider === 'anthropic') {
 		const instance = await getAnthropicInstance(cfg);

package/src/runtime/provider/openai.ts

@@ -2,12 +2,17 @@ import type { OttoConfig } from '@ottocode/sdk';
 import { getAuth, createOpenAIOAuthModel } from '@ottocode/sdk';
 import { openai, createOpenAI } from '@ai-sdk/openai';
 
-export async function resolveOpenAIModel(model: string, cfg: OttoConfig) {
+export async function resolveOpenAIModel(
+	model: string,
+	cfg: OttoConfig,
+	sessionId?: string,
+) {
 	const auth = await getAuth('openai', cfg.projectRoot);
 	if (auth?.type === 'oauth') {
 		return createOpenAIOAuthModel(model, {
 			oauth: auth,
 			projectRoot: cfg.projectRoot,
+			sessionId,
 		});
 	}
 	if (auth?.type === 'api' && auth.key) {