@agi-cli/server 0.1.55

package/src/routes/openapi.ts

@@ -0,0 +1,6 @@
+import type { Hono } from 'hono';
+import { getOpenAPISpec } from '../openapi/spec.ts';
+
+export function registerOpenApiRoute(app: Hono) {
+	app.get('/openapi.json', (c) => c.json(getOpenAPISpec()));
+}

package/src/routes/root.ts

@@ -0,0 +1,5 @@
+import type { Hono } from 'hono';
+
+export function registerRootRoutes(app: Hono) {
+	app.get('/', (c) => c.text('agi server running'));
+}

package/src/routes/session-messages.ts

@@ -0,0 +1,123 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { messages, messageParts, sessions } from '@agi-cli/database/schema';
+import { eq, inArray } from 'drizzle-orm';
+import {
+	validateProviderModel,
+	isProviderAuthorized,
+	ensureProviderEnv,
+} from '@agi-cli/sdk';
+import { dispatchAssistantMessage } from '../runtime/message-service.ts';
+
+type MessagePartRow = typeof messageParts.$inferSelect;
+type SessionRow = typeof sessions.$inferSelect;
+
+export function registerSessionMessagesRoutes(app: Hono) {
+	// List messages for a session
+	app.get('/v1/sessions/:id/messages', async (c) => {
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+		const id = c.req.param('id');
+		const rows = await db
+			.select()
+			.from(messages)
+			.where(eq(messages.sessionId, id))
+			.orderBy(messages.createdAt);
+		const without = c.req.query('without');
+		if (without !== 'parts') {
+			const ids = rows.map((m) => m.id);
+			const parts = ids.length
+				? await db
+						.select()
+						.from(messageParts)
+						.where(inArray(messageParts.messageId, ids))
+				: [];
+			const partsByMsg = new Map<string, MessagePartRow[]>();
+			for (const p of parts) {
+				const existing = partsByMsg.get(p.messageId);
+				if (existing) existing.push(p);
+				else partsByMsg.set(p.messageId, [p]);
+			}
+			const wantParsed = (() => {
+				const q = (c.req.query('parsed') || '').toLowerCase();
+				return q === '1' || q === 'true' || q === 'yes';
+			})();
+			function parseContent(raw: string): Record<string, unknown> | string {
+				try {
+					const v = JSON.parse(String(raw ?? ''));
+					if (v && typeof v === 'object' && !Array.isArray(v))
+						return v as Record<string, unknown>;
+				} catch {}
+				return raw;
+			}
+			const enriched = rows.map((m) => {
+				const parts = (partsByMsg.get(m.id) ?? []).sort(
+					(a, b) => a.index - b.index,
+				);
+				const mapped = parts.map((p) => {
+					const parsed = parseContent(p.content);
+					return wantParsed
+						? { ...p, content: parsed }
+						: { ...p, contentJson: parsed };
+				});
+				return { ...m, parts: mapped };
+			});
+			return c.json(enriched);
+		}
+		return c.json(rows);
+	});
+
+	// Post a user message and get assistant reply (non-streaming for v0)
+	app.post('/v1/sessions/:id/messages', async (c) => {
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+		const sessionId = c.req.param('id');
+		const body = await c.req.json().catch(() => ({}));
+		// Load session to inherit its provider/model/agent by default
+		const sessionRows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.id, sessionId));
+		if (!sessionRows.length) return c.json({ error: 'Session not found' }, 404);
+		const sess: SessionRow = sessionRows[0];
+		const provider = body?.provider ?? sess.provider ?? cfg.defaults.provider;
+		const modelName = body?.model ?? sess.model ?? cfg.defaults.model;
+		const agent = body?.agent ?? sess.agent ?? cfg.defaults.agent;
+		const content = body?.content ?? '';
+
+		// Validate model capabilities if tools are allowed for this agent
+		const wantsToolCalls = true; // agent toolset may be non-empty
+		try {
+			validateProviderModel(provider, modelName, { wantsToolCalls });
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return c.json({ error: message }, 400);
+		}
+		// Enforce provider auth: only allow providers/models the user authenticated for
+		const authorized = await isProviderAuthorized(cfg, provider);
+		if (!authorized) {
+			return c.json(
+				{
+					error: `Provider ${provider} is not configured. Run \`agi auth login\` to add credentials.`,
+				},
+				400,
+			);
+		}
+		await ensureProviderEnv(cfg, provider);
+
+		const { assistantMessageId } = await dispatchAssistantMessage({
+			cfg,
+			db,
+			session: sess,
+			agent,
+			provider,
+			model: modelName,
+			content,
+			oneShot: Boolean(body?.oneShot),
+		});
+		return c.json({ messageId: assistantMessageId }, 202);
+	});
+}

