@agi-cli/server 0.1.76 → 0.1.77

package/package.json

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

package/src/routes/config.ts

@@ -1,12 +1,18 @@
 import type { Hono } from 'hono';
 import { loadConfig } from '@agi-cli/sdk';
-import { catalog, type ProviderId, isProviderAuthorized } from '@agi-cli/sdk';
+import {
+	catalog,
+	type ProviderId,
+	isProviderAuthorized,
+	getGlobalAgentsDir,
+} from '@agi-cli/sdk';
 import { readdir } from 'node:fs/promises';
 import { join, basename } from 'node:path';
 import type { EmbeddedAppConfig } from '../index.ts';
 import type { AGIConfig } from '@agi-cli/sdk';
 import { logger } from '../runtime/logger.ts';
 import { serializeError } from '../runtime/api-error.ts';
+import { loadAgentsConfig } from '../runtime/agent-registry.ts';
 
 /**
  * Check if a provider is authorized in either embedded config or file-based config
@@ -64,6 +70,63 @@ function getDefault<T>(
 	return embeddedValue ?? embeddedDefaultValue ?? fileValue;
 }
 
+/**
+ * Discover all agents from all sources:
+ * - Built-in agents (general, build, plan)
+ * - agents.json (global + local)
+ * - Agent files in .agi/agents/ (global + local)
+ */
+async function discoverAllAgents(projectRoot: string): Promise<string[]> {
+	const builtInAgents = ['general', 'build', 'plan'];
+	const agentSet = new Set<string>(builtInAgents);
+
+	// Load agents from agents.json (global + local merged)
+	try {
+		const agentsJson = await loadAgentsConfig(projectRoot);
+		for (const agentName of Object.keys(agentsJson)) {
+			if (agentName.trim()) {
+				agentSet.add(agentName);
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to load agents.json', err);
+	}
+
+	// Discover custom agent files from local .agi/agents/
+	try {
+		const localAgentsPath = join(projectRoot, '.agi', 'agents');
+		const localFiles = await readdir(localAgentsPath).catch(() => []);
+		for (const file of localFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read local agents directory', err);
+	}
+
+	// Discover custom agent files from global ~/.config/agi/agents/
+	try {
+		const globalAgentsPath = getGlobalAgentsDir();
+		const globalFiles = await readdir(globalAgentsPath).catch(() => []);
+		for (const file of globalFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read global agents directory', err);
+	}
+
+	return Array.from(agentSet).sort();
+}
+
 export function registerConfigRoutes(app: Hono) {
 	// Get working directory info
 	app.get('/v1/config/cwd', (c) => {
@@ -93,26 +156,20 @@ export function registerConfigRoutes(app: Hono) {
 			const cfg = await loadConfig(projectRoot);
 
 			// Hybrid mode: Merge embedded config with file config
-			const builtInAgents = ['general', 'build', 'plan'];
-			let customAgents: string[] = [];
-
-			try {
-				const customAgentsPath = join(cfg.projectRoot, '.agi', 'agents');
-				const files = await readdir(customAgentsPath).catch(() => []);
-				customAgents = files
-					.filter((f) => f.endsWith('.txt'))
-					.map((f) => f.replace('.txt', ''));
-			} catch (err) {
-				logger.debug('Failed to read custom agents directory', err);
+			let allAgents: string[];
+
+			if (embeddedConfig?.agents) {
+				// Embedded mode: use embedded agents + file agents
+				const embeddedAgents = Object.keys(embeddedConfig.agents);
+				const fileAgents = await discoverAllAgents(cfg.projectRoot);
+				allAgents = Array.from(
+					new Set([...embeddedAgents, ...fileAgents]),
+				).sort();
+			} else {
+				// File mode: discover all agents
+				allAgents = await discoverAllAgents(cfg.projectRoot);
 			}
 
-			// Agents: Embedded custom agents + file-based agents
-			const fileAgents = [...builtInAgents, ...customAgents];
-			const embeddedAgents = embeddedConfig?.agents
-				? Object.keys(embeddedConfig.agents)
-				: [];
-			const allAgents = Array.from(new Set([...embeddedAgents, ...fileAgents]));
-
 			// Providers: Check both embedded and file-based auth
 			const authorizedProviders = await getAuthorizedProviders(
 				embeddedConfig,
@@ -174,26 +231,12 @@ export function registerConfigRoutes(app: Hono) {
 			const projectRoot = c.req.query('project') || process.cwd();
 			const cfg = await loadConfig(projectRoot);
 
-			const builtInAgents = ['general', 'build', 'plan'];
-
-			try {
-				const customAgentsPath = join(cfg.projectRoot, '.agi', 'agents');
-				const files = await readdir(customAgentsPath).catch(() => []);
-				const customAgents = files
-					.filter((f) => f.endsWith('.txt'))
-					.map((f) => f.replace('.txt', ''));
+			const allAgents = await discoverAllAgents(cfg.projectRoot);
 
-				return c.json({
-					agents: [...builtInAgents, ...customAgents],
-					default: cfg.defaults.agent,
-				});
-			} catch (err) {
-				logger.debug('Failed to read custom agents directory', err);
-				return c.json({
-					agents: builtInAgents,
-					default: cfg.defaults.agent,
-				});
-			}
+			return c.json({
+				agents: allAgents,
+				default: cfg.defaults.agent,
+			});
 		} catch (error) {
 			logger.error('Failed to get agents', error);
 			const errorResponse = serializeError(error);
@@ -288,4 +331,57 @@ export function registerConfigRoutes(app: Hono) {
 			return c.json(errorResponse, errorResponse.error.status || 500);
 		}
 	});
+
+	// Get all models grouped by provider
+	app.get('/v1/config/models', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			// Get all authorized providers
+			const authorizedProviders = await getAuthorizedProviders(
+				embeddedConfig,
+				cfg,
+			);
+
+			// Build models map
+			const modelsMap: Record<
+				string,
+				{
+					label: string;
+					models: Array<{
+						id: string;
+						label: string;
+						toolCall?: boolean;
+						reasoning?: boolean;
+					}>;
+				}
+			> = {};
+
+			for (const provider of authorizedProviders) {
+				const providerCatalog = catalog[provider];
+				if (providerCatalog) {
+					modelsMap[provider] = {
+						label: providerCatalog.label || provider,
+						models: providerCatalog.models.map((m) => ({
+							id: m.id,
+							label: m.label || m.id,
+							toolCall: m.toolCall,
+							reasoning: m.reasoning,
+						})),
+					};
+				}
+			}
+
+			return c.json(modelsMap);
+		} catch (error) {
+			logger.error('Failed to get all models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
 }

package/src/routes/sessions.ts

@@ -4,7 +4,7 @@ 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 { isProviderId, catalog } from '@agi-cli/sdk';
 import { resolveAgentConfig } from '../runtime/agent-registry.ts';
 import { createSession as createSessionRow } from '../runtime/session-manager.ts';
 import { serializeError } from '../runtime/api-error.ts';
@@ -80,6 +80,117 @@ export function registerSessionsRoutes(app: Hono) {
 		}
 	});
 
+	// Update session preferences
+	app.patch('/v1/sessions/:sessionId', async (c) => {
+		try {
+			const sessionId = c.req.param('sessionId');
+			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
+			>;
+
+			// Fetch existing session
+			const existingRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+
+			if (!existingRows.length) {
+				return c.json({ error: 'Session not found' }, 404);
+			}
+
+			const existingSession = existingRows[0];
+
+			// Verify session belongs to current project
+			if (existingSession.projectPath !== cfg.projectRoot) {
+				return c.json({ error: 'Session not found in this project' }, 404);
+			}
+
+			// Prepare update data
+			const updates: {
+				agent?: string;
+				provider?: string;
+				model?: string;
+				lastActiveAt?: number;
+			} = {
+				lastActiveAt: Date.now(),
+			};
+
+			// Validate agent if provided
+			if (typeof body.agent === 'string') {
+				const agentName = body.agent.trim();
+				if (agentName) {
+					// Agent validation: check if it exists via resolveAgentConfig
+					try {
+						await resolveAgentConfig(cfg.projectRoot, agentName);
+						updates.agent = agentName;
+					} catch (err) {
+						logger.warn('Invalid agent provided', { agent: agentName, err });
+						return c.json({ error: `Invalid agent: ${agentName}` }, 400);
+					}
+				}
+			}
+
+			// Validate provider if provided
+			if (typeof body.provider === 'string') {
+				const providerName = body.provider.trim();
+				if (providerName && isProviderId(providerName)) {
+					updates.provider = providerName;
+				} else if (providerName) {
+					return c.json({ error: `Invalid provider: ${providerName}` }, 400);
+				}
+			}
+
+			// Validate model if provided (and optionally verify it belongs to provider)
+			if (typeof body.model === 'string') {
+				const modelName = body.model.trim();
+				if (modelName) {
+					const targetProvider = (updates.provider ||
+						existingSession.provider) as ProviderId;
+
+					// Check if model exists for the provider
+					const providerCatalog = catalog[targetProvider];
+					if (providerCatalog) {
+						const modelExists = providerCatalog.models.some(
+							(m) => m.id === modelName,
+						);
+						if (!modelExists) {
+							return c.json(
+								{
+									error: `Model "${modelName}" not found for provider "${targetProvider}"`,
+								},
+								400,
+							);
+						}
+					}
+
+					updates.model = modelName;
+				}
+			}
+
+			// Perform update
+			await db.update(sessions).set(updates).where(eq(sessions.id, sessionId));
+
+			// Return updated session
+			const updatedRows = await db
+				.select()
+				.from(sessions)
+				.where(eq(sessions.id, sessionId))
+				.limit(1);
+
+			return c.json(updatedRows[0]);
+		} catch (err) {
+			logger.error('Failed to update session', err);
+			const errorResponse = serializeError(err);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
 	// Abort session stream
 	app.delete('/v1/sessions/:sessionId/abort', async (c) => {
 		const sessionId = c.req.param('sessionId');

package/src/runtime/logger.ts

@@ -45,9 +45,11 @@ export function debug(message: string, meta?: Record<string, unknown>): void {
 }
 
 /**
- * Log informational messages
+ * Log informational messages (only when debug or trace mode is enabled)
  */
 export function info(message: string, meta?: Record<string, unknown>): void {
+	if (!isDebugEnabled() && !isTraceEnabled()) return;
+
 	try {
 		if (meta && Object.keys(meta).length > 0) {
 			console.log(`[info] ${message}`, meta);