@agi-cli/server 0.1.55

package/src/runtime/ask-service.ts

@@ -0,0 +1,363 @@
+import { eq } from 'drizzle-orm';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import {
+	createSession,
+	getLastSession,
+	getSessionById,
+} from './session-manager.ts';
+import {
+	selectProviderAndModel,
+	type ProviderSelection,
+} from './provider-selection.ts';
+import { resolveAgentConfig } from './agent-registry.ts';
+import { dispatchAssistantMessage } from './message-service.ts';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+	isProviderId,
+	type ProviderId,
+} from '@agi-cli/sdk';
+import { sessions } from '@agi-cli/database/schema';
+import { time } from './debug.ts';
+
+export class AskServiceError extends Error {
+	constructor(
+		message: string,
+		public status = 400,
+		public code = 'ASK_SERVICE_ERROR',
+	) {
+		super(message);
+		this.name = 'AskServiceError';
+	}
+
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			code: this.code,
+			status: this.status,
+		};
+	}
+}
+
+export type InjectableConfig = {
+	provider?: string;
+	model?: string;
+	apiKey?: string;
+	agent?: string;
+};
+
+export type InjectableCredentials = Partial<
+	Record<ProviderId, { apiKey: string }>
+>;
+
+export type AskServerRequest = {
+	projectRoot?: string;
+	prompt: string;
+	agent?: string;
+	provider?: string;
+	model?: string;
+	sessionId?: string;
+	last?: boolean;
+	jsonMode?: boolean;
+	skipFileConfig?: boolean;
+	config?: InjectableConfig;
+	credentials?: InjectableCredentials;
+	agentPrompt?: string;
+	tools?: string[];
+};
+
+export type AskServerResponse = {
+	sessionId: string;
+	header: {
+		agent?: string;
+		provider?: string;
+		model?: string;
+		sessionId: string;
+	};
+	provider: ProviderId;
+	model: string;
+	agent: string;
+	assistantMessageId: string;
+	message?: { kind: 'created' | 'last'; sessionId: string };
+};
+
+type SessionRow =
+	typeof import('@agi-cli/database/schema').sessions.$inferSelect;
+
+export async function handleAskRequest(
+	request: AskServerRequest,
+): Promise<AskServerResponse> {
+	try {
+		return await processAskRequest(request);
+	} catch (err) {
+		throw normalizeAskServiceError(err);
+	}
+}
+
+async function processAskRequest(
+	request: AskServerRequest,
+): Promise<AskServerResponse> {
+	const projectRoot = request.projectRoot || process.cwd();
+	const configTimer = time('ask:loadConfig+db');
+
+	let cfg: import('@agi-cli/sdk').AGIConfig;
+
+	if (request.skipFileConfig || request.config) {
+		const injectedProvider = (request.config?.provider ||
+			request.provider ||
+			'openai') as ProviderId;
+		const injectedModel =
+			request.config?.model || request.model || 'gpt-4o-mini';
+		const injectedAgent = request.config?.agent || request.agent || 'general';
+
+		cfg = {
+			projectRoot,
+			defaults: {
+				provider: injectedProvider,
+				model: injectedModel,
+				agent: injectedAgent,
+			},
+			providers: {
+				openai: { enabled: true },
+				anthropic: { enabled: true },
+				google: { enabled: true },
+				openrouter: { enabled: true },
+				opencode: { enabled: true },
+			},
+			paths: {
+				dataDir: `${projectRoot}/.agi`,
+				dbPath: `${projectRoot}/.agi/agi.sqlite`,
+				projectConfigPath: null,
+				globalConfigPath: null,
+			},
+		};
+
+		if (request.credentials) {
+			for (const [provider, creds] of Object.entries(request.credentials)) {
+				const envKey = `${provider.toUpperCase()}_API_KEY`;
+				process.env[envKey] = creds.apiKey;
+			}
+		} else if (request.config?.apiKey) {
+			const envKey = `${injectedProvider.toUpperCase()}_API_KEY`;
+			process.env[envKey] = request.config.apiKey;
+		}
+	} else {
+		cfg = await loadConfig(projectRoot);
+	}
+
+	const db = await getDb(cfg.projectRoot);
+	configTimer.end();
+
+	let session: SessionRow | undefined;
+	let messageIndicator: AskServerResponse['message'];
+
+	if (request.sessionId) {
+		session = await getSessionById({
+			db,
+			projectPath: cfg.projectRoot,
+			sessionId: request.sessionId,
+		});
+		if (!session) {
+			throw new AskServiceError(`Session not found: ${request.sessionId}`, 404);
+		}
+	} else if (request.last) {
+		session = await getLastSession({ db, projectPath: cfg.projectRoot });
+		if (session) {
+			messageIndicator = { kind: 'last', sessionId: session.id };
+		}
+	} else {
+		session = undefined;
+	}
+
+	const agentName = (() => {
+		if (request.agent) return request.agent;
+		if (session?.agent) return session.agent;
+		return cfg.defaults.agent;
+	})();
+
+	const agentTimer = time('ask:resolveAgentConfig');
+	const agentCfg = request.agentPrompt
+		? {
+				name: agentName,
+				prompt: request.agentPrompt,
+				tools: request.tools ?? ['progress_update', 'finish'],
+				provider: isProviderId(request.provider)
+					? (request.provider as ProviderId)
+					: undefined,
+				model: request.model,
+			}
+		: await resolveAgentConfig(cfg.projectRoot, agentName);
+	agentTimer.end({ agent: agentName });
+	const agentProviderDefault = isProviderId(agentCfg.provider)
+		? agentCfg.provider
+		: cfg.defaults.provider;
+	const agentModelDefault = agentCfg.model ?? cfg.defaults.model;
+
+	const explicitProvider = isProviderId(request.provider)
+		? (request.provider as ProviderId)
+		: undefined;
+
+	let providerSelection: ProviderSelection;
+	const selectTimer = time('ask:selectProviderModel');
+	try {
+		providerSelection = await selectProviderAndModel({
+			cfg,
+			agentProviderDefault,
+			agentModelDefault,
+			explicitProvider,
+			explicitModel: request.model,
+			skipAuth: Boolean(
+				request.skipFileConfig || request.config || request.credentials,
+			),
+		});
+		selectTimer.end({ provider: providerSelection.provider });
+	} catch (err) {
+		selectTimer.end();
+		throw normalizeAskServiceError(err);
+	}
+
+	if (!session) {
+		const createTimer = time('ask:createSession');
+		const newSession = await createSession({
+			db,
+			cfg,
+			agent: agentName,
+			provider: providerSelection.provider,
+			model: providerSelection.model,
+			title: null,
+		});
+		createTimer.end();
+		session = newSession;
+		messageIndicator = { kind: 'created', sessionId: newSession.id };
+	}
+	if (!session)
+		throw new AskServiceError('Failed to resolve or create session.', 500);
+
+	const overridesProvided = Boolean(request.provider || request.model);
+
+	let providerForMessage: ProviderId;
+	let modelForMessage: string;
+
+	if (overridesProvided) {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+	} else if (session.provider && session.model) {
+		const sessionProvider = isProviderId(session.provider)
+			? (session.provider as ProviderId)
+			: agentProviderDefault;
+		providerForMessage = sessionProvider;
+		modelForMessage = session.model;
+	} else {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+	}
+
+	const providerAuthorized = await isProviderAuthorized(
+		cfg,
+		providerForMessage,
+	);
+	let fellBackToSelection = false;
+	if (!providerAuthorized) {
+		providerForMessage = providerSelection.provider;
+		modelForMessage = providerSelection.model;
+		fellBackToSelection = true;
+	}
+	if (
+		session &&
+		fellBackToSelection &&
+		(session.provider !== providerForMessage ||
+			session.model !== modelForMessage)
+	) {
+		await db
+			.update(sessions)
+			.set({ provider: providerForMessage, model: modelForMessage })
+			.where(eq(sessions.id, session.id));
+		session = {
+			...session,
+			provider: providerForMessage,
+			model: modelForMessage,
+		} as SessionRow;
+	}
+
+	validateProviderModel(providerForMessage, modelForMessage);
+
+	if (!request.skipFileConfig && !request.config && !request.credentials) {
+		await ensureProviderEnv(cfg, providerForMessage);
+	}
+
+	const assistantMessage = await dispatchAssistantMessage({
+		cfg,
+		db,
+		session,
+		agent: agentName,
+		provider: providerForMessage,
+		model: modelForMessage,
+		content: request.prompt,
+		oneShot: !request.sessionId && !request.last,
+	});
+
+	const headerAgent = session.agent ?? agentName;
+	const headerProvider = providerForMessage;
+	const headerModel = modelForMessage;
+
+	return {
+		sessionId: session.id,
+		header: {
+			agent: headerAgent,
+			provider: headerProvider,
+			model: headerModel,
+			sessionId: session.id,
+		},
+		provider: providerForMessage,
+		model: modelForMessage,
+		agent: agentName,
+		assistantMessageId: assistantMessage.assistantMessageId,
+		message: messageIndicator,
+	};
+}
+
+function normalizeAskServiceError(err: unknown): AskServiceError {
+	if (err instanceof AskServiceError) return err;
+	if (err instanceof Error) {
+		const status = inferStatus(err);
+		const message = err.message || 'Unknown error';
+		return new AskServiceError(message, status);
+	}
+	return new AskServiceError(String(err ?? 'Unknown error'));
+}
+
+export function inferStatus(err: Error): number {
+	const anyErr = err as { status?: unknown; code?: unknown };
+	if (typeof anyErr.status === 'number') {
+		const s = anyErr.status;
+		if (Number.isFinite(s) && s >= 400 && s < 600) return s;
+	}
+	if (typeof anyErr.code === 'number') {
+		const s = anyErr.code;
+		if (Number.isFinite(s) && s >= 400 && s < 600) return s;
+	}
+	const derived = deriveStatusFromMessage(err.message || '');
+	return derived ?? 400;
+}
+
+const STATUS_PATTERNS: Array<{ regex: RegExp; status: number }> = [
+	{ regex: /not found/i, status: 404 },
+	{ regex: /missing credentials/i, status: 401 },
+	{ regex: /unauthorized/i, status: 401 },
+	{ regex: /not configured/i, status: 401 },
+	{ regex: /authorized providers/i, status: 401 },
+	{ regex: /forbidden/i, status: 403 },
+	{ regex: /timeout/i, status: 504 },
+];
+
+export function deriveStatusFromMessage(message: string): number | undefined {
+	const trimmed = message.trim();
+	if (!trimmed) return undefined;
+	for (const { regex, status } of STATUS_PATTERNS) {
+		if (regex.test(trimmed)) return status;
+	}
+	return undefined;
+}

