@ottocode/server 0.1.173

package/src/runtime/session/manager.ts

@@ -0,0 +1,99 @@
+import { desc, eq } from 'drizzle-orm';
+import type { OttoConfig } from '@ottocode/sdk';
+import type { DB } from '@ottocode/database';
+import { sessions } from '@ottocode/database/schema';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+	type ProviderId,
+} from '@ottocode/sdk';
+import { publish } from '../../events/bus.ts';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+type CreateSessionInput = {
+	db: DB;
+	cfg: OttoConfig;
+	agent: string;
+	provider: ProviderId;
+	model: string;
+	title?: string | null;
+};
+
+export async function createSession({
+	db,
+	cfg,
+	agent,
+	provider,
+	model,
+	title,
+}: CreateSessionInput): Promise<SessionRow> {
+	validateProviderModel(provider, model);
+	const authorized = await isProviderAuthorized(cfg, provider);
+	if (!authorized) {
+		throw new Error(
+			`Provider ${provider} is not configured. Run \`otto auth login\` to add credentials.`,
+		);
+	}
+	await ensureProviderEnv(cfg, provider);
+	const id = crypto.randomUUID();
+	const now = Date.now();
+	const row = {
+		id,
+		title: title ?? null,
+		agent,
+		provider,
+		model,
+		projectPath: cfg.projectRoot,
+		createdAt: now,
+		lastActiveAt: now,
+		totalInputTokens: null,
+		totalOutputTokens: null,
+		totalCachedTokens: null,
+		totalCacheCreationTokens: null,
+		totalReasoningTokens: null,
+		totalToolTimeMs: null,
+		toolCountsJson: null,
+		currentContextTokens: null,
+	};
+	await db.insert(sessions).values(row);
+	publish({ type: 'session.created', sessionId: id, payload: row });
+	return row;
+}
+
+type GetSessionInput = {
+	db: DB;
+	projectPath: string;
+	sessionId: string;
+};
+
+export async function getSessionById({
+	db,
+	projectPath,
+	sessionId,
+}: GetSessionInput): Promise<SessionRow | undefined> {
+	const rows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, sessionId));
+	if (!rows.length) return undefined;
+	const row = rows[0];
+	if (row.projectPath !== projectPath) return undefined;
+	return row;
+}
+
+type GetLastSessionInput = { db: DB; projectPath: string };
+
+export async function getLastSession({
+	db,
+	projectPath,
+}: GetLastSessionInput): Promise<SessionRow | undefined> {
+	const rows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.projectPath, projectPath))
+		.orderBy(desc(sessions.lastActiveAt), desc(sessions.createdAt))
+		.limit(1);
+	return rows[0];
+}

package/src/runtime/session/queue.ts

