@agi-cli/server 0.1.55

package/src/runtime/environment.ts

@@ -0,0 +1,131 @@
+import { getHomeDir } from '@agi-cli/sdk';
+
+export async function getEnvironmentContext(
+	projectRoot: string,
+): Promise<string> {
+	const parts: string[] = [];
+
+	parts.push(
+		'Here is some useful information about the environment you are running in:',
+	);
+	parts.push('<env>');
+	parts.push(`  Working directory: ${projectRoot}`);
+
+	try {
+		const { existsSync } = await import('node:fs');
+		const isGitRepo = existsSync(`${projectRoot}/.git`);
+		parts.push(`  Is directory a git repo: ${isGitRepo ? 'yes' : 'no'}`);
+	} catch {
+		parts.push('  Is directory a git repo: unknown');
+	}
+
+	parts.push(`  Platform: ${process.platform}`);
+	parts.push(`  Today's date: ${new Date().toDateString()}`);
+	parts.push('</env>');
+
+	return parts.join('\n');
+}
+
+export async function getProjectTree(projectRoot: string): Promise<string> {
+	try {
+		const { promisify } = await import('node:util');
+		const { exec } = await import('node:child_process');
+		const execAsync = promisify(exec);
+
+		const { stdout } = await execAsync(
+			'git ls-files 2>/dev/null || find . -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" 2>/dev/null | head -100',
+			{ cwd: projectRoot, maxBuffer: 1024 * 1024 },
+		);
+
+		if (!stdout.trim()) return '';
+
+		const files = stdout.trim().split('\n').slice(0, 100);
+		return `<project>\n${files.join('\n')}\n</project>`;
+	} catch {
+		return '';
+	}
+}
+
+export async function findInstructionFiles(
+	projectRoot: string,
+): Promise<string[]> {
+	const { existsSync } = await import('node:fs');
+	const { join } = await import('node:path');
+	const foundPaths: string[] = [];
+
+	const localFiles = ['AGENTS.md', 'CLAUDE.md', 'CONTEXT.md'];
+	for (const filename of localFiles) {
+		let currentDir = projectRoot;
+		for (let i = 0; i < 5; i++) {
+			const filePath = join(currentDir, filename);
+			if (existsSync(filePath)) {
+				foundPaths.push(filePath);
+				break;
+			}
+			const parentDir = join(currentDir, '..');
+			if (parentDir === currentDir) break;
+			currentDir = parentDir;
+		}
+	}
+
+	const homeDir = getHomeDir();
+	const globalFiles = [
+		join(homeDir, '.config', 'agi', 'AGENTS.md'),
+		join(homeDir, '.claude', 'CLAUDE.md'),
+	];
+
+	for (const filePath of globalFiles) {
+		if (existsSync(filePath) && !foundPaths.includes(filePath)) {
+			foundPaths.push(filePath);
+		}
+	}
+
+	return foundPaths;
+}
+
+export async function loadInstructionFiles(
+	projectRoot: string,
+): Promise<string> {
+	const paths = await findInstructionFiles(projectRoot);
+	if (paths.length === 0) return '';
+
+	const contents: string[] = [];
+
+	for (const path of paths) {
+		try {
+			const file = Bun.file(path);
+			const content = await file.text();
+			if (content.trim()) {
+				contents.push(
+					`\n--- Custom Instructions from ${path} ---\n${content.trim()}`,
+				);
+			}
+		} catch {}
+	}
+
+	return contents.join('\n');
+}
+
+export async function composeEnvironmentAndInstructions(
+	projectRoot: string,
+	options?: { includeProjectTree?: boolean },
+): Promise<string> {
+	const parts: string[] = [];
+
+	const envContext = await getEnvironmentContext(projectRoot);
+	parts.push(envContext);
+
+	if (options?.includeProjectTree !== false) {
+		const projectTree = await getProjectTree(projectRoot);
+		if (projectTree) {
+			parts.push(projectTree);
+		}
+	}
+
+	const customInstructions = await loadInstructionFiles(projectRoot);
+	if (customInstructions) {
+		parts.push(customInstructions);
+	}
+
+	return parts.filter(Boolean).join('\n\n');
+}

package/src/runtime/error-handling.ts

