@agi-cli/server 0.1.55

package/src/runtime/provider.ts

@@ -0,0 +1,138 @@
+import type { AGIConfig } from '@agi-cli/sdk';
+import type { ProviderId } from '@agi-cli/sdk';
+import { openai, createOpenAI } from '@ai-sdk/openai';
+import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { getAuth } from '@agi-cli/sdk';
+import { refreshToken } from '@agi-cli/sdk';
+import { setAuth } from '@agi-cli/sdk';
+
+export type ProviderName = ProviderId;
+
+function getOpenRouterInstance() {
+	const apiKey = process.env.OPENROUTER_API_KEY ?? '';
+	return createOpenRouter({ apiKey });
+}
+
+async function getAnthropicInstance(cfg: AGIConfig) {
+	const auth = await getAuth('anthropic', cfg.projectRoot);
+
+	if (auth?.type === 'oauth') {
+		let currentAuth = auth;
+
+		if (currentAuth.expires < Date.now()) {
+			const tokens = await refreshToken(currentAuth.refresh);
+			await setAuth(
+				'anthropic',
+				{
+					type: 'oauth',
+					refresh: tokens.refresh,
+					access: tokens.access,
+					expires: tokens.expires,
+				},
+				cfg.projectRoot,
+				'global',
+			);
+			currentAuth = {
+				type: 'oauth',
+				refresh: tokens.refresh,
+				access: tokens.access,
+				expires: tokens.expires,
+			};
+		}
+
+		const customFetch = async (
+			input: string | URL | Request,
+			init?: RequestInit,
+		) => {
+			const initHeaders = init?.headers;
+			const headers: Record<string, string> = {};
+
+			if (initHeaders) {
+				if (initHeaders instanceof Headers) {
+					initHeaders.forEach((value, key) => {
+						if (key.toLowerCase() !== 'x-api-key') {
+							headers[key] = value;
+						}
+					});
+				} else if (Array.isArray(initHeaders)) {
+					for (const [key, value] of initHeaders) {
+						if (
+							key &&
+							key.toLowerCase() !== 'x-api-key' &&
+							typeof value === 'string'
+						) {
+							headers[key] = value;
+						}
+					}
+				} else {
+					for (const [key, value] of Object.entries(initHeaders)) {
+						if (
+							key.toLowerCase() !== 'x-api-key' &&
+							typeof value === 'string'
+						) {
+							headers[key] = value;
+						}
+					}
+				}
+			}
+
+			headers.authorization = `Bearer ${currentAuth.access}`;
+			headers['anthropic-beta'] =
+				'oauth-2025-04-20,claude-code-20250219,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14';
+
+			return fetch(input, {
+				...init,
+				headers,
+			});
+		};
+		return createAnthropic({
+			apiKey: '',
+			fetch: customFetch as typeof fetch,
+		});
+	}
+
+	return anthropic;
+}
+
+export async function resolveModel(
+	provider: ProviderName,
+	model: string,
+	cfg: AGIConfig,
+) {
+	if (provider === 'openai') return openai(model);
+	if (provider === 'anthropic') {
+		const instance = await getAnthropicInstance(cfg);
+		return instance(model);
+	}
+	if (provider === 'google') return google(model);
+	if (provider === 'openrouter') {
+		const openrouter = getOpenRouterInstance();
+		return openrouter.chat(model);
+	}
+	if (provider === 'opencode') {
+		const baseURL = 'https://opencode.ai/zen/v1';
+		const apiKey = process.env.OPENCODE_API_KEY ?? '';
+
+		const ocOpenAI = createOpenAI({ apiKey, baseURL });
+		const ocAnthropic = createAnthropic({ apiKey, baseURL });
+		const ocCompat = createOpenAICompatible({
+			name: 'opencode',
+			baseURL,
+			headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
+		});
+
+		const id = model.toLowerCase();
+		if (id.includes('claude')) return ocAnthropic(model);
+		if (
+			id.includes('qwen3-coder') ||
+			id.includes('grok-code') ||
+			id.includes('kimi-k2')
+		)
+			return ocCompat(model);
+		return ocOpenAI(model);
+	}
+	throw new Error(`Unsupported provider: ${provider}`);
+}

package/src/runtime/runner.ts

