@agi-cli/server 0.1.118 → 0.1.120

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.118",
+	"version": "0.1.120",
 	"description": "HTTP API server for AGI CLI",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@agi-cli/sdk": "0.1.118",
-		"@agi-cli/database": "0.1.118",
+		"@agi-cli/sdk": "0.1.120",
+		"@agi-cli/database": "0.1.120",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/events/types.ts

@@ -11,6 +11,7 @@ export type AGIEventType =
 	| 'plan.updated'
 	| 'finish-step'
 	| 'usage'
+	| 'queue.updated'
 	| 'error'
 	| 'heartbeat';
 

package/src/index.ts

@@ -14,6 +14,7 @@ import { registerFilesRoutes } from './routes/files.ts';
 import { registerGitRoutes } from './routes/git/index.ts';
 import { registerTerminalsRoutes } from './routes/terminals.ts';
 import { registerSessionFilesRoutes } from './routes/session-files.ts';
+import { registerBranchRoutes } from './routes/branch.ts';
 import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -64,6 +65,7 @@ function initApp() {
 	registerGitRoutes(app);
 	registerTerminalsRoutes(app, globalTerminalManager);
 	registerSessionFilesRoutes(app);
+	registerBranchRoutes(app);
 
 	return app;
 }
@@ -130,6 +132,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
 	registerSessionFilesRoutes(honoApp);
+	registerBranchRoutes(honoApp);
 
 	return honoApp;
 }
@@ -224,6 +227,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerGitRoutes(honoApp);
 	registerTerminalsRoutes(honoApp, globalTerminalManager);
 	registerSessionFilesRoutes(honoApp);
+	registerBranchRoutes(honoApp);
 
 	return honoApp;
 }

package/src/routes/branch.ts