package/src/routes/session-stream.ts

@@ -0,0 +1,45 @@
+import type { Hono } from 'hono';
+import { subscribe } from '../events/bus.ts';
+import type { AGIEvent } from '../events/types.ts';
+
+export function registerSessionStreamRoute(app: Hono) {
+	app.get('/v1/sessions/:id/stream', async (c) => {
+		const sessionId = c.req.param('id');
+		const headers = new Headers({
+			'Content-Type': 'text/event-stream',
+			'Cache-Control': 'no-cache, no-transform',
+			Connection: 'keep-alive',
+		});
+
+		const encoder = new TextEncoder();
+
+		const stream = new ReadableStream<Uint8Array>({
+			start(controller) {
+				const write = (evt: AGIEvent) => {
+					const line =
+						`event: ${evt.type}\n` +
+						`data: ${JSON.stringify(evt.payload ?? {})}\n\n`;
+					controller.enqueue(encoder.encode(line));
+				};
+				const unsubscribe = subscribe(sessionId, write);
+				// Initial ping
+				controller.enqueue(encoder.encode(`: connected ${sessionId}\n\n`));
+				const hb = setInterval(() => {
+					// Comment line as heartbeat to keep connection alive
+					controller.enqueue(encoder.encode(`: hb ${Date.now()}\n\n`));
+				}, 15000);
+
+				const signal = c.req.raw?.signal as AbortSignal | undefined;
+				signal?.addEventListener('abort', () => {
+					clearInterval(hb);
+					unsubscribe();
+					try {
+						controller.close();
+					} catch {}
+				});
+			},
+		});
+
+		return new Response(stream, { headers });
+	});
+}

package/src/routes/sessions.ts

@@ -0,0 +1,87 @@
+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 type { ProviderId } from '@agi-cli/sdk';
+import { isProviderId } from '@agi-cli/sdk';
+import { resolveAgentConfig } from '../runtime/agent-registry.ts';
+import { createSession as createSessionRow } from '../runtime/session-manager.ts';
+
+export function registerSessionsRoutes(app: Hono) {
+	// List sessions
+	app.get('/v1/sessions', async (c) => {
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+		// Only return sessions for this project
+		const rows = await db
+			.select()
+			.from(sessions)
+			.where(eq(sessions.projectPath, cfg.projectRoot))
+			.orderBy(desc(sessions.lastActiveAt), desc(sessions.createdAt));
+		const normalized = rows.map((r) => {
+			let counts: Record<string, unknown> | undefined;
+			if (r.toolCountsJson) {
+				try {
+					const parsed = JSON.parse(r.toolCountsJson);
+					if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+						counts = parsed as Record<string, unknown>;
+					}
+				} catch {}
+			}
+			const { toolCountsJson: _toolCountsJson, ...rest } = r;
+			return counts ? { ...rest, toolCounts: counts } : rest;
+		});
+		return c.json(normalized);
+	});
+
+	// Create session
+	app.post('/v1/sessions', async (c) => {
+		const projectRoot = c.req.query('project') || process.cwd();
+		const cfg = await loadConfig(projectRoot);
+		const db = await getDb(cfg.projectRoot);
+		const body = (await c.req.json().catch(() => ({}))) as Record<
+			string,
+			unknown
+		>;
+		const agent = (body.agent as string | undefined) ?? cfg.defaults.agent;
+		const agentCfg = await resolveAgentConfig(cfg.projectRoot, agent);
+		const providerCandidate =
+			typeof body.provider === 'string' ? body.provider : undefined;
+		const provider: ProviderId = (() => {
+			if (providerCandidate && isProviderId(providerCandidate))
+				return providerCandidate;
+			if (agentCfg.provider && isProviderId(agentCfg.provider))
+				return agentCfg.provider;
+			return cfg.defaults.provider;
+		})();
+		const modelCandidate =
+			typeof body.model === 'string' ? body.model.trim() : undefined;
+		const model = modelCandidate?.length
+			? modelCandidate
+			: (agentCfg.model ?? cfg.defaults.model);
+		try {
+			const row = await createSessionRow({
+				db,
+				cfg,
+				agent,
+				provider,
+				model,
+				title: (body.title as string | null | undefined) ?? null,
+			});
+			return c.json(row, 201);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return c.json({ error: message }, 400);
+		}
+	});
+
+	// 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);
+		return c.json({ success: true });
+	});
+}