package/src/runtime/cwd.ts

@@ -0,0 +1,69 @@
+const cwdMap = new Map<string, string>();
+
+export function getCwd(sessionId: string): string {
+	return cwdMap.get(sessionId) ?? '.';
+}
+
+export function setCwd(sessionId: string, cwd: string) {
+	cwdMap.set(sessionId, cwd || '.');
+}
+
+// normalize relative path like './a/../b' -> 'b', never escapes above '.'
+export function normalizeRelative(path: string): string {
+	const parts = path.replace(/\\/g, '/').split('/');
+	const stack: string[] = [];
+	for (const part of parts) {
+		if (!part || part === '.') continue;
+		if (part === '..') {
+			if (stack.length > 0) stack.pop();
+			continue;
+		}
+		stack.push(part);
+	}
+	return stack.length ? stack.join('/') : '.';
+}
+
+export function joinRelative(base: string, p: string): string {
+	if (!p || p === '.') return base || '.';
+
+	// Expand tilde to home directory if present
+	const home = process.env.HOME || process.env.USERPROFILE || '';
+	if (p === '~' && home) p = home;
+	else if (p.startsWith('~/') && home) p = `${home}/${p.slice(2)}`;
+
+	// If target is absolute, preserve it as absolute
+	if (p.startsWith('/')) {
+		// Canonicalize: collapse //, resolve . and .. without escaping above root
+		const parts = p.replace(/\\/g, '/').split('/');
+		const stack: string[] = [];
+		for (const part of parts) {
+			if (!part || part === '.') continue;
+			if (part === '..') {
+				if (stack.length > 0) stack.pop();
+				continue;
+			}
+			stack.push(part);
+		}
+		return `/${stack.join('/')}` || '/';
+	}
+
+	// If base is absolute, join and return absolute
+	const baseIsAbs = Boolean(base) && base.startsWith('/');
+	if (baseIsAbs) {
+		const joined = `${base.replace(/\/$/, '')}/${p}`;
+		const parts = joined.replace(/\\/g, '/').split('/');
+		const stack: string[] = [];
+		for (const part of parts) {
+			if (!part || part === '.') continue;
+			if (part === '..') {
+				if (stack.length > 0) stack.pop();
+				continue;
+			}
+			stack.push(part);
+		}
+		return `/${stack.join('/')}` || '/';
+	}
+
+	// Relative -> Relative join
+	return normalizeRelative(`${base || '.'}/${p}`);
+}

