@agi-cli/server 0.1.119 → 0.1.121

package/src/runtime/agent/runner.ts

@@ -0,0 +1,356 @@
+import { hasToolCall, streamText } from 'ai';
+import { messageParts } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish, subscribe } from '../../events/bus.ts';
+import { debugLog, time } from '../debug/index.ts';
+import { toErrorPayload } from '../errors/handling.ts';
+import {
+	type RunOpts,
+	setRunning,
+	dequeueJob,
+	cleanupSession,
+} from '../session/queue.ts';
+import {
+	updateSessionTokensIncremental,
+	updateMessageTokensIncremental,
+	completeAssistantMessage,
+	cleanupEmptyTextParts,
+} from '../session/db-operations.ts';
+import {
+	createStepFinishHandler,
+	createErrorHandler,
+	createAbortHandler,
+	createFinishHandler,
+} from '../stream/handlers.ts';
+import { pruneSession } from '../message/compaction.ts';
+import { setupRunner } from './runner-setup.ts';
+import {
+	type ReasoningState,
+	serializeReasoningContent,
+	handleReasoningStart,
+	handleReasoningDelta,
+	handleReasoningEnd,
+} from './runner-reasoning.ts';
+
+export {
+	enqueueAssistantRun,
+	abortSession,
+	abortMessage,
+	removeFromQueue,
+	getQueueState,
+	getRunnerState,
+} from '../session/queue.ts';
+
+export async function runSessionLoop(sessionId: string) {
+	setRunning(sessionId, true);
+
+	while (true) {
+		const job = await 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);
+}
+
+async function runAssistant(opts: RunOpts) {
+	const separator = '='.repeat(72);
+	debugLog(separator);
+	debugLog(
+		`[RUNNER] Starting turn for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
+	);
+
+	const setup = await setupRunner(opts);
+	const {
+		db,
+		history,
+		system,
+		additionalSystemMessages,
+		model,
+		effectiveMaxOutputTokens,
+		toolset,
+		sharedCtx,
+		firstToolTimer,
+		firstToolSeen,
+		providerOptions,
+	} = setup;
+
+	const isFirstMessage = !history.some((m) => m.role === 'assistant');
+
+	const messagesWithSystemInstructions: Array<{
+		role: string;
+		content: string | Array<unknown>;
+	}> = [...additionalSystemMessages, ...history];
+
+	if (!isFirstMessage) {
+		messagesWithSystemInstructions.push({
+			role: 'user',
+			content:
+				'SYSTEM REMINDER: You are continuing an existing session. When you have completed the task, you MUST stream a text summary of what you did to the user, and THEN call the `finish` tool. Do not call `finish` without a summary.',
+		});
+	}
+
+	debugLog(
+		`[RUNNER] messagesWithSystemInstructions length: ${messagesWithSystemInstructions.length}`,
+	);
+
+	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;
+
+	let currentPartId: string | null = null;
+	let accumulated = '';
+	let stepIndex = 0;
+
+	const getCurrentPartId = () => currentPartId;
+	const getStepIndex = () => stepIndex;
+	const updateCurrentPartId = (id: string | null) => {
+		currentPartId = id;
+	};
+	const updateAccumulated = (text: string) => {
+		accumulated = text;
+	};
+	const incrementStepIndex = () => {
+		stepIndex += 1;
+		return stepIndex;
+	};
+
+	const reasoningStates = new Map<string, ReasoningState>();
+
+	const onStepFinish = createStepFinishHandler(
+		opts,
+		db,
+		getStepIndex,
+		incrementStepIndex,
+		getCurrentPartId,
+		updateCurrentPartId,
+		updateAccumulated,
+		sharedCtx,
+		updateSessionTokensIncremental,
+		updateMessageTokensIncremental,
+	);
+
+	const onError = createErrorHandler(
+		opts,
+		db,
+		getStepIndex,
+		sharedCtx,
+		runSessionLoop,
+	);
+
+	const onAbort = createAbortHandler(opts, db, getStepIndex, sharedCtx);
+
+	const onFinish = createFinishHandler(opts, db, completeAssistantMessage);
+
+	try {
+		// biome-ignore lint/suspicious/noExplicitAny: AI SDK message types are complex
+		const result = streamText({
+			model,
+			tools: toolset,
+			...(system ? { system } : {}),
+			messages: messagesWithSystemInstructions as any,
+			...(effectiveMaxOutputTokens
+				? { maxOutputTokens: effectiveMaxOutputTokens }
+				: {}),
+			...(Object.keys(providerOptions).length > 0 ? { providerOptions } : {}),
+			abortSignal: opts.abortSignal,
+			stopWhen: hasToolCall('finish'),
+			onStepFinish: onStepFinish as any,
+			onError: onError as any,
+			onAbort: onAbort as any,
+			onFinish: onFinish as any,
+		} as any);
+
+		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();
+				}
+
+				if (!currentPartId) {
+					currentPartId = crypto.randomUUID();
+					sharedCtx.assistantPartId = currentPartId;
+					await db.insert(messageParts).values({
+						id: currentPartId,
+						messageId: opts.assistantMessageId,
+						index: await 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;
+				await handleReasoningStart(
+					reasoningId,
+					part.providerMetadata,
+					opts,
+					db,
+					sharedCtx,
+					getStepIndex,
+					reasoningStates,
+				);
+				continue;
+			}
+
+			if (part.type === 'reasoning-delta') {
+				await handleReasoningDelta(
+					part.id,
+					part.text,
+					part.providerMetadata,
+					opts,
+					db,
+					getStepIndex,
+					reasoningStates,
+				);
+				continue;
+			}
+
+			if (part.type === 'reasoning-end') {
+				await handleReasoningEnd(part.id, db, reasoningStates);
+			}
+		}
+
+		const fs = firstToolSeen();
+		if (!fs && !_finishObserved) {
+			publish({
+				type: 'finish-step',
+				sessionId: opts.sessionId,
+				payload: { reason: 'no-tool-calls' },
+			});
+		}
+
+		unsubscribeFinish();
+		await cleanupEmptyTextParts(opts, db);
+		firstToolTimer.end({ seen: firstToolSeen() });
+
+		debugLog(
+			`[RUNNER] Stream finished. finishSeen=${_finishObserved}, firstToolSeen=${fs}`,
+		);
+	} catch (err) {
+		unsubscribeFinish();
+		const payload = toErrorPayload(err);
+
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		const errorCode = (err as { code?: string })?.code ?? '';
+		const responseBody = (err as { responseBody?: string })?.responseBody ?? '';
+		const apiErrorType = (err as { apiErrorType?: string })?.apiErrorType ?? '';
+		const combinedError = `${errorMessage} ${responseBody}`.toLowerCase();
+
+		const isPromptTooLong =
+			combinedError.includes('prompt is too long') ||
+			combinedError.includes('maximum context length') ||
+			combinedError.includes('too many tokens') ||
+			combinedError.includes('context_length_exceeded') ||
+			combinedError.includes('request too large') ||
+			combinedError.includes('exceeds the model') ||
+			combinedError.includes('input is too long') ||
+			errorCode === 'context_length_exceeded' ||
+			apiErrorType === 'invalid_request_error';
+
+		debugLog(
+			`[RUNNER] isPromptTooLong: ${isPromptTooLong}, isCompactCommand: ${opts.isCompactCommand}`,
+		);
+
+		if (isPromptTooLong && !opts.isCompactCommand) {
+			debugLog('[RUNNER] Prompt too long - auto-compacting');
+			try {
+				const pruneResult = await pruneSession(db, opts.sessionId);
+				debugLog(
+					`[RUNNER] Auto-pruned ${pruneResult.pruned} parts, saved ~${pruneResult.saved} tokens`,
+				);
+
+				publish({
+					type: 'error',
+					sessionId: opts.sessionId,
+					payload: {
+						...payload,
+						message: `Context too large. Auto-compacted old tool results. Please retry your message.`,
+						name: 'ContextOverflow',
+					},
+				});
+
+				try {
+					await completeAssistantMessage({}, opts, db);
+				} catch {}
+				return;
+			} catch (pruneErr) {
+				debugLog(
+					`[RUNNER] Auto-prune failed: ${pruneErr instanceof Error ? pruneErr.message : String(pruneErr)}`,
+				);
+			}
+		}
+
+		debugLog(`[RUNNER] Error during stream: ${payload.message}`);
+		publish({
+			type: 'error',
+			sessionId: opts.sessionId,
+			payload,
+		});
+
+		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;
+	} finally {
+		debugLog(
+			`[RUNNER] Turn complete for session ${opts.sessionId}, message ${opts.assistantMessageId}`,
+		);
+		debugLog(separator);
+	}
+}

package/src/runtime/agent-registry.ts

@@ -1,333 +1,6 @@
-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_todos',
-		'glob',
-		'ripgrep',
-		'git_status',
-		'terminal',
-		'apply_patch',
-		'websearch',
-	],
-	plan: ['read', 'ls', 'tree', 'ripgrep', 'update_todos', 'websearch'],
-	general: [
-		'read',
-		'write',
-		'ls',
-		'tree',
-		'bash',
-		'ripgrep',
-		'glob',
-		'websearch',
-		'update_todos',
-	],
-	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 summary: ${JSON.stringify({
-			length: prompt.length,
-			lines: prompt.split('\n').length,
-		})}`,
-	);
-	return {
-		name,
-		prompt,
-		tools: deduped,
-		provider,
-		model,
-	};
-}
+// Barrel export for backwards compatibility with @agi-cli/server/runtime/agent-registry
+export {
+	resolveAgentConfig,
+	defaultToolsForAgent,
+	type AgentConfigEntry,
+} from './agent/registry.ts';