@agi-cli/server 0.1.74 → 0.1.76

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.74",
+	"version": "0.1.76",
 	"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.74",
-		"@agi-cli/database": "0.1.74",
+		"@agi-cli/sdk": "0.1.76",
+		"@agi-cli/database": "0.1.76",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/openapi/spec.ts

@@ -195,6 +195,11 @@ export function getOpenAPISpec() {
 										},
 										provider: { $ref: '#/components/schemas/Provider' },
 										model: { type: 'string' },
+										userContext: {
+											type: 'string',
+											description:
+												'Optional user-provided context to include in the system prompt.',
+										},
 									},
 								},
 							},

package/src/routes/session-messages.ts

@@ -85,6 +85,17 @@ export function registerSessionMessagesRoutes(app: Hono) {
 			const db = await getDb(cfg.projectRoot);
 			const sessionId = c.req.param('id');
 			const body = await c.req.json().catch(() => ({}));
+
+			// DEBUG: Log received body
+			logger.info('[API] Received message request', {
+				sessionId,
+				hasContent: !!body?.content,
+				hasUserContext: !!body?.userContext,
+				userContext: body?.userContext
+					? `${String(body.userContext).substring(0, 50)}...`
+					: 'NONE',
+			});
+
 			// Load session to inherit its provider/model/agent by default
 			const sessionRows = await db
 				.select()
@@ -101,6 +112,14 @@ export function registerSessionMessagesRoutes(app: Hono) {
 			const content = body?.content ?? '';
 			const userContext = body?.userContext;
 
+			// DEBUG: Log extracted userContext
+			logger.info('[API] Extracted userContext', {
+				userContext: userContext
+					? `${String(userContext).substring(0, 50)}...`
+					: 'NONE',
+				typeOf: typeof userContext,
+			});
+
 			// Validate model capabilities if tools are allowed for this agent
 			const wantsToolCalls = true; // agent toolset may be non-empty
 			try {

package/src/runtime/message-service.ts

@@ -37,6 +37,12 @@ export async function dispatchAssistantMessage(
 		oneShot,
 		userContext,
 	} = options;
+
+	// DEBUG: Log userContext in dispatch
+	debugLog(
+		`[MESSAGE_SERVICE] dispatchAssistantMessage called with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
+	);
+
 	const sessionId = session.id;
 	const now = Date.now();
 	const userMessageId = crypto.randomUUID();
@@ -100,6 +106,11 @@ export async function dispatchAssistantMessage(
 		payload: { id: assistantMessageId, role: 'assistant' },
 	});
 
+	// DEBUG: Log before enqueue
+	debugLog(
+		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
+	);
+
 	enqueueAssistantRun({
 		sessionId,
 		assistantMessageId,
@@ -128,21 +139,44 @@ function scheduleSessionTitle(args: {
 	db: DB;
 	sessionId: string;
 	content: unknown;
-}): void {
-	const { sessionId } = args;
-	if (titleInFlight.has(sessionId)) return;
-	titleInFlight.add(sessionId);
-	void (async () => {
+}) {
+	const { cfg, db, sessionId, content } = args;
+
+	if (titleInFlight.has(sessionId) || titlePending.has(sessionId)) {
+		return;
+	}
+
+	const processNext = () => {
+		if (titleQueue.length === 0) {
+			return;
+		}
+		if (titleActiveCount >= TITLE_CONCURRENCY_LIMIT) {
+			return;
+		}
+		const next = titleQueue.shift();
+		if (!next) return;
+		titleActiveCount++;
+		next();
+	};
+
+	const task = async () => {
+		titleInFlight.add(sessionId);
+		titlePending.delete(sessionId);
 		try {
-			const alreadyTitled = await sessionHasTitle(args.db, sessionId);
-			if (alreadyTitled) return;
-			await withTitleSlot(() => updateSessionTitle(args));
-		} catch {
-			// Swallow title generation errors; they are non-blocking.
+			await generateSessionTitle({ cfg, db, sessionId, content });
+		} catch (err) {
+			debugLog('[TITLE_GEN] Title generation error:');
+			debugLog(err);
 		} finally {
 			titleInFlight.delete(sessionId);
+			titleActiveCount--;
+			processNext();
 		}
-	})();
+	};
+
+	titlePending.add(sessionId);
+	titleQueue.push(task);
+	processNext();
 }
 
 function enqueueSessionTitle(args: {
@@ -151,72 +185,54 @@ function enqueueSessionTitle(args: {
 	sessionId: string;
 	content: unknown;
 }) {
-	const { sessionId } = args;
-	if (titlePending.has(sessionId) || titleInFlight.has(sessionId)) return;
-	titlePending.add(sessionId);
-	Promise.resolve()
-		.then(() => {
-			titlePending.delete(sessionId);
-			scheduleSessionTitle(args);
-		})
-		.catch(() => {
-			titlePending.delete(sessionId);
-		});
+	scheduleSessionTitle(args);
 }
 
-async function updateSessionTitle(args: {
+async function generateSessionTitle(args: {
 	cfg: AGIConfig;
 	db: DB;
 	sessionId: string;
 	content: unknown;
-}) {
+}): Promise<void> {
 	const { cfg, db, sessionId, content } = args;
+
 	try {
-		const rows = await db
+		const existingSession = await db
 			.select()
 			.from(sessions)
 			.where(eq(sessions.id, sessionId));
-		if (!rows.length) return;
-		const current = rows[0];
-		const alreadyHasTitle =
-			current.title != null && String(current.title).trim().length > 0;
-		let heuristic = '';
-		if (!alreadyHasTitle) {
-			heuristic = deriveTitle(String(content ?? ''));
-			if (heuristic) {
-				await db
-					.update(sessions)
-					.set({ title: heuristic })
-					.where(eq(sessions.id, sessionId));
-				publish({
-					type: 'session.updated',
-					sessionId,
-					payload: { title: heuristic },
-				});
-			}
+
+		if (!existingSession.length) {
+			debugLog('[TITLE_GEN] Session not found, aborting');
+			return;
 		}
 
-		const providerId =
-			(current.provider as ProviderId) ?? cfg.defaults.provider;
-		const modelId = current.model ?? cfg.defaults.model;
+		const sess = existingSession[0];
+		if (sess.title && sess.title !== 'New Session') {
+			debugLog('[TITLE_GEN] Session already has a title, skipping');
+			return;
+		}
+
+		const provider = sess.provider ?? cfg.defaults.provider;
+		const modelName = sess.model ?? cfg.defaults.model;
+
+		debugLog('[TITLE_GEN] Generating title for session');
+		debugLog(`[TITLE_GEN] Provider: ${provider}, Model: ${modelName}`);
 
-		debugLog('[TITLE_GEN] Starting title generation');
-		debugLog(`[TITLE_GEN] Provider: ${providerId}, Model: ${modelId}`);
+		const model = await resolveModel(provider, modelName, cfg);
 
-		// Check if we need OAuth spoof prompt (same logic as runner)
 		const { getAuth } = await import('@agi-cli/sdk');
 		const { getProviderSpoofPrompt } = await import('./prompt.ts');
-		const auth = await getAuth(providerId, cfg.projectRoot);
+		const auth = await getAuth(provider, cfg.projectRoot);
 		const needsSpoof = auth?.type === 'oauth';
 		const spoofPrompt = needsSpoof
-			? getProviderSpoofPrompt(providerId)
+			? getProviderSpoofPrompt(provider)
 			: undefined;
 
-		debugLog(`[TITLE_GEN] Auth type: ${auth?.type ?? 'none'}`);
-		debugLog(`[TITLE_GEN] Needs spoof: ${needsSpoof}`);
-		debugLog(`[TITLE_GEN] Spoof prompt length: ${spoofPrompt?.length ?? 0}`);
+		debugLog(
+			`[TITLE_GEN] needsSpoof: ${needsSpoof}, spoofPrompt: ${spoofPrompt || 'NONE'}`,
+		);
 
-		const model = await resolveModel(providerId, modelId, cfg);
 		const promptText = String(content ?? '').slice(0, 2000);
 
 		const titlePrompt = [
@@ -281,123 +297,49 @@ async function updateSessionTitle(args: {
 		const sanitized = sanitizeTitle(modelTitle);
 		debugLog(`[TITLE_GEN] After sanitization: "${sanitized}"`);
 
-		if (!sanitized) {
-			debugLog('[TITLE_GEN] Title sanitized to empty, aborting');
+		if (!sanitized || sanitized === 'New Session') {
+			debugLog('[TITLE_GEN] Sanitized title is empty or default, aborting');
 			return;
 		}
 
-		modelTitle = sanitized;
-
-		const check = await db
-			.select()
-			.from(sessions)
-			.where(eq(sessions.id, sessionId));
-		if (!check.length) return;
-		const currentTitle = String(check[0].title ?? '').trim();
-		if (currentTitle && currentTitle !== heuristic) {
-			debugLog(
-				`[TITLE_GEN] Session already has different title: "${currentTitle}", skipping`,
-			);
-			return;
-		}
-
-		debugLog(`[TITLE_GEN] Setting final title: "${modelTitle}"`);
 		await db
 			.update(sessions)
-			.set({ title: modelTitle })
+			.set({ title: sanitized, updatedAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
+
+		debugLog(`[TITLE_GEN] Setting final title: "${sanitized}"`);
+
 		publish({
 			type: 'session.updated',
 			sessionId,
-			payload: { title: modelTitle },
+			payload: { id: sessionId, title: sanitized },
 		});
 	} catch (err) {
-		debugLog('[TITLE_GEN] Fatal error:');
+		debugLog('[TITLE_GEN] Error in generateSessionTitle:');
 		debugLog(err);
 	}
 }
 
-async function withTitleSlot<T>(fn: () => Promise<T>): Promise<T> {
-	await acquireTitleSlot();
-	try {
-		return await fn();
-	} finally {
-		releaseTitleSlot();
-	}
-}
-
-async function sessionHasTitle(db: DB, sessionId: string): Promise<boolean> {
-	try {
-		const rows = await db
-			.select({ title: sessions.title })
-			.from(sessions)
-			.where(eq(sessions.id, sessionId))
-			.limit(1);
-		if (!rows.length) return false;
-		const title = rows[0]?.title;
-		return typeof title === 'string' && title.trim().length > 0;
-	} catch {
-		return false;
-	}
-}
-
-function acquireTitleSlot(): Promise<void> {
-	if (titleActiveCount < TITLE_CONCURRENCY_LIMIT) {
-		titleActiveCount += 1;
-		return Promise.resolve();
-	}
-	return new Promise((resolve) => {
-		titleQueue.push(() => {
-			titleActiveCount += 1;
-			resolve();
-		});
-	});
-}
-
-function releaseTitleSlot(): void {
-	if (titleActiveCount > 0) titleActiveCount -= 1;
-	const next = titleQueue.shift();
-	if (next) {
-		next();
-	}
+function sanitizeTitle(raw: string): string {
+	let s = raw.trim();
+	s = s.replace(/^["']|["']$/g, '');
+	s = s.replace(/[.!?]+$/, '');
+	s = s.replace(/\s+/g, ' ');
+	if (s.length > 80) s = s.slice(0, 80).trim();
+	return s;
 }
 
-async function touchSessionLastActive(args: { db: DB; sessionId: string }) {
+async function touchSessionLastActive(args: {
+	db: DB;
+	sessionId: string;
+}): Promise<void> {
 	const { db, sessionId } = args;
 	try {
 		await db
 			.update(sessions)
-			.set({ lastActiveAt: Date.now() })
+			.set({ updatedAt: Date.now() })
 			.where(eq(sessions.id, sessionId));
-	} catch {}
-}
-
-function deriveTitle(text: string): string {
-	const cleaned = String(text || '')
-		.replace(/```[\s\S]*?```/g, ' ')
-		.replace(/`[^`]*`/g, ' ')
-		.replace(/\s+/g, ' ')
-		.trim();
-	if (!cleaned) return '';
-	const endIdx = (() => {
-		const punct = ['? ', '. ', '! ']
-			.map((p) => cleaned.indexOf(p))
-			.filter((i) => i > 0);
-		const idx = Math.min(...(punct.length ? punct : [cleaned.length]));
-		return Math.min(idx + 1, cleaned.length);
-	})();
-	const first = cleaned.slice(0, endIdx).trim();
-	const maxLen = 64;
-	const base = first.length > 8 ? first : cleaned;
-	const truncated =
-		base.length > maxLen ? `${base.slice(0, maxLen - 1).trimEnd()}…` : base;
-	return truncated;
-}
-
-function sanitizeTitle(s: string): string {
-	let t = s.trim();
-	t = t.replace(/^['"""''()[\\]]+|['"""''()[\\]]+$/g, '').trim();
-	t = t.replace(/[\\s\\-_:–—]+$/g, '').trim();
-	if (t.length > 64) t = `${t.slice(0, 63).trimEnd()}…`;
-	return t;
+	} catch (err) {
+		debugLog('[touchSessionLastActive] Error:', err);
+	}
 }

package/src/runtime/runner.ts

@@ -122,7 +122,18 @@ async function runAssistant(opts: RunOpts) {
 	const history = await buildHistoryMessages(db, opts.sessionId);
 	historyTimer.end({ messages: history.length });
 
-	const isFirstMessage = history.length === 0;
+	// FIX: For OAuth, we need to check if this is the first ASSISTANT message
+	// The user message is already in history by this point, so history.length will be > 0
+	// We need to add additionalSystemMessages on the first assistant turn
+	const isFirstMessage = !history.some((m) => m.role === 'assistant');
+
+	debugLog(`[RUNNER] isFirstMessage: ${isFirstMessage}`);
+	debugLog(`[RUNNER] userContext provided: ${opts.userContext ? 'YES' : 'NO'}`);
+	if (opts.userContext) {
+		debugLog(
+			`[RUNNER] userContext value: ${opts.userContext.substring(0, 100)}${opts.userContext.length > 100 ? '...' : ''}`,
+		);
+	}
 
 	const systemTimer = time('runner:composeSystemPrompt');
 	const { getAuth } = await import('@agi-cli/sdk');
@@ -133,10 +144,14 @@ async function runAssistant(opts: RunOpts) {
 		? getProviderSpoofPrompt(opts.provider)
 		: undefined;
 
+	debugLog(`[RUNNER] needsSpoof (OAuth): ${needsSpoof}`);
+	debugLog(`[RUNNER] spoofPrompt: ${spoofPrompt || 'NONE'}`);
+
 	let system: string;
 	let additionalSystemMessages: Array<{ role: 'system'; content: string }> = [];
 
 	if (spoofPrompt) {
+		// OAuth mode: short spoof in system field, full instructions in messages array
 		system = spoofPrompt;
 		const fullPrompt = await composeSystemPrompt({
 			provider: opts.provider,
@@ -148,8 +163,25 @@ async function runAssistant(opts: RunOpts) {
 			includeProjectTree: isFirstMessage,
 			userContext: opts.userContext,
 		});
+
+		// FIX: Always add the system message for OAuth because:
+		// 1. System messages are NOT stored in the database
+		// 2. buildHistoryMessages only returns user/assistant messages
+		// 3. We need the full instructions on every turn
 		additionalSystemMessages = [{ role: 'system', content: fullPrompt }];
+
+		debugLog('[RUNNER] OAuth mode: additionalSystemMessages created');
+		debugLog(`[RUNNER] fullPrompt length: ${fullPrompt.length}`);
+		debugLog(
+			`[RUNNER] fullPrompt contains userContext: ${fullPrompt.includes('<user-provided-state-context>') ? 'YES' : 'NO'}`,
+		);
+		if (opts.userContext && fullPrompt.includes(opts.userContext)) {
+			debugLog('[RUNNER] ✅ userContext IS in fullPrompt');
+		} else if (opts.userContext) {
+			debugLog('[RUNNER] ❌ userContext NOT in fullPrompt!');
+		}
 	} else {
+		// API key mode: full instructions in system field
 		system = await composeSystemPrompt({
 			provider: opts.provider,
 			model: opts.model,
@@ -174,11 +206,29 @@ async function runAssistant(opts: RunOpts) {
 		'progress_update',
 	]);
 	const gated = allTools.filter((t) => allowedNames.has(t.name));
+
+	// FIX: For OAuth, ALWAYS prepend the system message because it's never in history
+	// For API key mode, only add on first message (when additionalSystemMessages is empty)
 	const messagesWithSystemInstructions = [
-		...(isFirstMessage ? additionalSystemMessages : []),
+		...additionalSystemMessages, // Always add for OAuth, empty for API key mode
 		...history,
 	];
 
+	debugLog(
+		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
+	);
+	debugLog(
+		`[RUNNER] additionalSystemMessages length: ${additionalSystemMessages.length}`,
+	);
+	if (additionalSystemMessages.length > 0) {
+		debugLog(
+			'[RUNNER] ✅ additionalSystemMessages ADDED to messagesWithSystemInstructions',
+		);
+		debugLog(
+			`[RUNNER] This happens on EVERY turn for OAuth (system messages not stored in DB)`,
+		);
+	}
+
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
 		db,
@@ -259,9 +309,24 @@ async function runAssistant(opts: RunOpts) {
 		maxToolResults: 30,
 	});
 
+	debugLog(
+		`[RUNNER] After optimizeContext: ${contextOptimized.length} messages`,
+	);
+
 	// 2. Truncate history
 	const truncatedMessages = truncateHistory(contextOptimized, 20);
 
+	debugLog(
+		`[RUNNER] After truncateHistory: ${truncatedMessages.length} messages`,
+	);
+	if (truncatedMessages.length > 0 && truncatedMessages[0].role === 'system') {
+		debugLog('[RUNNER] ✅ First message is system message');
+	} else if (truncatedMessages.length > 0) {
+		debugLog(
+			`[RUNNER] ⚠️ First message is NOT system (it's ${truncatedMessages[0].role})`,
+		);
+	}
+
 	// 3. Add cache control
 	const { system: cachedSystem, messages: optimizedMessages } = addCacheControl(
 		opts.provider,
@@ -269,6 +334,13 @@ async function runAssistant(opts: RunOpts) {
 		truncatedMessages,
 	);
 
+	debugLog(
+		`[RUNNER] Final optimizedMessages: ${optimizedMessages.length} messages`,
+	);
+	debugLog(
+		`[RUNNER] cachedSystem (spoof): ${typeof cachedSystem === 'string' ? cachedSystem.substring(0, 100) : JSON.stringify(cachedSystem).substring(0, 100)}`,
+	);
+
 	try {
 		// @ts-expect-error this is fine 🔥
 		const result = streamText({
@@ -312,29 +384,23 @@ async function runAssistant(opts: RunOpts) {
 		await db
 			.update(messageParts)
 			.set({
-				content: JSON.stringify({
-					text: accumulated,
-					error: errorPayload.message,
-				}),
+				content: JSON.stringify({ error: errorPayload }),
 			})
-			.where(eq(messageParts.messageId, opts.assistantMessageId));
+			.where(eq(messageParts.id, currentPartId));
+
 		publish({
-			type: 'error',
+			type: 'message.error',
 			sessionId: opts.sessionId,
 			payload: {
 				messageId: opts.assistantMessageId,
-				error: errorPayload.message,
-				details: errorPayload.details,
+				partId: currentPartId,
+				error: errorPayload,
 			},
 		});
 		throw error;
 	} finally {
-		if (!firstToolSeen()) firstToolTimer.end({ skipped: true });
-		try {
-			unsubscribeFinish();
-		} catch {}
-		try {
-			await cleanupEmptyTextParts(opts, db);
-		} catch {}
+		unsubscribeFinish();
+		await cleanupEmptyTextParts(db, opts.assistantMessageId);
+		firstToolTimer.end({ seen: firstToolSeen });
 	}
 }