package/src/runtime/db-operations.ts

@@ -0,0 +1,94 @@
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts, sessions } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import type { RunOpts } from './session-queue.ts';
+
+/**
+ * Updates session token counts after a run completes.
+ */
+export async function updateSessionTokens(
+	fin: { usage?: { inputTokens?: number; outputTokens?: number } },
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	if (!fin.usage) return;
+
+	const sessRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId));
+
+	if (sessRows.length > 0 && sessRows[0]) {
+		const row = sessRows[0];
+		const priorInput = Number(row.totalInputTokens ?? 0);
+		const priorOutput = Number(row.totalOutputTokens ?? 0);
+		const nextInput = priorInput + Number(fin.usage.inputTokens ?? 0);
+		const nextOutput = priorOutput + Number(fin.usage.outputTokens ?? 0);
+
+		await db
+			.update(sessions)
+			.set({
+				totalInputTokens: nextInput,
+				totalOutputTokens: nextOutput,
+			})
+			.where(eq(sessions.id, opts.sessionId));
+	}
+}
+
+/**
+ * Marks an assistant message as complete with token usage information.
+ */
+export async function completeAssistantMessage(
+	fin: {
+		usage?: {
+			inputTokens?: number;
+			outputTokens?: number;
+			totalTokens?: number;
+		};
+	},
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	const vals: Record<string, unknown> = {
+		status: 'complete',
+		completedAt: Date.now(),
+	};
+
+	if (fin.usage) {
+		vals.promptTokens = fin.usage.inputTokens;
+		vals.completionTokens = fin.usage.outputTokens;
+		vals.totalTokens =
+			fin.usage.totalTokens ??
+			(vals.promptTokens as number) + (vals.completionTokens as number);
+	}
+
+	await db
+		.update(messages)
+		.set(vals)
+		.where(eq(messages.id, opts.assistantMessageId));
+}
+
+/**
+ * Removes empty text parts from an assistant message.
+ */
+export async function cleanupEmptyTextParts(
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+) {
+	const parts = await db
+		.select()
+		.from(messageParts)
+		.where(eq(messageParts.messageId, opts.assistantMessageId));
+
+	for (const p of parts) {
+		if (p.type === 'text') {
+			let t = '';
+			try {
+				t = JSON.parse(p.content || '{}')?.text || '';
+			} catch {}
+			if (!t || t.length === 0) {
+				await db.delete(messageParts).where(eq(messageParts.id, p.id));
+			}
+		}
+	}
+}

