@ottocode/server 0.1.225 → 0.1.227

package/src/routes/config/utils.ts

@@ -63,7 +63,8 @@ export async function getAuthTypeForProvider(
 	projectRoot: string,
 ): Promise<'api' | 'oauth' | 'wallet' | undefined> {
 	if (embeddedConfig?.auth?.[provider]) {
-		return embeddedConfig.auth[provider].type as 'api' | 'oauth' | 'wallet';
+		const embeddedAuth = embeddedConfig.auth[provider];
+		return 'type' in embeddedAuth ? embeddedAuth.type : 'api';
 	}
 	const auth = await getAuth(provider, projectRoot);
 	return auth?.type as 'api' | 'oauth' | 'wallet' | undefined;
@@ -83,7 +84,9 @@ export async function discoverAllAgents(
 			}
 		}
 	} catch (err) {
-		logger.debug('Failed to load agents.json', err);
+		logger.debug('Failed to load agents.json', {
+			error: err instanceof Error ? err.message : String(err),
+		});
 	}
 
 	try {
@@ -98,7 +101,9 @@ export async function discoverAllAgents(
 			}
 		}
 	} catch (err) {
-		logger.debug('Failed to read local agents directory', err);
+		logger.debug('Failed to read local agents directory', {
+			error: err instanceof Error ? err.message : String(err),
+		});
 	}
 
 	try {
@@ -113,7 +118,9 @@ export async function discoverAllAgents(
 			}
 		}
 	} catch (err) {
-		logger.debug('Failed to read global agents directory', err);
+		logger.debug('Failed to read global agents directory', {
+			error: err instanceof Error ? err.message : String(err),
+		});
 	}
 
 	return Array.from(agentSet).sort();

package/src/routes/terminals.ts

@@ -87,12 +87,14 @@ export function registerTerminalsRoutes(
 			return c.json({ error: 'Terminal not found' }, 404);
 		}
 
