@agi-cli/server 0.1.86 → 0.1.87

package/package.json

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

package/src/events/types.ts

@@ -3,6 +3,7 @@ export type AGIEventType =
 	| 'session.updated'
 	| 'message.created'
 	| 'message.part.delta'
+	| 'reasoning.delta'
 	| 'message.completed'
 	| 'tool.call'
 	| 'tool.delta'

package/src/runtime/db-operations.ts

@@ -28,7 +28,7 @@ export async function updateSessionTokensIncremental(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
 ) {
-	if (!usage) return;
+	if (!usage || !db) return;
 
 	// Read session totals
 	const sessRows = await db
@@ -106,7 +106,7 @@ export async function updateSessionTokens(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
 ) {
-	if (!fin.usage) return;
+	if (!fin.usage || !db) return;
 
 	const sessRows = await db
 		.select()
@@ -140,7 +140,7 @@ export async function updateMessageTokensIncremental(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
 ) {
-	if (!usage) return;
+	if (!usage || !db) return;
 
 	const msgRows = await db
 		.select()
@@ -204,6 +204,8 @@ export async function completeAssistantMessage(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
 ) {
+	if (!db) return;
+
 	// Only mark as complete - tokens are already tracked incrementally
 	await db
 		.update(messages)
@@ -221,6 +223,8 @@ export async function cleanupEmptyTextParts(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
 ) {
+	if (!db) return;
+
 	const parts = await db
 		.select()
 		.from(messageParts)

package/src/runtime/history-builder.ts

@@ -21,6 +21,13 @@ export async function buildHistoryMessages(
 	const ui: UIMessage[] = [];
 
 	for (const m of rows) {
+		if (m.role === 'assistant' && m.status !== 'complete') {
+			debugLog(
+				`[buildHistoryMessages] Skipping assistant message ${m.id} with status ${m.status}`,
+			);
+			continue;
+		}
+
 		const parts = await db
 			.select()
 			.from(messageParts)
@@ -54,6 +61,8 @@ export async function buildHistoryMessages(
 			}> = [];
 
 			for (const p of parts) {
+				if (p.type === 'reasoning') continue;
+
 				if (p.type === 'text') {
 					try {
 						const obj = JSON.parse(p.content ?? '{}');

package/src/runtime/message-service.ts

@@ -4,7 +4,8 @@ import type { AGIConfig } from '@agi-cli/sdk';
 import type { DB } from '@agi-cli/database';
 import { messages, messageParts, sessions } from '@agi-cli/database/schema';
 import { publish } from '../events/bus.ts';
-import { enqueueAssistantRun } from './runner.ts';
+import { enqueueAssistantRun } from './session-queue.ts';
+import { runSessionLoop } from './runner.ts';
 import { resolveModel } from './provider.ts';
 import type { ProviderId } from '@agi-cli/sdk';
 import { debugLog } from './debug.ts';
@@ -86,20 +87,6 @@ export async function dispatchAssistantMessage(
 		model,
 		createdAt: Date.now(),
 	});
-	const assistantPartId = crypto.randomUUID();
-	const startTs = Date.now();
-	await db.insert(messageParts).values({
-		id: assistantPartId,
-		messageId: assistantMessageId,
-		index: 0,
-		stepIndex: 0,
-		type: 'text',
-		content: JSON.stringify({ text: '' }),
-		agent,
-		provider,
-		model,
-		startedAt: startTs,
-	});
 	publish({
 		type: 'message.created',
 		sessionId,
@@ -111,17 +98,19 @@ export async function dispatchAssistantMessage(
 		`[MESSAGE_SERVICE] Enqueuing assistant run with userContext: ${userContext ? `${userContext.substring(0, 50)}...` : 'NONE'}`,
 	);
 
-	enqueueAssistantRun({
-		sessionId,
-		assistantMessageId,
-		assistantPartId,
-		agent,
-		provider,
-		model,
-		projectRoot: cfg.projectRoot,
-		oneShot: Boolean(oneShot),
-		userContext,
-	});
+	enqueueAssistantRun(
+		{
+			sessionId,
+			assistantMessageId,
+			agent,
+			provider,
+			model,
+			projectRoot: cfg.projectRoot,
+			oneShot: Boolean(oneShot),
+			userContext,
+		},
+		runSessionLoop,
+	);
 
 	void touchSessionLastActive({ db, sessionId });
 

package/src/runtime/runner.ts

@@ -15,9 +15,6 @@ import { toErrorPayload } from './error-handling.ts';
 import { getMaxOutputTokens } from './token-utils.ts';
 import {
 	type RunOpts,
-	enqueueAssistantRun as enqueueRun,
-	abortSession as abortSessionQueue,
-	getRunnerState,
 	setRunning,
 	dequeueJob,
 	cleanupSession,
@@ -36,32 +33,19 @@ import {
 	createFinishHandler,
 } from './stream-handlers.ts';
 
-/**
- * Enqueues an assistant run for processing.
- */
-export function enqueueAssistantRun(opts: Omit<RunOpts, 'abortSignal'>) {
-	enqueueRun(opts, processQueue);
-}
-
-/**
- * Aborts an active session.
- */
-export function abortSession(sessionId: string) {
-	abortSessionQueue(sessionId);
-}
+export { enqueueAssistantRun, abortSession } from './session-queue.ts';
+export { getRunnerState } from './session-queue.ts';
 
 /**
- * Processes the queue of assistant runs for a session.
+ * Main loop that processes the queue for a given session.
  */
-async function processQueue(sessionId: string) {
-	const state = getRunnerState(sessionId);
-	if (!state) return;
-	if (state.running) return;
+export async function runSessionLoop(sessionId: string) {
 	setRunning(sessionId, true);
 
-	while (state.queue.length > 0) {
-		const job = dequeueJob(sessionId);
+	while (true) {
+		const job = await dequeueJob(sessionId);
 		if (!job) break;
+
 		try {
 			await runAssistant(job);
 		} catch (_err) {
@@ -170,12 +154,9 @@ async function runAssistant(opts: RunOpts) {
 	const toolsTimer = time('runner:discoverTools');
 	const allTools = await discoverProjectTools(cfg.projectRoot);
 	toolsTimer.end({ count: allTools.length });
-	const allowedNames = new Set([
-		...(agentCfg.tools || []),
-		'finish',
-		'progress_update',
-	]);
-	const gated = allTools.filter((t) => allowedNames.has(t.name));
+	const allowedNames = new Set([...(agentCfg.tools || []), 'finish']);
+	const gated = allTools.filter((tool) => allowedNames.has(tool.name));
+	debugLog(`[tools] ${gated.length} allowed tools`);
 
 	// 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)
@@ -184,6 +165,8 @@ async function runAssistant(opts: RunOpts) {
 		...history,
 	];
 
+	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
+	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);
 	debugLog(
 		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
 	);
@@ -199,22 +182,21 @@ async function runAssistant(opts: RunOpts) {
 		);
 	}
 
+	const model = await resolveModel(opts.provider, opts.model, cfg);
+	debugLog(
+		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,
+	);
+
+	const maxOutputTokens = getMaxOutputTokens(opts.provider, opts.model);
+	debugLog(`[RUNNER] maxOutputTokens for ${opts.model}: ${maxOutputTokens}`);
+
+	// Setup tool context
 	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
 		opts,
 		db,
 	);
 	const toolset = adaptTools(gated, sharedCtx, opts.provider);
 
-	const modelTimer = time('runner:resolveModel');
-	const model = await resolveModel(opts.provider, opts.model, cfg);
-	modelTimer.end();
-
-	const maxOutputTokens = getMaxOutputTokens(opts.provider, opts.model);
-
-	let currentPartId = opts.assistantPartId;
-	let accumulated = '';
-	let stepIndex = 0;
-
 	let _finishObserved = false;
 	const unsubscribeFinish = subscribe(opts.sessionId, (evt) => {
 		if (evt.type !== 'tool.result') return;
@@ -231,7 +213,7 @@ async function runAssistant(opts: RunOpts) {
 	// State management helpers
 	const getCurrentPartId = () => currentPartId;
 	const getStepIndex = () => stepIndex;
-	const updateCurrentPartId = (id: string) => {
+	const updateCurrentPartId = (id: string | null) => {
 		currentPartId = id;
 	};
 	const updateAccumulated = (text: string) => {
@@ -242,16 +224,29 @@ async function runAssistant(opts: RunOpts) {
 		return stepIndex;
 	};
 
+	type ReasoningState = {
+		partId: string;
+		text: string;
+		providerMetadata?: unknown;
+	};
+	const reasoningStates = new Map<string, ReasoningState>();
+	const serializeReasoningContent = (state: ReasoningState) =>
+		JSON.stringify(
+			state.providerMetadata != null
+				? { text: state.text, providerMetadata: state.providerMetadata }
+				: { text: state.text },
+		);
+
 	// Create stream handlers
 	const onStepFinish = createStepFinishHandler(
 		opts,
 		db,
-		getCurrentPartId,
 		getStepIndex,
-		sharedCtx,
+		incrementStepIndex,
+		getCurrentPartId,
 		updateCurrentPartId,
 		updateAccumulated,
-		incrementStepIndex,
+		sharedCtx,
 		updateSessionTokensIncremental,
 		updateMessageTokensIncremental,
 	);
@@ -306,6 +301,11 @@ async function runAssistant(opts: RunOpts) {
 		`[RUNNER] cachedSystem (spoof): ${typeof cachedSystem === 'string' ? cachedSystem.substring(0, 100) : JSON.stringify(cachedSystem).substring(0, 100)}`,
 	);
 
+	// Part tracking - will be created on first text-delta
+	let currentPartId: string | null = null;
+	let accumulated = '';
+	let stepIndex = 0;
+
 	try {
 		// @ts-expect-error this is fine 🔥
 		const result = streamText({
@@ -322,50 +322,173 @@ async function runAssistant(opts: RunOpts) {
 			onFinish,
 		});
 
-		for await (const delta of result.textStream) {
-			if (!delta) continue;
-			if (!firstDeltaSeen) {
-				firstDeltaSeen = true;
-				streamStartTimer.end();
+		for await (const part of result.fullStream) {
+			if (!part) continue;
+			if (part.type === 'text-delta') {
+				const delta = part.text;
+				if (!delta) continue;
+				if (!firstDeltaSeen) {
+					firstDeltaSeen = true;
+					streamStartTimer.end();
+				}
+
+				// Create text part on first delta
+				if (!currentPartId) {
+					currentPartId = crypto.randomUUID();
+					sharedCtx.assistantPartId = currentPartId;
+					await db.insert(messageParts).values({
+						id: currentPartId,
+						messageId: opts.assistantMessageId,
+						index: sharedCtx.nextIndex(),
+						stepIndex: null,
+						type: 'text',
+						content: JSON.stringify({ text: '' }),
+						agent: opts.agent,
+						provider: opts.provider,
+						model: opts.model,
+						startedAt: Date.now(),
+					});
+				}
+
+				accumulated += delta;
+				publish({
+					type: 'message.part.delta',
+					sessionId: opts.sessionId,
+					payload: {
+						messageId: opts.assistantMessageId,
+						partId: currentPartId,
+						stepIndex,
+						delta,
+					},
+				});
+				await db
+					.update(messageParts)
+					.set({ content: JSON.stringify({ text: accumulated }) })
+					.where(eq(messageParts.id, currentPartId));
+				continue;
+			}
+
+			if (part.type === 'reasoning-start') {
+				const reasoningId = part.id;
+				if (!reasoningId) continue;
+				const reasoningPartId = crypto.randomUUID();
+				const state: ReasoningState = {
+					partId: reasoningPartId,
+					text: '',
+					providerMetadata: part.providerMetadata,
+				};
+				reasoningStates.set(reasoningId, state);
+				try {
+					await db.insert(messageParts).values({
+						id: reasoningPartId,
+						messageId: opts.assistantMessageId,
+						index: sharedCtx.nextIndex(),
+						stepIndex: getStepIndex(),
+						type: 'reasoning',
+						content: serializeReasoningContent(state),
+						agent: opts.agent,
+						provider: opts.provider,
+						model: opts.model,
+						startedAt: Date.now(),
+					});
+				} catch {}
+				continue;
+			}
+
+			if (part.type === 'reasoning-delta') {
+				const state = reasoningStates.get(part.id);
+				if (!state) continue;
+				state.text += part.text;
+				if (part.providerMetadata != null) {
+					state.providerMetadata = part.providerMetadata;
+				}
+				publish({
+					type: 'reasoning.delta',
+					sessionId: opts.sessionId,
+					payload: {
+						messageId: opts.assistantMessageId,
+						partId: state.partId,
+						stepIndex: getStepIndex(),
+						delta: part.text,
+					},
+				});
+				try {
+					await db
+						.update(messageParts)
+						.set({ content: serializeReasoningContent(state) })
+						.where(eq(messageParts.id, state.partId));
+				} catch {}
+				continue;
 			}
-			accumulated += delta;
+
+			if (part.type === 'reasoning-end') {
+				const state = reasoningStates.get(part.id);
+				if (!state) continue;
+				try {
+					await db
+						.update(messageParts)
+						.set({ completedAt: Date.now() })
+						.where(eq(messageParts.id, state.partId));
+				} catch {}
+				reasoningStates.delete(part.id);
+			}
+		}
+
+		// Emit finish-step at the end if there were no tool calls and no finish
+		const fs = firstToolSeen();
+		if (!fs && !_finishObserved) {
 			publish({
-				type: 'message.part.delta',
+				type: 'finish-step',
 				sessionId: opts.sessionId,
-				payload: {
-					messageId: opts.assistantMessageId,
-					partId: currentPartId,
-					stepIndex,
-					delta,
-				},
+				payload: { reason: 'no-tool-calls' },
 			});
-			await db
-				.update(messageParts)
-				.set({ content: JSON.stringify({ text: accumulated }) })
-				.where(eq(messageParts.id, currentPartId));
 		}
-	} catch (error) {
-		const errorPayload = toErrorPayload(error);
-		await db
-			.update(messageParts)
-			.set({
-				content: JSON.stringify({ error: errorPayload }),
-			})
-			.where(eq(messageParts.id, currentPartId));
 
+		unsubscribeFinish();
+
+		await cleanupEmptyTextParts(opts, db);
+
+		firstToolTimer.end({ seen: firstToolSeen() });
+
+		debugLog(
+			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}`,
+		);
+	} catch (err) {
+		unsubscribeFinish();
+		const payload = toErrorPayload(err);
+		debugLog(`[RUNNER] Error during stream: ${payload.message}`);
+		debugLog(
+			`[RUNNER] Error stack: ${err instanceof Error ? err.stack : 'no stack'}`,
+		);
+		debugLog(
+			`[RUNNER] db is: ${typeof db}, db.select is: ${typeof db?.select}`,
+		);
 		publish({
-			type: 'message.error',
+			type: 'error',
 			sessionId: opts.sessionId,
-			payload: {
-				messageId: opts.assistantMessageId,
-				partId: currentPartId,
-				error: errorPayload,
-			},
+			payload,
 		});
-		throw error;
-	} finally {
-		unsubscribeFinish();
-		await cleanupEmptyTextParts(db, opts.assistantMessageId);
-		firstToolTimer.end({ seen: firstToolSeen });
+		try {
+			await updateSessionTokensIncremental(
+				{
+					inputTokens: 0,
+					outputTokens: 0,
+				},
+				undefined,
+				opts,
+				db,
+			);
+			await updateMessageTokensIncremental(
+				{
+					inputTokens: 0,
+					outputTokens: 0,
+				},
+				undefined,
+				opts,
+				db,
+			);
+			await completeAssistantMessage({}, opts, db);
+		} catch {}
+		throw err;
 	}
 }

package/src/runtime/session-queue.ts

@@ -3,7 +3,6 @@ import type { ProviderName } from './provider.ts';
 export type RunOpts = {
 	sessionId: string;
 	assistantMessageId: string;
-	assistantPartId: string;
 	agent: string;
 	provider: ProviderName;
 	model: string;

package/src/runtime/stream-handlers.ts

@@ -31,12 +31,12 @@ type AbortEvent = {
 export function createStepFinishHandler(
 	opts: RunOpts,
 	db: Awaited<ReturnType<typeof getDb>>,
-	getCurrentPartId: () => string,
 	getStepIndex: () => number,
-	sharedCtx: ToolAdapterContext,
-	updateCurrentPartId: (id: string) => void,
-	updateAccumulated: (text: string) => void,
 	incrementStepIndex: () => number,
+	getCurrentPartId: () => string | null,
+	updateCurrentPartId: (id: string | null) => void,
+	updateAccumulated: (text: string) => void,
+	sharedCtx: ToolAdapterContext,
 	updateSessionTokensIncrementalFn: (
 		usage: UsageData,
 		providerMetadata: ProviderMetadata | undefined,
@@ -56,10 +56,12 @@ export function createStepFinishHandler(
 		const stepIndex = getStepIndex();
 
 		try {
-			await db
-				.update(messageParts)
-				.set({ completedAt: finishedAt })
-				.where(eq(messageParts.id, currentPartId));
+			if (currentPartId) {
+				await db
+					.update(messageParts)
+					.set({ completedAt: finishedAt })
+					.where(eq(messageParts.id, currentPartId));
+			}
 		} catch {}
 
 		// Update token counts incrementally after each step
@@ -104,25 +106,11 @@ export function createStepFinishHandler(
 		} catch {}
 
 		try {
+			// Increment step index but defer creating the new text part
+			// until we actually get a text-delta (so reasoning blocks can complete first)
 			const newStepIndex = incrementStepIndex();
-			const newPartId = crypto.randomUUID();
-			const index = await sharedCtx.nextIndex();
-			const nowTs = Date.now();
-			await db.insert(messageParts).values({
-				id: newPartId,
-				messageId: opts.assistantMessageId,
-				index,
-				stepIndex: newStepIndex,
-				type: 'text',
-				content: JSON.stringify({ text: '' }),
-				agent: opts.agent,
-				provider: opts.provider,
-				model: opts.model,
-				startedAt: nowTs,
-			});
-			updateCurrentPartId(newPartId);
-			sharedCtx.assistantPartId = newPartId;
 			sharedCtx.stepIndex = newStepIndex;
+			updateCurrentPartId(null); // Signal that next text-delta should create new part
 			updateAccumulated('');
 		} catch {}
 	};

package/src/runtime/tool-context-setup.ts

@@ -1,6 +1,4 @@
 import type { getDb } from '@agi-cli/database';
-import { messageParts } from '@agi-cli/database/schema';
-import { eq } from 'drizzle-orm';
 import { time } from './debug.ts';
 import type { ToolAdapterContext } from '../tools/adapter.ts';
 import type { RunOpts } from './session-queue.ts';
@@ -18,12 +16,16 @@ export async function setupToolContext(
 	const firstToolTimer = time('runner:first-tool-call');
 	let firstToolSeen = false;
 
+	// Simple counter starting at 0 - first event gets 0, second gets 1, etc.
+	let currentIndex = 0;
+	const nextIndex = () => currentIndex++;
+
 	const sharedCtx: RunnerToolContext = {
-		nextIndex: async () => 0,
+		nextIndex,
 		stepIndex: 0,
 		sessionId: opts.sessionId,
 		messageId: opts.assistantMessageId,
-		assistantPartId: opts.assistantPartId,
+		assistantPartId: '', // Will be set by runner when first text part is created
 		db,
 		agent: opts.agent,
 		provider: opts.provider,
@@ -36,23 +38,5 @@ export async function setupToolContext(
 		},
 	};
 
-	let counter = 0;
-	try {
-		const existing = await db
-			.select()
-			.from(messageParts)
-			.where(eq(messageParts.messageId, opts.assistantMessageId));
-		if (existing.length) {
-			const indexes = existing.map((p) => Number(p.index ?? 0));
-			const maxIndex = Math.max(...indexes);
-			if (Number.isFinite(maxIndex)) counter = maxIndex;
-		}
-	} catch {}
-
-	sharedCtx.nextIndex = () => {
-		counter += 1;
-		return counter;
-	};
-
 	return { sharedCtx, firstToolTimer, firstToolSeen: () => firstToolSeen };
 }