@@ -0,0 +1,106 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { isProviderId, logger } from '@agi-cli/sdk';
+import {
+	createBranch,
+	listBranches,
+	getParentSession,
+} from '../runtime/branch.ts';
+import { serializeError } from '../runtime/api-error.ts';
+
+export function registerBranchRoutes(app: Hono) {
+	app.post('/v1/sessions/:sessionId/branch', 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 body = (await c.req.json().catch(() => ({}))) as Record<
+				string,
+				unknown
+			>;
+
+			const fromMessageId = body.fromMessageId;
+			if (typeof fromMessageId !== 'string' || !fromMessageId.trim()) {
+				return c.json({ error: 'fromMessageId is required' }, 400);
+			}
+
+			const provider =
+				typeof body.provider === 'string' && isProviderId(body.provider)
+					? body.provider
+					: undefined;
+
+			const model =
+				typeof body.model === 'string' && body.model.trim()
+					? body.model.trim()
+					: undefined;
+
+			const agent =
+				typeof body.agent === 'string' && body.agent.trim()
+					? body.agent.trim()
+					: undefined;
+
+			const title =
+				typeof body.title === 'string' && body.title.trim()
+					? body.title.trim()
+					: undefined;
+
+			const result = await createBranch({
+				db,
+				parentSessionId: sessionId,
+				fromMessageId: fromMessageId.trim(),
+				provider,
+				model,
+				agent,
+				title,
+				projectPath: cfg.projectRoot,
+			});
+
+			return c.json(result, 201);
+		} catch (err) {
+			logger.error('Failed to create branch', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 400);
+		}
+	});
+
+	app.get('/v1/sessions/:sessionId/branches', 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 branches = await listBranches(db, sessionId, cfg.projectRoot);
+
+			return c.json({ branches });
+		} catch (err) {
+			logger.error('Failed to list branches', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/sessions/:sessionId/parent', 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 parent = await getParentSession(db, sessionId, cfg.projectRoot);
+
+			if (!parent) {
+				return c.json({ parent: null });
+			}
+
+			return c.json({ parent });
+		} catch (err) {
+			logger.error('Failed to get parent session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/sessions.ts

@@ -1,8 +1,8 @@
 import type { Hono } from 'hono';
 import { loadConfig } from '@agi-cli/sdk';
 import { getDb } from '@agi-cli/database';
-import { sessions } from '@agi-cli/database/schema';
-import { desc, eq } from 'drizzle-orm';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { desc, eq, and, inArray } from 'drizzle-orm';
 import type { ProviderId } from '@agi-cli/sdk';
 import { isProviderId, catalog } from '@agi-cli/sdk';
 import { resolveAgentConfig } from '../runtime/agent-registry.ts';
@@ -194,8 +194,108 @@ export function registerSessionsRoutes(app: Hono) {
 	// Abort session stream
 	app.delete('/v1/sessions/:sessionId/abort', async (c) => {
 		const sessionId = c.req.param('sessionId');
-		const { abortSession } = await import('../runtime/runner.ts');
-		abortSession(sessionId);
+		const body = (await c.req.json().catch(() => ({}))) as Record<
+			string,
+			unknown
+		>;
+		const messageId =
+			typeof body.messageId === 'string' ? body.messageId : undefined;
+		const clearQueue = body.clearQueue === true;
+
+		const { abortSession, abortMessage } = await import('../runtime/runner.ts');
+
+		if (messageId) {
+			const result = abortMessage(sessionId, messageId);
+			return c.json({
+				success: result.removed,
+				wasRunning: result.wasRunning,
+				messageId,
+			});
+		}
+
+		abortSession(sessionId, clearQueue);
 		return c.json({ success: true });
 	});
+
+	// Get queue state for a session
+	app.get('/v1/sessions/:sessionId/queue', async (c) => {
+		const sessionId = c.req.param('sessionId');
+		const { getQueueState } = await import('../runtime/session-queue.ts');
+		const state = getQueueState(sessionId);
+		return c.json(
+			state ?? {
+				currentMessageId: null,
+				queuedMessages: [],
+				isRunning: false,
+			},
+		);
+	});
+
+	// Remove a message from the queue
+	app.delete('/v1/sessions/:sessionId/queue/:messageId', async (c) => {
+		const sessionId = c.req.param('sessionId');
+		const messageId = c.req.param('messageId');
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+		const { removeFromQueue, abortMessage } = await import(
+			'../runtime/session-queue.ts'
+		);
+
+		// First try to remove from queue (queued messages)
+		const removed = removeFromQueue(sessionId, messageId);
+		if (removed) {
+			// Delete messages from database
+			try {
+				// Find the assistant message to get its creation time
+				const assistantMsg = await db
+					.select()
+					.from(messages)
+					.where(eq(messages.id, messageId))
+					.limit(1);
+
+				if (assistantMsg.length > 0) {
+					// Find the user message that came right before (same session, created just before)
+					const userMsg = await db
+						.select()
+						.from(messages)
+						.where(
+							and(eq(messages.sessionId, sessionId), eq(messages.role, 'user')),
+						)
+						.orderBy(desc(messages.createdAt))
+						.limit(1);
+
+					const messageIdsToDelete = [messageId];
+					if (userMsg.length > 0) {
+						messageIdsToDelete.push(userMsg[0].id);
+					}
+
+					// Delete message parts first (foreign key constraint)
+					await db
+						.delete(messageParts)
+						.where(inArray(messageParts.messageId, messageIdsToDelete));
+					// Delete messages
+					await db
+						.delete(messages)
+						.where(inArray(messages.id, messageIdsToDelete));
+				}
+			} catch (err) {
+				logger.error('Failed to delete queued messages from DB', err);
+			}
+			return c.json({ success: true, removed: true, wasQueued: true });
+		}
+
+		// If not in queue, try to abort (might be running)
+		const result = abortMessage(sessionId, messageId);
+		if (result.removed) {
+			return c.json({
+				success: true,
+				removed: true,
+				wasQueued: false,
+				wasRunning: result.wasRunning,
+			});
+		}
+
+		return c.json({ success: false, removed: false }, 404);
+	});
 }

package/src/runtime/branch.ts

@@ -0,0 +1,277 @@
+import { eq, asc } from 'drizzle-orm';
+import type { DB } from '@agi-cli/database';
+import { sessions, messages, messageParts } from '@agi-cli/database/schema';
+import { publish } from '../events/bus.ts';
+import type { ProviderId } from '@agi-cli/sdk';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+export type CreateBranchInput = {
+	db: DB;
+	parentSessionId: string;
+	fromMessageId: string;
+	provider?: ProviderId;
+	model?: string;
+	agent?: string;
+	title?: string;
+	projectPath: string;
+};
+
+export type BranchResult = {
+	session: SessionRow;
+	parentSessionId: string;
+	branchPointMessageId: string;
+	copiedMessages: number;
+	copiedParts: number;
+};
+
+export async function createBranch({
+	db,
+	parentSessionId,
+	fromMessageId,
+	provider,
+	model,
+	agent,
+	title,
+	projectPath,
+}: CreateBranchInput): Promise<BranchResult> {
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, parentSessionId));
+
+	if (!parentRows.length) {
+		throw new Error('Parent session not found');
+	}
+
+	const parent = parentRows[0];
+
+	if (parent.projectPath !== projectPath) {
+		throw new Error('Parent session not found in this project');
+	}
+
+	const branchPointRows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.id, fromMessageId));
+
+	if (!branchPointRows.length) {
+		throw new Error('Branch point message not found');
+	}
+
+	const branchPoint = branchPointRows[0];
+
+	if (branchPoint.sessionId !== parentSessionId) {
+		throw new Error('Branch point message does not belong to parent session');
+	}
+
+	const allMessages = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, parentSessionId))
+		.orderBy(asc(messages.createdAt));
+
+	const branchPointIndex = allMessages.findIndex((m) => m.id === fromMessageId);
+	if (branchPointIndex === -1) {
+		throw new Error('Branch point message not found in session');
+	}
+
+	const messagesToCopy = allMessages.slice(0, branchPointIndex + 1);
+
+	const newSessionId = crypto.randomUUID();
+	const now = Date.now();
+
+	const newSession: typeof sessions.$inferInsert = {
+		id: newSessionId,
+		title: title || `Branch of ${parent.title || 'Untitled'}`,
+		agent: agent || parent.agent,
+		provider: provider || parent.provider,
+		model: model || parent.model,
+		projectPath: parent.projectPath,
+		createdAt: now,
+		lastActiveAt: now,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		sessionType: 'branch',
+	};
+
+	await db.insert(sessions).values(newSession);
+
+	const messageIdMap = new Map<string, string>();
+	let copiedParts = 0;
+
+	for (const msg of messagesToCopy) {
+		const newMessageId = crypto.randomUUID();
+		messageIdMap.set(msg.id, newMessageId);
+
+		const newMessage: typeof messages.$inferInsert = {
+			id: newMessageId,
+			sessionId: newSessionId,
+			role: msg.role,
+			status: msg.status,
+			agent: msg.agent,
+			provider: msg.provider,
+			model: msg.model,
+			createdAt: msg.createdAt,
+			completedAt: msg.completedAt,
+			latencyMs: msg.latencyMs,
+			promptTokens: msg.promptTokens,
+			completionTokens: msg.completionTokens,
+			totalTokens: msg.totalTokens,
+			cachedInputTokens: msg.cachedInputTokens,
+			reasoningTokens: msg.reasoningTokens,
+			error: msg.error,
+			errorType: msg.errorType,
+			errorDetails: msg.errorDetails,
+			isAborted: msg.isAborted,
+		};
+
+		await db.insert(messages).values(newMessage);
+
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, msg.id))
+			.orderBy(asc(messageParts.index));
+
+		for (const part of parts) {
+			const newPart: typeof messageParts.$inferInsert = {
+				id: crypto.randomUUID(),
+				messageId: newMessageId,
+				index: part.index,
+				stepIndex: part.stepIndex,
+				type: part.type,
+				content: part.content,
+				agent: part.agent,
+				provider: part.provider,
+				model: part.model,
+				startedAt: part.startedAt,
+				completedAt: part.completedAt,
+				compactedAt: part.compactedAt,
+				toolName: part.toolName,
+				toolCallId: part.toolCallId,
+				toolDurationMs: part.toolDurationMs,
+			};
+
+			await db.insert(messageParts).values(newPart);
+			copiedParts++;
+		}
+	}
+
+	const result: SessionRow = {
+		...newSession,
+		totalInputTokens: null,
+		totalOutputTokens: null,
+		totalCachedTokens: null,
+		totalReasoningTokens: null,
+		totalToolTimeMs: null,
+		toolCountsJson: null,
+		contextSummary: null,
+		lastCompactedAt: null,
+	};
+
+	publish({
+		type: 'session.created',
+		sessionId: newSessionId,
+		payload: result,
+	});
+
+	return {
+		session: result,
+		parentSessionId,
+		branchPointMessageId: fromMessageId,
+		copiedMessages: messagesToCopy.length,
+		copiedParts,
+	};
+}
+
+export type ListBranchesResult = Array<{
+	session: SessionRow;
+	branchPointMessageId: string | null;
+	branchPointPreview: string | null;
+	createdAt: number;
+}>;
+
+export async function listBranches(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<ListBranchesResult> {
+	const branches = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.parentSessionId, sessionId))
+		.orderBy(asc(sessions.createdAt));
+
+	const results: ListBranchesResult = [];
+
+	for (const branch of branches) {
+		if (branch.projectPath !== projectPath) continue;
+
+		let preview: string | null = null;
+
+		if (branch.branchPointMessageId) {
+			const msgRows = await db
+				.select()
+				.from(messages)
+				.where(eq(messages.id, branch.branchPointMessageId));
+
+			if (msgRows.length > 0) {
+				const parts = await db
+					.select()
+					.from(messageParts)
+					.where(eq(messageParts.messageId, branch.branchPointMessageId))
+					.orderBy(asc(messageParts.index));
+
+				for (const part of parts) {
+					if (part.type === 'text') {
+						try {
+							const content = JSON.parse(part.content || '{}');
+							if (content.text) {
+								preview = content.text.slice(0, 100);
+								break;
+							}
+						} catch {}
+					}
+				}
+			}
+		}
+
+		results.push({
+			session: branch,
+			branchPointMessageId: branch.branchPointMessageId,
+			branchPointPreview: preview,
+			createdAt: branch.createdAt,
+		});
+	}
+
+	return results;
+}
+
+export async function getParentSession(
+	db: DB,
+	sessionId: string,
+	projectPath: string,
+): Promise<SessionRow | null> {
+	const sessionRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, sessionId));
+
+	if (!sessionRows.length) return null;
+
+	const session = sessionRows[0];
+	if (!session.parentSessionId) return null;
+
+	const parentRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, session.parentSessionId));
+
+	if (!parentRows.length) return null;
+
+	const parent = parentRows[0];
+	if (parent.projectPath !== projectPath) return null;
+
+	return parent;
+}