@@ -0,0 +1,196 @@
+import { APICallError } from 'ai';
+
+export type ErrorPayload = {
+	message: string;
+	type: string;
+	details?: Record<string, unknown>;
+};
+
+export function toErrorPayload(err: unknown): ErrorPayload {
+	let actualError = err;
+	if (
+		err &&
+		typeof err === 'object' &&
+		'error' in err &&
+		Object.keys(err).length === 1
+	) {
+		actualError = (err as { error: unknown }).error;
+	}
+
+	const asObj =
+		actualError && typeof actualError === 'object'
+			? (actualError as Record<string, unknown>)
+			: undefined;
+	let message = '';
+	let errorType = 'unknown';
+	const details: Record<string, unknown> = {};
+
+	if (APICallError.isInstance(actualError)) {
+		errorType = 'api_error';
+		message = actualError.message || 'API call failed';
+
+		details.name = actualError.name;
+		details.statusCode = actualError.statusCode;
+		details.url = actualError.url;
+		details.isRetryable = actualError.isRetryable;
+
+		if (actualError.responseBody) {
+			details.responseBody = actualError.responseBody;
+			try {
+				const parsed = JSON.parse(actualError.responseBody);
+				if (parsed.error) {
+					if (typeof parsed.error === 'string') {
+						message = parsed.error;
+					} else if (parsed.error.message) {
+						message = parsed.error.message;
+					}
+				}
+				if (parsed.error?.type) {
+					details.apiErrorType = parsed.error.type;
+				}
+			} catch {}
+		}
+
+		if (actualError.requestBodyValues) {
+			details.requestBodyValues = actualError.requestBodyValues;
+		}
+
+		if (actualError.responseHeaders) {
+			details.responseHeaders = actualError.responseHeaders;
+		}
+
+		if (actualError.cause) {
+			const cause = actualError.cause as Record<string, unknown> | undefined;
+			details.cause = {
+				message: typeof cause?.message === 'string' ? cause.message : undefined,
+				code: cause?.code,
+				status: cause?.status ?? cause?.statusCode,
+			};
+		}
+
+		return { message, type: errorType, details };
+	}
+
+	if (
+		asObj &&
+		'type' in asObj &&
+		asObj.type === 'error' &&
+		'error' in asObj &&
+		typeof asObj.error === 'object' &&
+		asObj.error
+	) {
+		const errorObj = asObj.error as Record<string, unknown>;
+
+		if (typeof errorObj.message === 'string') {
+			message = errorObj.message;
+		}
+		if (typeof errorObj.type === 'string') {
+			errorType = errorObj.type;
+			details.errorType = errorObj.type;
+		}
+		if (typeof errorObj.code === 'string') {
+			details.code = errorObj.code;
+		}
+		if ('param' in errorObj) {
+			details.param = errorObj.param;
+		}
+
+		return { message, type: errorType, details };
+	}
+
+	if (asObj) {
+		if ('name' in asObj && typeof asObj.name === 'string') {
+			errorType = asObj.name;
+			details.name = asObj.name;
+		}
+
+		if ('type' in asObj && typeof asObj.type === 'string') {
+			errorType = asObj.type;
+			details.type = asObj.type;
+		}
+
+		if ('code' in asObj && asObj.code != null) {
+			details.code = asObj.code;
+		}
+
+		if ('status' in asObj && asObj.status != null) {
+			details.status = asObj.status;
+		}
+
+		if ('statusCode' in asObj && asObj.statusCode != null) {
+			details.statusCode = asObj.statusCode;
+		}
+	}
+
+	if (asObj && typeof asObj.message === 'string' && asObj.message) {
+		message = asObj.message;
+	} else if (typeof actualError === 'string') {
+		message = actualError;
+	} else if (asObj && typeof asObj.error === 'string' && asObj.error) {
+		message = asObj.error;
+	} else if (
+		asObj &&
+		typeof asObj.responseBody === 'string' &&
+		asObj.responseBody
+	) {
+		details.responseBody = asObj.responseBody;
+		try {
+			const parsed = JSON.parse(asObj.responseBody);
+			if (parsed.error) {
+				if (typeof parsed.error === 'string') {
+					message = parsed.error;
+				} else if (typeof parsed.error.message === 'string') {
+					message = parsed.error.message;
+				} else {
+					message = asObj.responseBody;
+				}
+			} else {
+				message = asObj.responseBody;
+			}
+		} catch {
+			message = asObj.responseBody;
+		}
+	} else if (asObj?.statusCode && asObj.url) {
+		message = `HTTP ${String(asObj.statusCode)} error at ${String(asObj.url)}`;
+		details.url = asObj.url;
+	} else if (asObj?.name) {
+		message = String(asObj.name);
+	} else {
+		message = 'An error occurred';
+	}
+
+	if (asObj) {
+		if ('url' in asObj) details.url = asObj.url;
+		if ('isRetryable' in asObj) details.isRetryable = asObj.isRetryable;
+		if ('data' in asObj) details.data = asObj.data;
+
+		if (asObj.cause) {
+			const c = asObj.cause as Record<string, unknown> | undefined;
+			details.cause = {
+				message: typeof c?.message === 'string' ? c.message : undefined,
+				code: c?.code,
+				status: c?.status ?? c?.statusCode,
+			};
+		}
+
+		if (
+			(asObj as { response?: { status?: unknown; statusText?: unknown } })
+				?.response?.status
+		) {
+			details.response = {
+				status: (
+					asObj as { response?: { status?: unknown; statusText?: unknown } }
+				).response?.status,
+				statusText: (
+					asObj as { response?: { status?: unknown; statusText?: unknown } }
+				).response?.statusText,
+			};
+		}
+	}
+
+	return {
+		message,
+		type: errorType,
+		details: Object.keys(details).length ? details : undefined,
+	};
+}