package/src/runtime/agent-registry.ts

@@ -0,0 +1,327 @@
+import { getGlobalAgentsJsonPath, getGlobalAgentsDir } from '@agi-cli/sdk';
+import { debugLog } from './debug.ts';
+import type { ProviderName } from '@agi-cli/sdk';
+import { catalog } from '@agi-cli/sdk';
+// Embed default agent prompts; only user overrides read from disk.
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_BUILD from '@agi-cli/sdk/prompts/agents/build.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_PLAN from '@agi-cli/sdk/prompts/agents/plan.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_GENERAL from '@agi-cli/sdk/prompts/agents/general.txt' with {
+	type: 'text',
+};
+
+export type AgentConfig = {
+	name: string;
+	prompt: string;
+	tools: string[]; // allowed tool names
+	provider?: ProviderName;
+	model?: string;
+};
+
+export type AgentConfigEntry = {
+	tools?: string[];
+	appendTools?: string[];
+	prompt?: string;
+	provider?: string;
+	model?: string;
+};
+
+type AgentsJson = Record<string, AgentConfigEntry>;
+
+function normalizeStringList(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const item of value) {
+		if (typeof item !== 'string') continue;
+		const trimmed = item.trim();
+		if (!trimmed || seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		out.push(trimmed);
+	}
+	return out;
+}
+
+const providerValues = new Set<ProviderName>(
+	Object.keys(catalog) as ProviderName[],
+);
+
+function normalizeProvider(value: unknown): ProviderName | undefined {
+	if (typeof value !== 'string') return undefined;
+	const trimmed = value.trim().toLowerCase();
+	if (!trimmed) return undefined;
+	return providerValues.has(trimmed as ProviderName)
+		? (trimmed as ProviderName)
+		: undefined;
+}
+
+function normalizeModel(value: unknown): string | undefined {
+	if (typeof value !== 'string') return undefined;
+	const trimmed = value.trim();
+	return trimmed.length ? trimmed : undefined;
+}
+
+function mergeAgentEntries(
+	base: AgentConfigEntry | undefined,
+	override: AgentConfigEntry,
+): AgentConfigEntry {
+	const merged: AgentConfigEntry = {};
+	const baseTools = normalizeStringList(base?.tools);
+	if (baseTools.length) merged.tools = [...baseTools];
+	const baseAppend = normalizeStringList(base?.appendTools);
+	if (baseAppend.length) merged.appendTools = [...baseAppend];
+	if (base && Object.hasOwn(base, 'prompt')) merged.prompt = base.prompt;
+	if (base && Object.hasOwn(base, 'provider'))
+		merged.provider = normalizeProvider(base.provider);
+	if (base && Object.hasOwn(base, 'model'))
+		merged.model = normalizeModel(base.model);
+
+	if (Array.isArray(override.tools))
+		merged.tools = normalizeStringList(override.tools);
+	if (Array.isArray(override.appendTools)) {
+		const extras = normalizeStringList(override.appendTools);
+		const union = new Set([...(merged.appendTools ?? []), ...extras]);
+		merged.appendTools = Array.from(union);
+	} else if (
+		Object.hasOwn(override, 'appendTools') &&
+		!Array.isArray(override.appendTools)
+	) {
+		delete merged.appendTools;
+	}
+	if (Object.hasOwn(override, 'prompt')) merged.prompt = override.prompt;
+
+	if (Object.hasOwn(override, 'provider')) {
+		const normalized = normalizeProvider(override.provider);
+		if (normalized) merged.provider = normalized;
+		else delete merged.provider;
+	}
+	if (Object.hasOwn(override, 'model')) {
+		const normalized = normalizeModel(override.model);
+		if (normalized) merged.model = normalized;
+		else delete merged.model;
+	}
+	return merged;
+}
+
+const baseToolSet = ['progress_update', 'finish'] as const;
+
+const defaultToolExtras: Record<string, string[]> = {
+	build: [
+		'read',
+		'write',
+		'ls',
+		'tree',
+		'bash',
+		'update_plan',
+		'grep',
+		'git_status',
+		'git_diff',
+		'ripgrep',
+		'apply_patch',
+		'websearch',
+	],
+	plan: ['read', 'ls', 'tree', 'ripgrep', 'update_plan', 'websearch'],
+	general: [
+		'read',
+		'write',
+		'ls',
+		'tree',
+		'bash',
+		'ripgrep',
+		'websearch',
+		'update_plan',
+	],
+	git: ['git_status', 'git_diff', 'git_commit', 'read', 'ls'],
+	commit: ['git_status', 'git_diff', 'git_commit', 'read', 'ls'],
+};
+
+export function defaultToolsForAgent(name: string): string[] {
+	const extras = defaultToolExtras[name] ? [...defaultToolExtras[name]] : [];
+	return Array.from(new Set([...baseToolSet, ...extras]));
+}
+
+export async function loadAgentsConfig(
+	projectRoot: string,
+): Promise<AgentsJson> {
+	const localPath = `${projectRoot}/.agi/agents.json`.replace(/\\/g, '/');
+	const globalPath = getGlobalAgentsJsonPath();
+	let globalCfg: AgentsJson = {};
+	let localCfg: AgentsJson = {};
+	try {
+		const gf = Bun.file(globalPath);
+		if (await gf.exists())
+			globalCfg = (await gf.json().catch(() => ({}))) as AgentsJson;
+	} catch {}
+	try {
+		const lf = Bun.file(localPath);
+		if (await lf.exists())
+			localCfg = (await lf.json().catch(() => ({}))) as AgentsJson;
+	} catch {}
+	const merged: AgentsJson = {};
+	for (const [name, entry] of Object.entries(globalCfg)) {
+		merged[name] = mergeAgentEntries(undefined, entry ?? {});
+	}
+	for (const [name, entry] of Object.entries(localCfg)) {
+		const base = merged[name];
+		merged[name] = mergeAgentEntries(base, entry ?? {});
+	}
+	return merged;
+}
+
+export async function resolveAgentConfig(
+	projectRoot: string,
+	name: string,
+	inlineConfig?: {
+		prompt?: string;
+		tools?: string[];
+		provider?: string;
+		model?: string;
+	},
+): Promise<AgentConfig> {
+	if (inlineConfig?.prompt) {
+		const provider = normalizeProvider(inlineConfig.provider);
+		const model = normalizeModel(inlineConfig.model);
+		return {
+			name,
+			prompt: inlineConfig.prompt,
+			tools: inlineConfig.tools ?? defaultToolsForAgent(name),
+			provider,
+			model,
+		};
+	}
+	const agents = await loadAgentsConfig(projectRoot);
+	const entry = agents[name];
+	let prompt = '';
+	let promptSource: string = 'none';
+
+	// Override files: project first, then global
+	const globalAgentsDir = getGlobalAgentsDir();
+	const localDirTxt = `${projectRoot}/.agi/agents/${name}/agent.txt`.replace(
+		/\\/g,
+		'/',
+	);
+	const localDirMd = `${projectRoot}/.agi/agents/${name}/agent.md`.replace(
+		/\\/g,
+		'/',
+	);
+	const localFlatTxt = `${projectRoot}/.agi/agents/${name}.txt`.replace(
+		/\\/g,
+		'/',
+	);
+	const localFlatMd = `${projectRoot}/.agi/agents/${name}.md`.replace(
+		/\\/g,
+		'/',
+	);
+	const globalDirTxt = `${globalAgentsDir}/${name}/agent.txt`.replace(
+		/\\/g,
+		'/',
+	);
+	const globalDirMd = `${globalAgentsDir}/${name}/agent.md`.replace(/\\/g, '/');
+	const globalFlatTxt = `${globalAgentsDir}/${name}.txt`.replace(/\\/g, '/');
+	const globalFlatMd = `${globalAgentsDir}/${name}.md`.replace(/\\/g, '/');
+	const files = [
+		localDirMd,
+		localFlatMd,
+		localDirTxt,
+		localFlatTxt,
+		globalDirMd,
+		globalFlatMd,
+		globalDirTxt,
+		globalFlatTxt,
+	];
+	for (const p of files) {
+		try {
+			const f = Bun.file(p);
+			if (await f.exists()) {
+				const text = await f.text();
+				if (text.trim()) {
+					prompt = text;
+					promptSource = `file:${p}`;
+					break;
+				}
+			}
+		} catch {}
+	}
+
+	// If agents.json provides a 'prompt' field, accept inline content or a relative/absolute path
+	if (entry?.prompt) {
+		const p = entry.prompt.trim();
+		if (
+			/[.](md|txt)$/i.test(p) ||
+			p.startsWith('.') ||
+			p.startsWith('/') ||
+			p.startsWith('~/')
+		) {
+			const candidates: string[] = [];
+			if (p.startsWith('~/')) {
+				const home = process.env.HOME || process.env.USERPROFILE || '';
+				candidates.push(`${home}/${p.slice(2)}`);
+			} else if (p.startsWith('/')) candidates.push(p);
+			else candidates.push(`${projectRoot}/${p}`.replace(/\\/g, '/'));
+			for (const candidate of candidates) {
+				const pf = Bun.file(candidate);
+				if (await pf.exists()) {
+					const t = await pf.text();
+					if (t.trim()) {
+						prompt = t;
+						promptSource = `agents.json:file:${candidate}`;
+						break;
+					}
+				}
+			}
+		} else {
+			prompt = p;
+			promptSource = 'agents.json:inline';
+		}
+	}
+
+	// Fallback: use embedded defaults (plan/build/general); else default to build
+	if (!prompt) {
+		const byName = (n: string): string | undefined => {
+			if (n === 'build') return AGENT_BUILD;
+			if (n === 'plan') return AGENT_PLAN;
+			if (n === 'general') return AGENT_GENERAL;
+			return undefined;
+		};
+		const candidate = byName(name)?.trim();
+		if (candidate?.length) {
+			prompt = candidate;
+			promptSource = `fallback:embedded:${name}.txt`;
+		} else {
+			prompt = (AGENT_BUILD || '').trim();
+			promptSource = 'fallback:embedded:build.txt';
+		}
+	}
+
+	// Default tool access per agent if not explicitly configured
+	let tools = Array.isArray(entry?.tools)
+		? [...(entry?.tools as string[])]
+		: defaultToolsForAgent(name);
+	if (!entry || !entry.tools) {
+		tools = defaultToolsForAgent(name);
+	}
+	if (Array.isArray(entry?.appendTools) && entry.appendTools.length) {
+		for (const t of entry.appendTools) {
+			if (typeof t === 'string' && t.trim()) tools.push(t.trim());
+		}
+	}
+	// Deduplicate and ensure base tools are always available
+	const deduped = Array.from(new Set([...tools, ...baseToolSet]));
+	const provider = normalizeProvider(entry?.provider);
+	const model = normalizeModel(entry?.model);
+	debugLog(`[agent] ${name} prompt source: ${promptSource}`);
+	debugLog(`[agent] ${name} prompt:\n${prompt}`);
+	return {
+		name,
+		prompt,
+		tools: deduped,
+		provider,
+		model,
+	};
+}