package/src/runtime/provider.ts

@@ -437,6 +437,7 @@ export async function resolveModel(
 	provider: ProviderName,
 	model: string,
 	cfg: AGIConfig,
+	options?: { systemPrompt?: string },
 ) {
 	if (provider === 'openai') {
 		const auth = await getAuth('openai', cfg.projectRoot);
@@ -447,6 +448,7 @@ export async function resolveModel(
 				projectRoot: cfg.projectRoot,
 				reasoningEffort: isCodexModel ? 'high' : 'medium',
 				reasoningSummary: 'auto',
+				instructions: options?.systemPrompt,
 			});
 		}
 		if (auth?.type === 'api' && auth.key) {

package/src/runtime/runner.ts

@@ -34,8 +34,14 @@ import {
 } from './stream-handlers.ts';
 import { getCompactionSystemPrompt, pruneSession } from './compaction.ts';
 
-export { enqueueAssistantRun, abortSession } from './session-queue.ts';
-export { getRunnerState } from './session-queue.ts';
+export {
+	enqueueAssistantRun,
+	abortSession,
+	abortMessage,
+	removeFromQueue,
+	getQueueState,
+	getRunnerState,
+} from './session-queue.ts';
 
 /**
  * Main loop that processes the queue for a given session.
@@ -253,7 +259,14 @@ async function runAssistant(opts: RunOpts) {
 		);
 	}
 
-	const model = await resolveModel(opts.provider, opts.model, cfg);
+	// For OpenAI OAuth, pass the full system prompt as instructions
+	const oauthSystemPrompt =
+		needsSpoof && opts.provider === 'openai' && additionalSystemMessages[0]
+			? additionalSystemMessages[0].content
+			: undefined;
+	const model = await resolveModel(opts.provider, opts.model, cfg, {
+		systemPrompt: oauthSystemPrompt,
+	});
 	debugLog(
 		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,
 	);

package/src/runtime/session-queue.ts

@@ -1,4 +1,5 @@
 import type { ProviderName } from './provider.ts';
+import { publish } from '../events/bus.ts';
 
 export type RunOpts = {
 	sessionId: string;
@@ -15,45 +16,190 @@ export type RunOpts = {
 	compactionContext?: string;
 };
 
-type RunnerState = { queue: RunOpts[]; running: boolean };
+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 session
-const sessionAbortControllers = new Map<string, AbortController>();
+// 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 for the session if one doesn't exist.
+ * Creates an abort controller per message.
  */
 export function enqueueAssistantRun(
 	opts: Omit<RunOpts, 'abortSignal'>,
 	processQueueFn: (sessionId: string) => Promise<void>,
 ) {
-	// Create abort controller for this session
 	const abortController = new AbortController();
-	sessionAbortControllers.set(opts.sessionId, abortController);
+	messageAbortControllers.set(opts.assistantMessageId, abortController);
 
-	const state = runners.get(opts.sessionId) ?? { queue: [], running: false };
+	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);
 }
 
 /**
- * Signals the abort controller for a session.
- * This will trigger the abortSignal in the streamText call.
+ * 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 abortSession(sessionId: string) {
-	const controller = sessionAbortControllers.get(sessionId);
+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();
-		sessionAbortControllers.delete(sessionId);
+		messageAbortControllers.delete(messageId);
 	}
+
+	publishQueueState(sessionId);
+	return true;
 }
 
-export function getRunnerState(sessionId: string): RunnerState | undefined {
+/**
+ * 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);
 }
 
@@ -62,16 +208,33 @@ export function setRunning(sessionId: string, running: boolean) {
 	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);
-	return state?.queue.shift();
+	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);
-		// Clean up any lingering abort controller
-		sessionAbortControllers.delete(sessionId);
+		publishQueueState(sessionId);
 	}
 }

package/src/tools/adapter.ts

@@ -191,6 +191,7 @@ export function adaptTools(
 						delta,
 						stepIndex: meta?.stepIndex ?? ctx.stepIndex,
 						callId: meta?.callId,
+						messageId: ctx.messageId,
 					},
 				});
 				if (typeof base.onInputDelta === 'function')
@@ -235,6 +236,7 @@ export function adaptTools(
 							args,
 							callId,
 							stepIndex: ctx.stepIndex,
+							messageId: ctx.messageId,
 						},
 					});
 					// Persist synchronously to maintain correct ordering
@@ -266,7 +268,13 @@ export function adaptTools(
 				publish({
 					type: 'tool.call',
 					sessionId: ctx.sessionId,
-					payload: { name, args, callId, stepIndex: ctx.stepIndex },
+					payload: {
+						name,
+						args,
+						callId,
+						stepIndex: ctx.stepIndex,
+						messageId: ctx.messageId,
+					},
 				});
 				// Persist synchronously to maintain correct ordering
 				try {
@@ -373,6 +381,7 @@ export function adaptTools(
 										delta: chunk,
 										stepIndex: stepIndexForEvent,
 										callId: callIdFromQueue,
+										messageId: ctx.messageId,
 									},
 								});
 							}