+		const activeTerminal = terminal;
+
 		return streamSSE(c, async (stream) => {
 			logger.debug('SSE stream started for terminal', { id });
 			// Send historical buffer first (unless skipHistory is set)
 			const skipHistory = c.req.query('skipHistory') === 'true';
 			if (!skipHistory) {
-				const history = terminal.read();
+				const history = activeTerminal.read();
 				logger.debug('SSE sending terminal history', {
 					id,
 					lines: history.length,
@@ -120,8 +122,8 @@ export function registerTerminalsRoutes(
 			let finished = false;
 
 			function cleanup() {
-				terminal.removeDataListener(onData);
-				terminal.removeExitListener(onExit);
+				activeTerminal.removeDataListener(onData);
+				activeTerminal.removeExitListener(onExit);
 				c.req.raw.signal.removeEventListener('abort', onAbort);
 			}
 
@@ -145,7 +147,7 @@ export function registerTerminalsRoutes(
 
 			function onAbort() {
 				logger.debug('SSE client disconnected from terminal', {
-					id: terminal.id,
+					id: activeTerminal.id,
 				});
 				stream.close();
 				finish();

package/src/routes/tunnel.ts

@@ -59,7 +59,7 @@ export function registerTunnelRoutes(app: Hono) {
 
 			const url = await activeTunnel.start(port, (msg) => {
 				progressMessage = msg;
-				logger.debug('Tunnel progress:', msg);
+				logger.debug('Tunnel progress', { message: msg });
 			});
 
 			tunnelUrl = url;

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

@@ -2,12 +2,14 @@ export type OauthCodexContinuationInput = {
 	provider: string;
 	isOpenAIOAuth: boolean;
 	finishObserved: boolean;
+	abortedByUser?: boolean;
 	continuationCount: number;
 	maxContinuations: number;
 	finishReason?: string;
 	rawFinishReason?: string;
 	firstToolSeen: boolean;
 	hasTrailingAssistantText: boolean;
+	endedWithToolActivity?: boolean;
 	droppedPseudoToolText: boolean;
 	lastAssistantText: string;
 };
@@ -68,6 +70,10 @@ export function decideOauthCodexContinuation(
 		return { shouldContinue: false };
 	}
 
+	if (input.abortedByUser) {
+		return { shouldContinue: false, reason: 'aborted-by-user' };
+	}
+
 	if (input.continuationCount >= input.maxContinuations) {
 		return { shouldContinue: false, reason: 'max-continuations-reached' };
 	}
@@ -76,6 +82,10 @@ export function decideOauthCodexContinuation(
 		return { shouldContinue: true, reason: 'truncated' };
 	}
 
+	if (input.endedWithToolActivity) {
+		return { shouldContinue: true, reason: 'ended-on-tool-activity' };
+	}
+
 	if (isMissingAssistantSummary(input)) {
 		return { shouldContinue: true, reason: 'no-trailing-assistant-text' };
 	}

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

@@ -211,6 +211,13 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 	const providerOptions = { ...adapted.providerOptions };
 	let effectiveMaxOutputTokens = maxOutputTokens;
 
+	if (opts.provider === 'copilot') {
+		providerOptions.openai = {
+			...((providerOptions.openai as Record<string, unknown>) || {}),
+			store: false,
+		};
+	}
+
 	if (opts.reasoningText) {
 		const underlyingProvider = getUnderlyingProviderKey(
 			opts.provider,

package/src/runtime/agent/runner.ts

@@ -182,11 +182,16 @@ async function runAssistant(opts: RunOpts) {
 	let _finishObserved = false;
 	let _toolActivityObserved = false;
 	let _trailingAssistantTextAfterTool = false;
+	let _abortedByUser = false;
+	let titleGenerationTriggered = false;
 	const unsubscribeFinish = subscribe(opts.sessionId, (evt) => {
 		if (evt.type === 'tool.call' || evt.type === 'tool.result') {
 			_toolActivityObserved = true;
 			_trailingAssistantTextAfterTool = false;
 		}
+		if (evt.type === 'tool.call') {
+			triggerTitleGenerationWhenReady();
+		}
 		if (evt.type !== 'tool.result') return;
 		try {
 			const name = (evt.payload as { name?: string } | undefined)?.name;
@@ -221,6 +226,22 @@ async function runAssistant(opts: RunOpts) {
 		stepIndex += 1;
 		return stepIndex;
 	};
+	const triggerTitleGenerationWhenReady = () => {
+		if (titleGenerationTriggered) {
+			return;
+		}
+
+		titleGenerationTriggered = true;
+		if (!isFirstMessage) {
+			return;
+		}
+
+		void triggerDeferredTitleGeneration({
+			cfg,
+			db,
+			sessionId: opts.sessionId,
+		});
+	};
 
 	const reasoningStates = new Map<string, ReasoningState>();
 
@@ -232,6 +253,7 @@ async function runAssistant(opts: RunOpts) {
 		getCurrentPartId,
 		updateCurrentPartId,
 		updateAccumulated,
+		triggerTitleGenerationWhenReady,
 		sharedCtx,
 		updateSessionTokensIncremental,
 		updateMessageTokensIncremental,
@@ -245,12 +267,19 @@ async function runAssistant(opts: RunOpts) {
 		runSessionLoop,
 	);
 
-	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
+	const baseOnAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
+	const onAbort = async (event: Parameters<typeof baseOnAbort>[0]) => {
+		_abortedByUser = true;
+		await baseOnAbort(event);
+	};
 
 	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
-	const stopWhenCondition = isOpenAIOAuth
-		? stepCountIs(20)
-		: hasToolCall('finish');
+	const isCopilotResponsesApi =
+		opts.provider === 'copilot' && !opts.model.startsWith('gpt-5-mini');
+	const stopWhenCondition =
+		isOpenAIOAuth || isCopilotResponsesApi
+			? stepCountIs(20)
+			: hasToolCall('finish');
 
 	try {
 		const result = streamText({
@@ -307,13 +336,6 @@ async function runAssistant(opts: RunOpts) {
 				if (!firstDeltaSeen) {
 					firstDeltaSeen = true;
 					streamStartTimer.end();
-					if (isFirstMessage) {
-						void triggerDeferredTitleGeneration({
-							cfg,
-							db,
-							sessionId: opts.sessionId,
-						});
-					}
 				}
 
 				if (!currentPartId) {
@@ -421,16 +443,20 @@ async function runAssistant(opts: RunOpts) {
 
 		const MAX_CONTINUATIONS = 6;
 		const continuationCount = opts.continuationCount ?? 0;
+		const endedWithToolActivity =
+			_toolActivityObserved && !_trailingAssistantTextAfterTool;
 		const continuationDecision = decideOauthCodexContinuation({
 			provider: opts.provider,
 			isOpenAIOAuth,
 			finishObserved: _finishObserved,
+			abortedByUser: _abortedByUser,
 			continuationCount,
 			maxContinuations: MAX_CONTINUATIONS,
 			finishReason: streamFinishReason,
 			rawFinishReason: streamRawFinishReason,
 			firstToolSeen: fs,
 			hasTrailingAssistantText: _trailingAssistantTextAfterTool,
+			endedWithToolActivity,
 			droppedPseudoToolText: oauthTextGuard?.dropped ?? false,
 			lastAssistantText: latestAssistantText,
 		});

package/src/runtime/ask/service.ts

@@ -127,7 +127,12 @@ async function processAskRequest(
 				google: { enabled: true },
 				openrouter: { enabled: true },
 				opencode: { enabled: true },
+				copilot: { enabled: true },
 				setu: { enabled: true },
+				zai: { enabled: true },
+				'zai-coding': { enabled: true },
+				moonshot: { enabled: true },
+				minimax: { enabled: true },
 			},
 			paths: {
 				dataDir: `${projectRoot}/.otto`,

package/src/runtime/errors/api-error.ts

@@ -5,6 +5,7 @@
  * across all API endpoints.
  */
 
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
 import { isDebugEnabled } from '../debug/state.ts';
 import { toErrorPayload } from './handling.ts';
 
@@ -16,7 +17,7 @@ export type APIErrorResponse = {
 		message: string;
 		type: string;
 		code?: string;
-		status?: number;
+		status?: ContentfulStatusCode;
 		details?: Record<string, unknown>;
 		stack?: string;
 	};
@@ -27,29 +28,33 @@ export type APIErrorResponse = {
  */
 export class APIError extends Error {
 	public readonly code?: string;
-	public readonly status: number;
+	public readonly status: ContentfulStatusCode;
 	public readonly type: string;
 	public readonly details?: Record<string, unknown>;
 
 	constructor(
 		message: string,
-		options?: {
-			code?: string;
-			status?: number;
-			type?: string;
-			details?: Record<string, unknown>;
-			cause?: unknown;
-		},
+		options?:
+			| ContentfulStatusCode
+			| {
+					code?: string;
+					status?: ContentfulStatusCode;
+					type?: string;
+					details?: Record<string, unknown>;
+					cause?: unknown;
+			  },
 	) {
 		super(message);
 		this.name = 'APIError';
-		this.code = options?.code;
-		this.status = options?.status ?? 500;
-		this.type = options?.type ?? 'api_error';
-		this.details = options?.details;
-
-		if (options?.cause) {
-			this.cause = options.cause;
+		const normalizedOptions =
+			typeof options === 'number' ? { status: options } : options;
+		this.code = normalizedOptions?.code;
+		this.status = normalizedOptions?.status ?? 500;
+		this.type = normalizedOptions?.type ?? 'api_error';
+		this.details = normalizedOptions?.details;
+
+		if (normalizedOptions?.cause) {
+			this.cause = normalizedOptions.cause;
 		}
 
 		// Maintain proper stack trace
@@ -72,7 +77,7 @@ export function serializeError(err: unknown): APIErrorResponse {
 	// Determine HTTP status code
 	// Default to 400 for generic errors (client errors)
 	// Only use 500 if explicitly set or for APIError instances without a status
-	let status = 400;
+	let status: ContentfulStatusCode = 400;
 
 	// Handle APIError instances first
 	if (err instanceof APIError) {
@@ -80,15 +85,16 @@ export function serializeError(err: unknown): APIErrorResponse {
 	} else if (err && typeof err === 'object') {
 		const errObj = err as Record<string, unknown>;
 		if (typeof errObj.status === 'number') {
-			status = errObj.status;
+			status = errObj.status as ContentfulStatusCode;
 		} else if (typeof errObj.statusCode === 'number') {
-			status = errObj.statusCode;
+			status = errObj.statusCode as ContentfulStatusCode;
 		} else if (
 			errObj.details &&
 			typeof errObj.details === 'object' &&
 			typeof (errObj.details as Record<string, unknown>).statusCode === 'number'
 		) {
-			status = (errObj.details as Record<string, unknown>).statusCode as number;
+			status = (errObj.details as Record<string, unknown>)
+				.statusCode as ContentfulStatusCode;
 		}
 	}
 
@@ -130,7 +136,9 @@ export function serializeError(err: unknown): APIErrorResponse {
  * @param err - The error to convert
  * @returns Tuple of [APIErrorResponse, HTTP status code]
  */
-export function createErrorResponse(err: unknown): [APIErrorResponse, number] {
+export function createErrorResponse(
+	err: unknown,
+): [APIErrorResponse, ContentfulStatusCode] {
 	const response = serializeError(err);
 	return [response, response.error.status ?? 500];
 }

package/src/runtime/message/service.ts

@@ -284,7 +284,7 @@ async function generateSessionTitle(args: {
 			return;
 		}
 
-		const provider = sess.provider ?? cfg.defaults.provider;
+		const provider = (sess.provider ?? cfg.defaults.provider) as ProviderId;
 		const modelName = sess.model ?? cfg.defaults.model;
 
 		debugLog('[TITLE_GEN] Generating title for session');
@@ -365,7 +365,7 @@ Output ONLY the title, nothing else.`;
 
 		await db
 			.update(sessions)
-			.set({ title: sanitized, updatedAt: Date.now() })
+			.set({ title: sanitized, lastActiveAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
 
 		debugLog(`[TITLE_GEN] Setting final title: "${sanitized}"`);

package/src/runtime/provider/copilot.ts

@@ -1,12 +1,123 @@
-import { getAuth, createCopilotModel } from '@ottocode/sdk';
-import type { OttoConfig } from '@ottocode/sdk';
+import { getAuth, createCopilotModel, readEnvKey } from '@ottocode/sdk';
+import type { OttoConfig, OAuth } from '@ottocode/sdk';
 
-export async function resolveCopilotModel(model: string, cfg: OttoConfig) {
-	const auth = await getAuth('copilot', cfg.projectRoot);
+const COPILOT_MODELS_URL = 'https://api.githubcopilot.com/models';
+const COPILOT_MODELS_CACHE_TTL_MS = 5 * 60 * 1000;
+
+type CachedCopilotModels = {
+	expiresAt: number;
+	models: Set<string>;
+};
+
+const copilotModelsCache = new Map<string, CachedCopilotModels>();
+
+type CopilotTokenCandidate = {
+	source: 'env' | 'oauth';
+	token: string;
+	oauth: OAuth;
+};
+
+async function getCopilotTokenCandidates(
+	projectRoot: string,
+): Promise<CopilotTokenCandidate[]> {
+	const candidates: CopilotTokenCandidate[] = [];
+
+	const envToken = readEnvKey('copilot');
+	if (envToken) {
+		candidates.push({
+			source: 'env',
+			token: envToken,
+			oauth: {
+				type: 'oauth',
+				access: envToken,
+				refresh: envToken,
+				expires: 0,
+			},
+		});
+	}
+
+	const auth = await getAuth('copilot', projectRoot);
 	if (auth?.type === 'oauth') {
-		return createCopilotModel(model, { oauth: auth });
+		if (auth.refresh !== envToken) {
+			candidates.push({ source: 'oauth', token: auth.refresh, oauth: auth });
+		}
+	}
+
+	return candidates;
+}
+
+async function getCopilotAvailableModels(
+	token: string,
+): Promise<Set<string> | null> {
+	const cached = copilotModelsCache.get(token);
+	if (cached && cached.expiresAt > Date.now()) {
+		return cached.models;
+	}
+
+	try {
+		const response = await fetch(COPILOT_MODELS_URL, {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				'Openai-Intent': 'conversation-edits',
+				'User-Agent': 'ottocode',
+			},
+		});
+
+		if (!response.ok) return null;
+
+		const payload = (await response.json()) as {
+			data?: Array<{ id?: string }>;
+		};
+		const models = new Set(
+			(payload.data ?? [])
+				.map((item) => item.id)
+				.filter((id): id is string => Boolean(id)),
+		);
+
+		copilotModelsCache.set(token, {
+			expiresAt: Date.now() + COPILOT_MODELS_CACHE_TTL_MS,
+			models,
+		});
+
+		return models;
+	} catch {
+		return null;
+	}
+}
+
+export async function resolveCopilotModel(model: string, cfg: OttoConfig) {
+	const candidates = await getCopilotTokenCandidates(cfg.projectRoot);
+	if (!candidates.length) {
+		throw new Error(
+			'Copilot provider requires OAuth or GITHUB_TOKEN. Run `otto auth login copilot` or set GITHUB_TOKEN.',
+		);
+	}
+
+	let selected: CopilotTokenCandidate | null = null;
+	const unionAvailableModels = new Set<string>();
+
+	for (const candidate of candidates) {
+		const availableModels = await getCopilotAvailableModels(candidate.token);
+		if (!availableModels || availableModels.size === 0) continue;
+
+		for (const availableModel of availableModels) {
+			unionAvailableModels.add(availableModel);
+		}
+
+		if (!selected && availableModels.has(model)) {
+			selected = candidate;
+		}
+	}
+
+	if (selected) {
+		return createCopilotModel(model, { oauth: selected.oauth });
+	}
+
+	if (unionAvailableModels.size > 0) {
+		throw new Error(
+			`Copilot model '${model}' is not available for this account/organization token. Available models: ${Array.from(unionAvailableModels).join(', ')}`,
+		);
 	}
-	throw new Error(
-		'Copilot provider requires OAuth. Run `otto auth login copilot`.',
-	);
+
+	return createCopilotModel(model, { oauth: candidates[0].oauth });
 }

package/src/runtime/provider/oauth-adapter.ts

@@ -69,11 +69,10 @@ export function detectOAuth(
 ): OAuthContext {
 	const isOAuth = auth?.type === 'oauth';
 	const needsSpoof = !!isOAuth && provider === 'anthropic';
-	const isCopilot = provider === 'copilot';
 	return {
-		isOAuth: !!isOAuth || isCopilot,
+		isOAuth: !!isOAuth,
 		needsSpoof,
-		isOpenAIOAuth: (!!isOAuth && provider === 'openai') || isCopilot,
+		isOpenAIOAuth: !!isOAuth && provider === 'openai',
 		spoofPrompt: needsSpoof ? getProviderSpoofPrompt(provider) : undefined,
 	};
 }

package/src/runtime/session/branch.ts

@@ -160,7 +160,14 @@ export async function createBranch({
 	}
 
 	const result: SessionRow = {
-		...newSession,
+		id: newSession.id,
+		title: newSession.title ?? null,
+		agent: newSession.agent,
+		provider: newSession.provider,
+		model: newSession.model,
+		projectPath: newSession.projectPath,
+		createdAt: newSession.createdAt,
+		lastActiveAt: newSession.lastActiveAt ?? null,
 		totalInputTokens: null,
 		totalOutputTokens: null,
 		totalCachedTokens: null,
@@ -171,6 +178,9 @@ export async function createBranch({
 		currentContextTokens: null,
 		contextSummary: null,
 		lastCompactedAt: null,
+		parentSessionId: newSession.parentSessionId ?? null,
+		branchPointMessageId: newSession.branchPointMessageId ?? null,
+		sessionType: newSession.sessionType ?? null,
 	};
 
 	publish({

package/src/runtime/session/manager.ts

@@ -39,7 +39,7 @@ export async function createSession({
 	await ensureProviderEnv(cfg, provider);
 	const id = crypto.randomUUID();
 	const now = Date.now();
-	const row = {
+	const row: SessionRow = {
 		id,
 		title: title ?? null,
 		agent,
@@ -56,6 +56,11 @@ export async function createSession({
 		totalToolTimeMs: null,
 		toolCountsJson: null,
 		currentContextTokens: null,
+		contextSummary: null,
+		lastCompactedAt: null,
+		parentSessionId: null,
+		branchPointMessageId: null,
+		sessionType: 'main',
 	};
 	await db.insert(sessions).values(row);
 	publish({ type: 'session.created', sessionId: id, payload: row });

package/src/runtime/stream/step-finish.ts

@@ -16,6 +16,7 @@ export function createStepFinishHandler(
 	getCurrentPartId: () => string | null,
 	updateCurrentPartId: (id: string | null) => void,
 	updateAccumulated: (text: string) => void,
+	triggerTitleGenerationWhenReady: () => void,
 	sharedCtx: ToolAdapterContext,
 	updateSessionTokensIncrementalFn: (
 		usage: UsageData,
@@ -31,6 +32,8 @@ export function createStepFinishHandler(
 	) => Promise<void>,
 ) {
 	return async (step: StepFinishEvent) => {
+		triggerTitleGenerationWhenReady();
+
 		const finishedAt = Date.now();
 		const currentPartId = getCurrentPartId();
 		const stepIndex = getStepIndex();

package/src/runtime/utils/token.ts

@@ -10,6 +10,9 @@ export function getMaxOutputTokens(
 	provider: ProviderName,
 	modelId: string,
 ): number | undefined {
+	if (provider === 'copilot') {
+		return undefined;
+	}
 	try {
 		const providerCatalog = catalog[provider];
 		if (!providerCatalog) {

package/src/tools/adapter.ts

@@ -130,12 +130,13 @@ export function adaptTools(
 			}: {
 				callId?: string;
 				startTs?: number;
-				stepIndexForEvent: number;
+				stepIndexForEvent?: number;
 				args?: unknown;
 			},
 		) => {
 			const resultPartId = crypto.randomUUID();
 			const endTs = Date.now();
+			const effectiveStepIndex = stepIndexForEvent ?? ctx.stepIndex;
 			const dur =
 				typeof startTs === 'number' ? Math.max(0, endTs - startTs) : null;
 
@@ -160,7 +161,7 @@ export function adaptTools(
 				id: resultPartId,
 				messageId: ctx.messageId,
 				index,
-				stepIndex: stepIndexForEvent,
+				stepIndex: effectiveStepIndex,
 				type: 'tool_result',
 				content: JSON.stringify(contentObj),
 				agent: ctx.agent,
@@ -176,7 +177,7 @@ export function adaptTools(
 			publish({
 				type: 'tool.result',
 				sessionId: ctx.sessionId,
-				payload: { ...contentObj, stepIndex: stepIndexForEvent },
+				payload: { ...contentObj, stepIndex: effectiveStepIndex },
 			});
 		};