@agi-cli/server 0.1.118 → 0.1.119

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.118",
+	"version": "0.1.119",
 	"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.119",
+		"@agi-cli/database": "0.1.119",
 		"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/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/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,
 									},
 								});
 							}