package/src/runtime/debug.ts

@@ -0,0 +1,104 @@
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+const SYNONYMS: Record<string, string> = {
+	debug: 'log',
+	logs: 'log',
+	logging: 'log',
+	trace: 'log',
+	verbose: 'log',
+	log: 'log',
+	time: 'timing',
+	timing: 'timing',
+	timings: 'timing',
+	perf: 'timing',
+};
+
+type DebugConfig = { flags: Set<string> };
+
+let cachedConfig: DebugConfig | null = null;
+
+function isTruthy(raw: string | undefined): boolean {
+	if (!raw) return false;
+	const trimmed = raw.trim().toLowerCase();
+	if (!trimmed) return false;
+	return TRUTHY.has(trimmed) || trimmed === 'all';
+}
+
+function normalizeToken(token: string): string {
+	const trimmed = token.trim().toLowerCase();
+	if (!trimmed) return '';
+	if (TRUTHY.has(trimmed) || trimmed === 'all') return 'all';
+	return SYNONYMS[trimmed] ?? trimmed;
+}
+
+function parseDebugConfig(): DebugConfig {
+	const flags = new Set<string>();
+	const sources = [process.env.AGI_DEBUG, process.env.DEBUG_AGI];
+	let sawValue = false;
+	for (const raw of sources) {
+		if (typeof raw !== 'string') continue;
+		const trimmed = raw.trim();
+		if (!trimmed) continue;
+		sawValue = true;
+		const tokens = trimmed.split(/[\s,]+/);
+		let matched = false;
+		for (const token of tokens) {
+			const normalized = normalizeToken(token);
+			if (!normalized) continue;
+			matched = true;
+			flags.add(normalized);
+		}
+		if (!matched && isTruthy(trimmed)) flags.add('all');
+	}
+	if (isTruthy(process.env.AGI_DEBUG_TIMING)) flags.add('timing');
+	if (!flags.size && sawValue) flags.add('all');
+	return { flags };
+}
+
+function getDebugConfig(): DebugConfig {
+	if (!cachedConfig) cachedConfig = parseDebugConfig();
+	return cachedConfig;
+}
+
+export function isDebugEnabled(flag?: string): boolean {
+	const config = getDebugConfig();
+	if (config.flags.has('all')) return true;
+	if (flag) return config.flags.has(flag);
+	return config.flags.has('log');
+}
+
+export function debugLog(...args: unknown[]) {
+	if (!isDebugEnabled('log')) return;
+	try {
+		console.log('[debug]', ...args);
+	} catch {}
+}
+
+function nowMs(): number {
+	const perf = (globalThis as { performance?: { now?: () => number } })
+		.performance;
+	if (perf && typeof perf.now === 'function') return perf.now();
+	return Date.now();
+}
+
+type Timer = { end(meta?: Record<string, unknown>): void };
+
+export function time(label: string): Timer {
+	if (!isDebugEnabled('timing')) {
+		return { end() {} };
+	}
+	const start = nowMs();
+	let finished = false;
+	return {
+		end(meta?: Record<string, unknown>) {
+			if (finished) return;
+			finished = true;
+			const duration = nowMs() - start;
+			try {
+				const line = `[timing] ${label} ${duration.toFixed(1)}ms`;
+				if (meta && Object.keys(meta).length) console.log(line, meta);
+				else console.log(line);
+			} catch {}
+		},
+	};
+}