@@ -0,0 +1,243 @@
+import type { ProviderName } from '../provider/index.ts';
+import { publish } from '../../events/bus.ts';
+import type { ToolApprovalMode } from '../tools/approval.ts';
+
+export type RunOpts = {
+	sessionId: string;
+	assistantMessageId: string;
+	agent: string;
+	provider: ProviderName;
+	model: string;
+	projectRoot: string;
+	oneShot?: boolean;
+	userContext?: string;
+	reasoningText?: boolean;
+	abortSignal?: AbortSignal;
+	isCompactCommand?: boolean;
+	compactionContext?: string;
+	toolApprovalMode?: ToolApprovalMode;
+	compactionRetries?: number;
+};
+
+export type QueuedMessage = {
+	messageId: string;
+	position: number;
+};
+
+type RunnerState = {
+	queue: RunOpts[];
+	running: boolean;
+	currentMessageId: string | null;
+};
+
+// Global state for session queues
+const runners = new Map<string, RunnerState>();
+
+// Track active abort controllers per MESSAGE (not session)
+const messageAbortControllers = new Map<string, AbortController>();
+
+function publishQueueState(sessionId: string) {
+	const state = runners.get(sessionId);
+	if (!state) return;
+
+	const queuedMessages: QueuedMessage[] = state.queue.map((opts, index) => ({
+		messageId: opts.assistantMessageId,
+		position: index,
+	}));
+
+	publish({
+		type: 'queue.updated',
+		sessionId,
+		payload: {
+			currentMessageId: state.currentMessageId,
+			queuedMessages,
+			queueLength: state.queue.length,
+		},
+	});
+}
+
+/**
+ * Enqueues an assistant run for a given session.
+ * Creates an abort controller per message.
+ */
+export function enqueueAssistantRun(
+	opts: Omit<RunOpts, 'abortSignal'>,
+	processQueueFn: (sessionId: string) => Promise<void>,
+) {
+	const abortController = new AbortController();
+	messageAbortControllers.set(opts.assistantMessageId, abortController);
+
+	const state = runners.get(opts.sessionId) ?? {
+		queue: [],
+		running: false,
+		currentMessageId: null,
+	};
+	state.queue.push({ ...opts, abortSignal: abortController.signal });
+	runners.set(opts.sessionId, state);
+
+	publishQueueState(opts.sessionId);
+
+	if (!state.running) void processQueueFn(opts.sessionId);
+}
+
+/**
+ * Aborts the currently running message for a session.
+ * Optionally clears the queue.
+ */
+export function abortSession(sessionId: string, clearQueue = false) {
+	const state = runners.get(sessionId);
+	if (!state) return;
+
+	// Abort the currently running message
+	if (state.currentMessageId) {
+		const controller = messageAbortControllers.get(state.currentMessageId);
+		if (controller) {
+			controller.abort();
+			messageAbortControllers.delete(state.currentMessageId);
+		}
+	}
+
+	// Optionally clear the queue and abort all queued messages
+	if (clearQueue && state.queue.length > 0) {
+		for (const opts of state.queue) {
+			const controller = messageAbortControllers.get(opts.assistantMessageId);
+			if (controller) {
+				controller.abort();
+				messageAbortControllers.delete(opts.assistantMessageId);
+			}
+		}
+		state.queue = [];
+		publishQueueState(sessionId);
+	}
+}
+
+/**
+ * Aborts a specific message by its ID.
+ * If it's currently running, aborts the stream.
+ * If it's queued, removes it from the queue.
+ */
+export function abortMessage(
+	sessionId: string,
+	messageId: string,
+): { removed: boolean; wasRunning: boolean } {
+	const state = runners.get(sessionId);
+	if (!state) return { removed: false, wasRunning: false };
+
+	// Check if this is the currently running message
+	if (state.currentMessageId === messageId) {
+		const controller = messageAbortControllers.get(messageId);
+		if (controller) {
+			controller.abort();
+			messageAbortControllers.delete(messageId);
+		}
+		return { removed: true, wasRunning: true };
+	}
+
+	// Check if it's in the queue
+	const index = state.queue.findIndex(
+		(opts) => opts.assistantMessageId === messageId,
+	);
+	if (index !== -1) {
+		state.queue.splice(index, 1);
+		const controller = messageAbortControllers.get(messageId);
+		if (controller) {
+			controller.abort();
+			messageAbortControllers.delete(messageId);
+		}
+		publishQueueState(sessionId);
+		return { removed: true, wasRunning: false };
+	}
+
+	return { removed: false, wasRunning: false };
+}
+
+/**
+ * Removes a queued message (not the currently running one).
+ */
+export function removeFromQueue(sessionId: string, messageId: string): boolean {
+	const state = runners.get(sessionId);
+	if (!state) return false;
+
+	// Don't allow removing the currently running message via this function
+	if (state.currentMessageId === messageId) {
+		return false;
+	}
+
+	const index = state.queue.findIndex(
+		(opts) => opts.assistantMessageId === messageId,
+	);
+	if (index === -1) return false;
+
+	state.queue.splice(index, 1);
+	const controller = messageAbortControllers.get(messageId);
+	if (controller) {
+		controller.abort();
+		messageAbortControllers.delete(messageId);
+	}
+
+	publishQueueState(sessionId);
+	return true;
+}
+
+/**
+ * Gets the current queue state for a session.
+ */
+export function getQueueState(sessionId: string): {
+	currentMessageId: string | null;
+	queuedMessages: QueuedMessage[];
+	isRunning: boolean;
+} | null {
+	const state = runners.get(sessionId);
+	if (!state) return null;
+
+	return {
+		currentMessageId: state.currentMessageId,
+		queuedMessages: state.queue.map((opts, index) => ({
+			messageId: opts.assistantMessageId,
+			position: index,
+		})),
+		isRunning: state.running,
+	};
+}
+
+export function getRunnerState(
+	sessionId: string,
+): { queue: RunOpts[]; running: boolean } | undefined {
+	return runners.get(sessionId);
+}
+
+export function setRunning(sessionId: string, running: boolean) {
+	const state = runners.get(sessionId);
+	if (state) state.running = running;
+}
+
+export function setCurrentMessage(sessionId: string, messageId: string | null) {
+	const state = runners.get(sessionId);
+	if (state) {
+		state.currentMessageId = messageId;
+		publishQueueState(sessionId);
+	}
+}
+
+export function dequeueJob(sessionId: string): RunOpts | undefined {
+	const state = runners.get(sessionId);
+	const job = state?.queue.shift();
+	if (job && state) {
+		state.currentMessageId = job.assistantMessageId;
+		publishQueueState(sessionId);
+	}
+	return job;
+}
+
+export function cleanupSession(sessionId: string) {
+	const state = runners.get(sessionId);
+	if (state && state.queue.length === 0 && !state.running) {
+		// Clean up any lingering abort controller for current message
+		if (state.currentMessageId) {
+			messageAbortControllers.delete(state.currentMessageId);
+		}
+		state.currentMessageId = null;
+		runners.delete(sessionId);
+		publishQueueState(sessionId);
+	}
+}

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