@@ -0,0 +1,313 @@
+import { hasToolCall, streamText } from 'ai';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { messageParts } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import { resolveModel } from './provider.ts';
+import { resolveAgentConfig } from './agent-registry.ts';
+import { composeSystemPrompt } from './prompt.ts';
+import { discoverProjectTools } from '@agi-cli/sdk';
+import { adaptTools } from '../tools/adapter.ts';
+import { publish, subscribe } from '../events/bus.ts';
+import { debugLog, time } from './debug.ts';
+import { buildHistoryMessages } from './history-builder.ts';
+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,
+} from './session-queue.ts';
+import {
+	setupToolContext,
+	type RunnerToolContext,
+} from './tool-context-setup.ts';
+import {
+	updateSessionTokens,
+	completeAssistantMessage,
+	cleanupEmptyTextParts,
+} from './db-operations.ts';
+import {
+	createStepFinishHandler,
+	createErrorHandler,
+	createAbortHandler,
+	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);
+}
+
+/**
+ * Processes the queue of assistant runs for a session.
+ */
+async function processQueue(sessionId: string) {
+	const state = getRunnerState(sessionId);
+	if (!state) return;
+	if (state.running) return;
+	setRunning(sessionId, true);
+
+	while (state.queue.length > 0) {
+		const job = dequeueJob(sessionId);
+		if (!job) break;
+		try {
+			await runAssistant(job);
+		} catch (_err) {
+			// Swallow to keep the loop alive; event published by runner
+		}
+	}
+
+	setRunning(sessionId, false);
+	cleanupSession(sessionId);
+}
+
+/**
+ * Ensures the finish tool is called if not already observed.
+ */
+async function ensureFinishToolCalled(
+	finishObserved: boolean,
+	toolset: ReturnType<typeof adaptTools>,
+	sharedCtx: RunnerToolContext,
+	stepIndex: number,
+) {
+	if (finishObserved || !toolset?.finish?.execute) return;
+
+	const finishInput = {} as const;
+	const callOptions = { input: finishInput } as const;
+
+	sharedCtx.stepIndex = stepIndex;
+
+	try {
+		await toolset.finish.onInputStart?.(callOptions as never);
+	} catch {}
+
+	try {
+		await toolset.finish.onInputAvailable?.(callOptions as never);
+	} catch {}
+
+	await toolset.finish.execute(finishInput, {} as never);
+}
+
+/**
+ * Main function to run the assistant for a given request.
+ */
+async function runAssistant(opts: RunOpts) {
+	const cfgTimer = time('runner:loadConfig+db');
+	const cfg = await loadConfig(opts.projectRoot);
+	const db = await getDb(cfg.projectRoot);
+	cfgTimer.end();
+
+	const agentTimer = time('runner:resolveAgentConfig');
+	const agentCfg = await resolveAgentConfig(cfg.projectRoot, opts.agent);
+	agentTimer.end({ agent: opts.agent });
+
+	const agentPrompt = agentCfg.prompt || '';
+
+	const historyTimer = time('runner:buildHistory');
+	const history = await buildHistoryMessages(db, opts.sessionId);
+	historyTimer.end({ messages: history.length });
+
+	const isFirstMessage = history.length === 0;
+
+	const systemTimer = time('runner:composeSystemPrompt');
+	const { getAuth } = await import('@agi-cli/sdk');
+	const { getProviderSpoofPrompt } = await import('./prompt.ts');
+	const auth = await getAuth(opts.provider, cfg.projectRoot);
+	const needsSpoof = auth?.type === 'oauth';
+	const spoofPrompt = needsSpoof
+		? getProviderSpoofPrompt(opts.provider)
+		: undefined;
+
+	let system: string;
+	let additionalSystemMessages: Array<{ role: 'system'; content: string }> = [];
+
+	if (spoofPrompt) {
+		system = spoofPrompt;
+		const fullPrompt = await composeSystemPrompt({
+			provider: opts.provider,
+			model: opts.model,
+			projectRoot: cfg.projectRoot,
+			agentPrompt,
+			oneShot: opts.oneShot,
+			spoofPrompt: undefined,
+			includeProjectTree: isFirstMessage,
+		});
+		additionalSystemMessages = [{ role: 'system', content: fullPrompt }];
+	} else {
+		system = await composeSystemPrompt({
+			provider: opts.provider,
+			model: opts.model,
+			projectRoot: cfg.projectRoot,
+			agentPrompt,
+			oneShot: opts.oneShot,
+			spoofPrompt: undefined,
+			includeProjectTree: isFirstMessage,
+		});
+	}
+	systemTimer.end();
+	debugLog('[system] composed prompt (provider+base+agent):');
+	debugLog(system);
+
+	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 messagesWithSystemInstructions = [
+		...(isFirstMessage ? additionalSystemMessages : []),
+		...history,
+	];
+
+	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
+		opts,
+		db,
+	);
+	const toolset = adaptTools(gated, sharedCtx);
+
+	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;
+		try {
+			const name = (evt.payload as { name?: string } | undefined)?.name;
+			if (name === 'finish') finishObserved = true;
+		} catch {}
+	});
+
+	const streamStartTimer = time('runner:first-delta');
+	let firstDeltaSeen = false;
+	debugLog(`[streamText] Calling with maxOutputTokens: ${maxOutputTokens}`);
+
+	// State management helpers
+	const getCurrentPartId = () => currentPartId;
+	const getStepIndex = () => stepIndex;
+	const updateCurrentPartId = (id: string) => {
+		currentPartId = id;
+	};
+	const updateAccumulated = (text: string) => {
+		accumulated = text;
+	};
+	const incrementStepIndex = () => {
+		stepIndex += 1;
+		return stepIndex;
+	};
+
+	// Create stream handlers
+	const onStepFinish = createStepFinishHandler(
+		opts,
+		db,
+		getCurrentPartId,
+		getStepIndex,
+		sharedCtx,
+		updateCurrentPartId,
+		updateAccumulated,
+		incrementStepIndex,
+	);
+
+	const onError = createErrorHandler(opts, db, getStepIndex, sharedCtx);
+
+	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
+
+	const onFinish = createFinishHandler(
+		opts,
+		db,
+		() => ensureFinishToolCalled(finishObserved, toolset, sharedCtx, stepIndex),
+		updateSessionTokens,
+		completeAssistantMessage,
+	);
+
+	try {
+		const result = streamText({
+			model,
+			tools: toolset,
+			...(String(system || '').trim() ? { system } : {}),
+			messages: messagesWithSystemInstructions,
+			...(maxOutputTokens ? { maxOutputTokens } : {}),
+			abortSignal: opts.abortSignal,
+			stopWhen: hasToolCall('finish'),
+			onStepFinish,
+			onError,
+			onAbort,
+			onFinish,
+		});
+
+		for await (const delta of result.textStream) {
+			if (!delta) continue;
+			if (!firstDeltaSeen) {
+				firstDeltaSeen = true;
+				streamStartTimer.end();
+			}
+			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));
+		}
+	} catch (error) {
+		const errorPayload = toErrorPayload(error);
+		await db
+			.update(messageParts)
+			.set({
+				content: JSON.stringify({
+					text: accumulated,
+					error: errorPayload.message,
+				}),
+			})
+			.where(eq(messageParts.messageId, opts.assistantMessageId));
+		publish({
+			type: 'error',
+			sessionId: opts.sessionId,
+			payload: {
+				messageId: opts.assistantMessageId,
+				error: errorPayload.message,
+				details: errorPayload.details,
+			},
+		});
+		throw error;
+	} finally {
+		if (!firstToolSeen()) firstToolTimer.end({ skipped: true });
+		try {
+			unsubscribeFinish();
+		} catch {}
+		try {
+			await cleanupEmptyTextParts(opts, db);
+		} catch {}
+	}
+}