package/src/runtime/history-builder.ts

@@ -0,0 +1,156 @@
+import { convertToModelMessages, type ModelMessage, type UIMessage } from 'ai';
+import type { getDb } from '@agi-cli/database';
+import { messages, messageParts } from '@agi-cli/database/schema';
+import { eq, asc } from 'drizzle-orm';
+import { debugLog } from './debug.ts';
+
+/**
+ * Builds the conversation history for a session from the database,
+ * converting it to the format expected by the AI SDK.
+ */
+export async function buildHistoryMessages(
+	db: Awaited<ReturnType<typeof getDb>>,
+	sessionId: string,
+): Promise<ModelMessage[]> {
+	const rows = await db
+		.select()
+		.from(messages)
+		.where(eq(messages.sessionId, sessionId))
+		.orderBy(asc(messages.createdAt));
+
+	const ui: UIMessage[] = [];
+
+	for (const m of rows) {
+		const parts = await db
+			.select()
+			.from(messageParts)
+			.where(eq(messageParts.messageId, m.id))
+			.orderBy(asc(messageParts.index));
+
+		if (m.role === 'user') {
+			const uparts: UIMessage['parts'] = [];
+			for (const p of parts) {
+				if (p.type !== 'text') continue;
+				try {
+					const obj = JSON.parse(p.content ?? '{}');
+					const t = String(obj.text ?? '');
+					if (t) uparts.push({ type: 'text', text: t });
+				} catch {}
+			}
+			if (uparts.length) {
+				ui.push({ id: m.id, role: 'user', parts: uparts });
+			}
+			continue;
+		}
+
+		if (m.role === 'assistant') {
+			const assistantParts: UIMessage['parts'] = [];
+			const toolCalls: Array<{ name: string; callId: string; args: unknown }> =
+				[];
+			const toolResults: Array<{
+				name: string;
+				callId: string;
+				result: unknown;
+			}> = [];
+
+			for (const p of parts) {
+				if (p.type === 'text') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}');
+						const t = String(obj.text ?? '');
+						if (t) assistantParts.push({ type: 'text', text: t });
+					} catch {}
+				} else if (p.type === 'tool_call') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}') as {
+							name?: string;
+							callId?: string;
+							args?: unknown;
+						};
+						if (obj.callId && obj.name) {
+							toolCalls.push({
+								name: obj.name,
+								callId: obj.callId,
+								args: obj.args,
+							});
+						}
+					} catch {}
+				} else if (p.type === 'tool_result') {
+					try {
+						const obj = JSON.parse(p.content ?? '{}') as {
+							name?: string;
+							callId?: string;
+							result?: unknown;
+						};
+						if (obj.callId) {
+							toolResults.push({
+								name: obj.name ?? 'tool',
+								callId: obj.callId,
+								result: obj.result,
+							});
+						}
+					} catch {}
+				}
+				// Skip error parts in history
+			}
+
+			const hasIncompleteTools = toolCalls.some(
+				(call) => !toolResults.find((result) => result.callId === call.callId),
+			);
+
+			if (hasIncompleteTools) {
+				debugLog(
+					`[buildHistoryMessages] Incomplete tool calls for assistant message ${m.id}, pushing text only`,
+				);
+				if (assistantParts.length) {
+					ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
+				}
+				continue;
+			}
+
+			for (const call of toolCalls) {
+				const toolType = `tool-${call.name}` as `tool-${string}`;
+				const result = toolResults.find((r) => r.callId === call.callId);
+
+				if (result) {
+					const outputStr = (() => {
+						const r = result.result;
+						if (typeof r === 'string') return r;
+						try {
+							return JSON.stringify(r);
+						} catch {
+							return String(r);
+						}
+					})();
+
+					assistantParts.push({
+						type: toolType,
+						state: 'output-available',
+						toolCallId: call.callId,
+						input: call.args,
+						output: outputStr,
+					} as never);
+				}
+			}
+
+			if (assistantParts.length) {
+				ui.push({ id: m.id, role: 'assistant', parts: assistantParts });
+
+				if (toolResults.length) {
+					const userParts: UIMessage['parts'] = toolResults.map((r) => {
+						const out =
+							typeof r.result === 'string'
+								? r.result
+								: JSON.stringify(r.result);
+						return { type: 'text', text: out };
+					});
+					if (userParts.length) {
+						ui.push({ id: m.id, role: 'user', parts: userParts });
+					}
+				}
+			}
+		}
+	}
+
+	return convertToModelMessages(ui);
+}