@@ -0,0 +1,65 @@
+import type { getDb } from '@ottocode/database';
+import { messages, messageParts } from '@ottocode/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish } from '../../events/bus.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+import type { AbortEvent } from './types.ts';
+
+export function createAbortHandler(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	getStepIndex: () => number,
+	sharedCtx: ToolAdapterContext,
+) {
+	return async ({ steps }: AbortEvent) => {
+		const stepIndex = getStepIndex();
+
+		const abortPartId = crypto.randomUUID();
+		await db.insert(messageParts).values({
+			id: abortPartId,
+			messageId: opts.assistantMessageId,
+			index: await sharedCtx.nextIndex(),
+			stepIndex,
+			type: 'error',
+			content: JSON.stringify({
+				message: 'Generation stopped by user',
+				type: 'abort',
+				isAborted: true,
+				stepsCompleted: steps.length,
+			}),
+			agent: opts.agent,
+			provider: opts.provider,
+			model: opts.model,
+			startedAt: Date.now(),
+			completedAt: Date.now(),
+		});
+
+		await db
+			.update(messages)
+			.set({
+				status: 'error',
+				error: 'Generation stopped by user',
+				errorType: 'abort',
+				errorDetails: JSON.stringify({
+					stepsCompleted: steps.length,
+					abortedAt: Date.now(),
+				}),
+				isAborted: true,
+			})
+			.where(eq(messages.id, opts.assistantMessageId));
+
+		publish({
+			type: 'error',
+			sessionId: opts.sessionId,
+			payload: {
+				messageId: opts.assistantMessageId,
+				partId: abortPartId,
+				error: 'Generation stopped by user',
+				errorType: 'abort',
+				isAborted: true,
+				stepsCompleted: steps.length,
+			},
+		});
+	};
+}