package/src/runtime/session-manager.ts

@@ -0,0 +1,95 @@
+import { desc, eq } from 'drizzle-orm';
+import type { AGIConfig } from '@agi-cli/sdk';
+import type { DB } from '@agi-cli/database';
+import { sessions } from '@agi-cli/database/schema';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+	type ProviderId,
+} from '@agi-cli/sdk';
+import { publish } from '../events/bus.ts';
+
+type SessionRow = typeof sessions.$inferSelect;
+
+type CreateSessionInput = {
+	db: DB;
+	cfg: AGIConfig;
+	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 \`agi 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: null,
+		totalInputTokens: null,
+		totalOutputTokens: null,
+		totalToolTimeMs: null,
+		toolCountsJson: 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,82 @@
+import type { ProviderName } from './provider.ts';
+
+export type RunOpts = {
+	sessionId: string;
+	assistantMessageId: string;
+	assistantPartId: string;
+	agent: string;
+	provider: ProviderName;
+	model: string;
+	projectRoot: string;
+	oneShot?: boolean;
+	abortSignal?: AbortSignal;
+};
+
+type RunnerState = { queue: RunOpts[]; running: boolean };
+
+// Global state for session queues
+const runners = new Map<string, RunnerState>();
+
+// Track active abort controllers per session
+const sessionAbortControllers = new Map<string, AbortController>();
+
+/**
+ * Enqueues an assistant run for a given session.
+ * Creates an abort controller for the session if one doesn't exist.
+ */
+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);
+
+	const state = runners.get(opts.sessionId) ?? { queue: [], running: false };
+	state.queue.push({ ...opts, abortSignal: abortController.signal });
+	runners.set(opts.sessionId, state);
+	if (!state.running) void processQueueFn(opts.sessionId);
+}
+
+/**
+ * Aborts all pending operations for a given session.
+ */
+export function abortSession(sessionId: string) {
+	const controller = sessionAbortControllers.get(sessionId);
+	if (controller) {
+		controller.abort();
+		sessionAbortControllers.delete(sessionId);
+	}
+}
+
+/**
+ * Gets the current state of a session's queue.
+ */
+export function getRunnerState(sessionId: string): RunnerState | undefined {
+	return runners.get(sessionId);
+}
+
+/**
+ * Marks a session queue as running.
+ */
+export function setRunning(sessionId: string, running: boolean) {
+	const state = runners.get(sessionId);
+	if (state) {
+		state.running = running;
+	}
+}
+
+/**
+ * Dequeues the next job from a session's queue.
+ */
+export function dequeueJob(sessionId: string): RunOpts | undefined {
+	const state = runners.get(sessionId);
+	return state?.queue.shift();
+}
+
+/**
+ * Cleanup abort controller for a session (called when queue is done).
+ */
+export function cleanupSession(sessionId: string) {
+	sessionAbortControllers.delete(sessionId);
+}