@ottocode/server 0.1.196 → 0.1.197

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.196",
+	"version": "0.1.197",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -14,6 +14,26 @@
 			"import": "./src/runtime/agent-registry.ts",
 			"types": "./src/runtime/agent-registry.ts"
 		},
+		"./runtime/ask/service": {
+			"import": "./src/runtime/ask/service.ts",
+			"types": "./src/runtime/ask/service.ts"
+		},
+		"./runtime/agent/runner": {
+			"import": "./src/runtime/agent/runner.ts",
+			"types": "./src/runtime/agent/runner.ts"
+		},
+		"./events/bus": {
+			"import": "./src/events/bus.ts",
+			"types": "./src/events/bus.ts"
+		},
+		"./events/types": {
+			"import": "./src/events/types.ts",
+			"types": "./src/events/types.ts"
+		},
+		"./runtime/tools/approval": {
+			"import": "./src/runtime/tools/approval.ts",
+			"types": "./src/runtime/tools/approval.ts"
+		},
 		"./runtime/ask-service.ts": {
 			"import": "./src/runtime/ask-service.ts",
 			"types": "./src/runtime/ask-service.ts"
@@ -29,8 +49,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.196",
-		"@ottocode/database": "0.1.196",
+		"@ottocode/sdk": "0.1.197",
+		"@ottocode/database": "0.1.197",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

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

@@ -0,0 +1,72 @@
+export type OauthCodexContinuationInput = {
+	provider: string;
+	isOpenAIOAuth: boolean;
+	finishObserved: boolean;
+	continuationCount: number;
+	maxContinuations: number;
+	finishReason?: string;
+	rawFinishReason?: string;
+	firstToolSeen: boolean;
+	droppedPseudoToolText: boolean;
+	lastAssistantText: string;
+};
+
+export type OauthCodexContinuationDecision = {
+	shouldContinue: boolean;
+	reason?: string;
+};
+
+const INTERMEDIATE_PROGRESS_PATTERNS: RegExp[] = [
+	/\bnext\s+i(?:['\u2019]ll|\s+will)\b/i,
+	/\bnow\s+i(?:['\u2019]ll|\s+will)\b/i,
+	/\bi(?:['\u2019]ll|\s+will)\s+(inspect|check|look|read|scan|trace|review|update|fix|implement|run|continue|retry)\b/i,
+	/\bi(?:\s+am|\s*'m)\s+going\s+to\b/i,
+	/\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;
+	return INTERMEDIATE_PROGRESS_PATTERNS.some((pattern) =>
+		pattern.test(trimmed),
+	);
+}
+
+function isTruncatedResponse(
+	finishReason?: string,
+	rawFinishReason?: string,
+): boolean {
+	if (finishReason === 'length') return true;
+	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.
+ */
+export function decideOauthCodexContinuation(
+	input: OauthCodexContinuationInput,
+): OauthCodexContinuationDecision {
+	if (input.provider !== 'openai' || !input.isOpenAIOAuth) {
+		return { shouldContinue: false };
+	}
+
+	if (input.finishObserved) {
+		return { shouldContinue: false };
+	}
+
+	if (input.continuationCount >= input.maxContinuations) {
+		return { shouldContinue: false, reason: 'max-continuations-reached' };
+	}
+
+	if (isTruncatedResponse(input.finishReason, input.rawFinishReason)) {
+		return { shouldContinue: true, reason: 'truncated' };
+	}
+
+	return { shouldContinue: false };
+}

package/src/runtime/agent/runner-setup.ts

@@ -110,6 +110,7 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 		includeProjectTree: isFirstMessage,
 		userContext: opts.userContext,
 		contextSummary,
+		isOpenAIOAuth: oauth.isOpenAIOAuth,
 	});
 
 	const rawMaxOutputTokens = getMaxOutputTokens(opts.provider, opts.model);

package/src/runtime/agent/runner.ts

@@ -1,4 +1,4 @@
-import { hasToolCall, streamText } from 'ai';
+import { hasToolCall, stepCountIs, streamText } from 'ai';
 import { messages, messageParts } from '@ottocode/database/schema';
 import { eq } from 'drizzle-orm';
 import { publish, subscribe } from '../../events/bus.ts';
@@ -32,6 +32,11 @@ import {
 	handleReasoningDelta,
 	handleReasoningEnd,
 } from './runner-reasoning.ts';
+import {
+	createOauthCodexTextGuardState,
+	consumeOauthCodexTextDelta,
+} from '../stream/text-guard.ts';
+import { decideOauthCodexContinuation } from './oauth-codex-continuation.ts';
 
 export {
 	enqueueAssistantRun,
@@ -94,11 +99,34 @@ async function runAssistant(opts: RunOpts) {
 	}> = [...additionalSystemMessages, ...history];
 
 	if (!isFirstMessage) {
-		messagesWithSystemInstructions.push({
-			role: isOpenAIOAuth ? 'system' : 'user',
-			content:
-				'SYSTEM REMINDER: You are continuing an existing session. When you have completed the task, you MUST stream a text summary of what you did to the user, and THEN call the `finish` tool. Do not call `finish` without a summary.',
-		});
+		if (isOpenAIOAuth) {
+			messagesWithSystemInstructions.push({
+				role: 'system',
+				content:
+					'SYSTEM REMINDER: You are continuing an existing session. Continue executing directly, use tools as needed, and provide a concise final summary when complete.',
+			});
+		} else {
+			messagesWithSystemInstructions.push({
+				role: 'user',
+				content:
+					'SYSTEM REMINDER: You are continuing an existing session. When you have completed the task, you MUST stream a text summary of what you did to the user, and THEN call the `finish` tool. Do not call `finish` without a summary.',
+			});
+		}
+	}
+	if ((opts.continuationCount ?? 0) > 0) {
+		if (isOpenAIOAuth) {
+			messagesWithSystemInstructions.push({
+				role: 'system',
+				content:
+					'SYSTEM REMINDER: Your previous response stopped mid-task. Continue immediately from where you left off and finish the actual implementation, not just a plan update.',
+			});
+		} else {
+			messagesWithSystemInstructions.push({
+				role: 'user',
+				content:
+					'SYSTEM REMINDER: Your previous response stopped before calling `finish`. Continue executing immediately from where you left off, avoid plan-only updates, and call `finish` only after streaming the final user summary.',
+			});
+		}
 	}
 
 	debugLog(
@@ -123,7 +151,11 @@ async function runAssistant(opts: RunOpts) {
 
 	let currentPartId: string | null = null;
 	let accumulated = '';
+	let latestAssistantText = '';
 	let stepIndex = 0;
+	const oauthTextGuard = isOpenAIOAuth
+		? createOauthCodexTextGuardState()
+		: null;
 
 	const getCurrentPartId = () => currentPartId;
 	const getStepIndex = () => stepIndex;
@@ -164,6 +196,9 @@ async function runAssistant(opts: RunOpts) {
 	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
 
 	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
+	const stopWhenCondition = isOpenAIOAuth
+		? stepCountIs(48)
+		: hasToolCall('finish');
 
 	try {
 		const result = streamText({
@@ -177,7 +212,7 @@ async function runAssistant(opts: RunOpts) {
 				: {}),
 			...(Object.keys(providerOptions).length > 0 ? { providerOptions } : {}),
 			abortSignal: opts.abortSignal,
-			stopWhen: hasToolCall('finish'),
+			stopWhen: stopWhenCondition,
 			// biome-ignore lint/suspicious/noExplicitAny: AI SDK callback types mismatch
 			onStepFinish: onStepFinish as any,
 			// biome-ignore lint/suspicious/noExplicitAny: AI SDK callback types mismatch
@@ -193,10 +228,18 @@ async function runAssistant(opts: RunOpts) {
 			if (!part) continue;
 
 			if (part.type === 'text-delta') {
-				const delta = part.text;
+				const rawDelta = part.text;
+				if (!rawDelta) continue;
+
+				const delta = oauthTextGuard
+					? consumeOauthCodexTextDelta(oauthTextGuard, rawDelta)
+					: rawDelta;
 				if (!delta) continue;
 
 				accumulated += delta;
+				if (accumulated.trim()) {
+					latestAssistantText = accumulated;
+				}
 
 				if (!currentPartId && !accumulated.trim()) {
 					continue;
@@ -282,6 +325,11 @@ async function runAssistant(opts: RunOpts) {
 		}
 
 		const fs = firstToolSeen();
+		if (oauthTextGuard?.dropped) {
+			debugLog(
+				'[RUNNER] Dropped pseudo tool-call text leaked by OpenAI OAuth stream',
+			);
+		}
 		if (!fs && !_finishObserved) {
 			publish({
 				type: 'finish-step',
@@ -301,66 +349,81 @@ async function runAssistant(opts: RunOpts) {
 			streamFinishReason = undefined;
 		}
 
+		let streamRawFinishReason: string | undefined;
+		try {
+			streamRawFinishReason = await result.rawFinishReason;
+		} catch {
+			streamRawFinishReason = undefined;
+		}
+
 		debugLog(
-			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, finishReason=${streamFinishReason}`,
+			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}`,
 		);
 
-		const wasTruncated = streamFinishReason === 'length';
+		const MAX_CONTINUATIONS = 6;
+		const continuationCount = opts.continuationCount ?? 0;
+		const continuationDecision = decideOauthCodexContinuation({
+			provider: opts.provider,
+			isOpenAIOAuth,
+			finishObserved: _finishObserved,
+			continuationCount,
+			maxContinuations: MAX_CONTINUATIONS,
+			finishReason: streamFinishReason,
+			rawFinishReason: streamRawFinishReason,
+			firstToolSeen: fs,
+			droppedPseudoToolText: oauthTextGuard?.dropped ?? false,
+			lastAssistantText: latestAssistantText,
+		});
 
-		const shouldContinue =
-			opts.provider === 'openai' &&
-			isOpenAIOAuth &&
-			!_finishObserved &&
-			(wasTruncated || fs);
+		if (continuationDecision.shouldContinue) {
+			debugLog(
+				`[RUNNER] WARNING: Stream ended without finish. reason=${continuationDecision.reason ?? 'unknown'}, finishReason=${streamFinishReason}, rawFinishReason=${streamRawFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
+			);
 
-		if (shouldContinue) {
 			debugLog(
-				`[RUNNER] WARNING: Stream ended without finish. finishReason=${streamFinishReason}, firstToolSeen=${fs}. Auto-continuing.`,
+				`[RUNNER] Auto-continuing (${continuationCount + 1}/${MAX_CONTINUATIONS})...`,
 			);
 
-			const MAX_CONTINUATIONS = 10;
-			const count = opts.continuationCount ?? 0;
-			if (count < MAX_CONTINUATIONS) {
+			try {
+				await completeAssistantMessage({}, opts, db);
+			} catch (err) {
 				debugLog(
-					`[RUNNER] Auto-continuing (${count + 1}/${MAX_CONTINUATIONS})...`,
+					`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
 				);
+			}
 
-				try {
-					await completeAssistantMessage({}, opts, db);
-				} catch (err) {
-					debugLog(
-						`[RUNNER] completeAssistantMessage failed before continuation: ${err instanceof Error ? err.message : String(err)}`,
-					);
-				}
-
-				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(),
-				});
+			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(),
+			});
 
-				publish({
-					type: 'message.created',
-					sessionId: opts.sessionId,
-					payload: { id: continuationMessageId, role: 'assistant' },
-				});
+			publish({
+				type: 'message.created',
+				sessionId: opts.sessionId,
+				payload: { id: continuationMessageId, role: 'assistant' },
+			});
 
-				enqueueAssistantRun(
-					{
-						...opts,
-						assistantMessageId: continuationMessageId,
-						continuationCount: count + 1,
-					},
-					runSessionLoop,
-				);
-				return;
-			}
+			enqueueAssistantRun(
+				{
+					...opts,
+					assistantMessageId: continuationMessageId,
+					continuationCount: continuationCount + 1,
+				},
+				runSessionLoop,
+			);
+			return;
+		}
+		if (
+			continuationDecision.reason === 'max-continuations-reached' &&
+			!_finishObserved
+		) {
 			debugLog(
 				`[RUNNER] Max continuations (${MAX_CONTINUATIONS}) reached, stopping.`,
 			);

package/src/runtime/message/history-builder.ts

@@ -23,7 +23,11 @@ export async function buildHistoryMessages(
 	const toolHistory = new ToolHistoryTracker();
 
 	for (const m of rows) {
-		if (m.role === 'assistant' && m.status !== 'complete') {
+		if (
+			m.role === 'assistant' &&
+			m.status !== 'complete' &&
+			m.status !== 'completed'
+		) {
 			debugLog(
 				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status} (current turn still in progress)`,
 			);

package/src/runtime/prompt/builder.ts

@@ -12,6 +12,10 @@ import GUIDED_PROMPT from '@ottocode/sdk/prompts/modes/guided.txt' with {
 	type: 'text',
 };
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import OPENAI_OAUTH_PROMPT from '@ottocode/sdk/prompts/providers/openai-oauth.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import ANTHROPIC_SPOOF_PROMPT from '@ottocode/sdk/prompts/providers/anthropicSpoof.txt' with {
 	type: 'text',
 };
@@ -35,6 +39,7 @@ export async function composeSystemPrompt(options: {
 	includeProjectTree?: boolean;
 	userContext?: string;
 	contextSummary?: string;
+	isOpenAIOAuth?: boolean;
 }): Promise<ComposedSystemPrompt> {
 	const components: string[] = [];
 	if (options.spoofPrompt) {
@@ -49,27 +54,38 @@ export async function composeSystemPrompt(options: {
 	}
 
 	const parts: string[] = [];
+	if (options.isOpenAIOAuth) {
+		const oauthInstructions = (OPENAI_OAUTH_PROMPT || '').trim();
+		if (oauthInstructions) {
+			parts.push(oauthInstructions);
+			components.push('provider:openai-oauth');
+		}
+		if (options.agentPrompt.trim()) {
+			parts.push(options.agentPrompt.trim());
+			components.push('agent');
+		}
+	} else {
+		const providerResult = await providerBasePrompt(
+			options.provider,
+			options.model,
+			options.projectRoot,
+		);
+		const baseInstructions = (BASE_PROMPT || '').trim();
 
-	const providerResult = await providerBasePrompt(
-		options.provider,
-		options.model,
-		options.projectRoot,
-	);
-	const baseInstructions = (BASE_PROMPT || '').trim();
-
-	parts.push(
-		providerResult.prompt.trim(),
-		baseInstructions.trim(),
-		options.agentPrompt.trim(),
-	);
-	if (providerResult.prompt.trim()) {
-		components.push(`provider:${providerResult.resolvedType}`);
-	}
-	if (baseInstructions.trim()) {
-		components.push('base');
-	}
-	if (options.agentPrompt.trim()) {
-		components.push('agent');
+		parts.push(
+			providerResult.prompt.trim(),
+			baseInstructions.trim(),
+			options.agentPrompt.trim(),
+		);
+		if (providerResult.prompt.trim()) {
+			components.push(`provider:${providerResult.resolvedType}`);
+		}
+		if (baseInstructions.trim()) {
+			components.push('base');
+		}
+		if (options.agentPrompt.trim()) {
+			components.push('agent');
+		}
 	}
 
 	if (options.oneShot) {

package/src/runtime/stream/error-handler.ts

@@ -188,7 +188,7 @@ export function createErrorHandler(
 			} else {
 				await db
 					.update(messages)
-					.set({ status: 'completed', completedAt: Date.now() })
+					.set({ status: 'complete', completedAt: Date.now() })
 					.where(eq(messages.id, opts.assistantMessageId));
 
 				publish({
@@ -260,7 +260,7 @@ export function createErrorHandler(
 				await db
 					.update(messages)
 					.set({
-						status: compactionSucceeded ? 'completed' : 'error',
+						status: compactionSucceeded ? 'complete' : 'error',
 						completedAt: Date.now(),
 					})
 					.where(eq(messages.id, compactMessageId));

package/src/runtime/stream/text-guard.ts

@@ -0,0 +1,77 @@
+export type OauthCodexTextGuardState = {
+	raw: string;
+	sanitized: string;
+	dropped: boolean;
+};
+
+const LEAK_PATTERNS: RegExp[] = [
+	/assistant\s+to=/i,
+	/assistant\s+to\b/i,
+	/\bassistant\b\s*$/i,
+	/assistant\s+to=functions\./i,
+	/assistant\s+to=functions\b/i,
+	/to=functions\.[a-z0-9_]+\s+(commentary|analysis|final)\b/i,
+	/call:tool\{/i,
+];
+
+function findFirstLeakIndex(text: string): number {
+	let index = -1;
+	for (const pattern of LEAK_PATTERNS) {
+		const match = pattern.exec(text);
+		if (!match || match.index < 0) continue;
+		if (index === -1 || match.index < index) {
+			index = match.index;
+		}
+	}
+	return index;
+}
+
+/**
+ * Removes codex pseudo tool-call leakage from text streams.
+ *
+ * Some OAuth Codex responses leak harness syntax (e.g. "assistant to=functions...")
+ * into user-facing text. Once such a marker appears, everything from that marker
+ * onward is considered non-user text and dropped.
+ */
+export function stripCodexPseudoToolText(raw: string): {
+	sanitized: string;
+	dropped: boolean;
+} {
+	const leakIndex = findFirstLeakIndex(raw);
+	if (leakIndex === -1) {
+		return { sanitized: raw, dropped: false };
+	}
+	return {
+		sanitized: raw.slice(0, leakIndex).trimEnd(),
+		dropped: true,
+	};
+}
+
+export function createOauthCodexTextGuardState(): OauthCodexTextGuardState {
+	return {
+		raw: '',
+		sanitized: '',
+		dropped: false,
+	};
+}
+
+/**
+ * Consumes a raw delta and returns only safe delta text.
+ */
+export function consumeOauthCodexTextDelta(
+	state: OauthCodexTextGuardState,
+	rawDelta: string,
+): string {
+	if (!rawDelta) return '';
+	state.raw += rawDelta;
+	const next = stripCodexPseudoToolText(state.raw);
+	if (next.dropped) state.dropped = true;
+
+	let safeDelta = '';
+	if (next.sanitized.startsWith(state.sanitized)) {
+		safeDelta = next.sanitized.slice(state.sanitized.length);
+	}
+
+	state.sanitized = next.sanitized;
+	return safeDelta;
+}