@agi-cli/server 0.1.119 → 0.1.121

package/src/runtime/agent/registry.ts

@@ -0,0 +1,333 @@
+import { getGlobalAgentsJsonPath, getGlobalAgentsDir } from '@agi-cli/sdk';
+import { debugLog } from '../debug/index.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,
+	};
+}

package/src/runtime/agent/runner-reasoning.ts

@@ -0,0 +1,108 @@
+import type { getDb } from '@agi-cli/database';
+import { messageParts } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import { publish } from '../../events/bus.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+
+export type ReasoningState = {
+	partId: string;
+	text: string;
+	providerMetadata?: unknown;
+};
+
+export function serializeReasoningContent(state: ReasoningState): string {
+	return JSON.stringify(
+		state.providerMetadata != null
+			? { text: state.text, providerMetadata: state.providerMetadata }
+			: { text: state.text },
+	);
+}
+
+export async function handleReasoningStart(
+	reasoningId: string,
+	providerMetadata: unknown,
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	sharedCtx: ToolAdapterContext,
+	getStepIndex: () => number,
+	reasoningStates: Map<string, ReasoningState>,
+): Promise<void> {
+	const reasoningPartId = crypto.randomUUID();
+	const state: ReasoningState = {
+		partId: reasoningPartId,
+		text: '',
+		providerMetadata,
+	};
+	reasoningStates.set(reasoningId, state);
+	try {
+		await db.insert(messageParts).values({
+			id: reasoningPartId,
+			messageId: opts.assistantMessageId,
+			index: await sharedCtx.nextIndex(),
+			stepIndex: getStepIndex(),
+			type: 'reasoning',
+			content: serializeReasoningContent(state),
+			agent: opts.agent,
+			provider: opts.provider,
+			model: opts.model,
+			startedAt: Date.now(),
+		});
+	} catch {}
+}
+
+export async function handleReasoningDelta(
+	reasoningId: string,
+	text: string,
+	providerMetadata: unknown,
+	opts: RunOpts,
+	db: Awaited<ReturnType<typeof getDb>>,
+	getStepIndex: () => number,
+	reasoningStates: Map<string, ReasoningState>,
+): Promise<void> {
+	const state = reasoningStates.get(reasoningId);
+	if (!state) return;
+	state.text += text;
+	if (providerMetadata != null) {
+		state.providerMetadata = providerMetadata;
+	}
+	publish({
+		type: 'reasoning.delta',
+		sessionId: opts.sessionId,
+		payload: {
+			messageId: opts.assistantMessageId,
+			partId: state.partId,
+			stepIndex: getStepIndex(),
+			delta: text,
+		},
+	});
+	try {
+		await db
+			.update(messageParts)
+			.set({ content: serializeReasoningContent(state) })
+			.where(eq(messageParts.id, state.partId));
+	} catch {}
+}
+
+export async function handleReasoningEnd(
+	reasoningId: string,
+	db: Awaited<ReturnType<typeof getDb>>,
+	reasoningStates: Map<string, ReasoningState>,
+): Promise<void> {
+	const state = reasoningStates.get(reasoningId);
+	if (!state) return;
+	if (!state.text || state.text.trim() === '') {
+		try {
+			await db.delete(messageParts).where(eq(messageParts.id, state.partId));
+		} catch {}
+		reasoningStates.delete(reasoningId);
+		return;
+	}
+	try {
+		await db
+			.update(messageParts)
+			.set({ completedAt: Date.now() })
+			.where(eq(messageParts.id, state.partId));
+	} catch {}
+	reasoningStates.delete(reasoningId);
+}

package/src/runtime/agent/runner-setup.ts

@@ -0,0 +1,265 @@
+import { loadConfig } from '@agi-cli/sdk';
+import { getDb } from '@agi-cli/database';
+import { sessions } from '@agi-cli/database/schema';
+import { eq } from 'drizzle-orm';
+import { resolveModel } from '../provider/index.ts';
+import { resolveAgentConfig } from './registry.ts';
+import {
+	composeSystemPrompt,
+	getProviderSpoofPrompt,
+} from '../prompt/builder.ts';
+import { discoverProjectTools } from '@agi-cli/sdk';
+import { adaptTools } from '../../tools/adapter.ts';
+import { debugLog, time } from '../debug/index.ts';
+import { buildHistoryMessages } from '../message/history-builder.ts';
+import { getMaxOutputTokens } from '../utils/token.ts';
+import { setupToolContext } from '../tools/setup.ts';
+import { getCompactionSystemPrompt } from '../message/compaction.ts';
+import type { RunOpts } from '../session/queue.ts';
+import type { ToolAdapterContext } from '../../tools/adapter.ts';
+
+export interface SetupResult {
+	cfg: Awaited<ReturnType<typeof loadConfig>>;
+	db: Awaited<ReturnType<typeof getDb>>;
+	agentCfg: Awaited<ReturnType<typeof resolveAgentConfig>>;
+	history: Awaited<ReturnType<typeof buildHistoryMessages>>;
+	system: string;
+	systemComponents: string[];
+	additionalSystemMessages: Array<{ role: 'system' | 'user'; content: string }>;
+	model: Awaited<ReturnType<typeof resolveModel>>;
+	maxOutputTokens: number | undefined;
+	effectiveMaxOutputTokens: number | undefined;
+	toolset: ReturnType<typeof adaptTools>;
+	sharedCtx: ToolAdapterContext;
+	firstToolTimer: ReturnType<typeof time>;
+	firstToolSeen: () => boolean;
+	providerOptions: Record<string, unknown>;
+	needsSpoof: boolean;
+}
+
+const THINKING_BUDGET = 16000;
+
+export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
+	const cfgTimer = time('runner:loadConfig+db');
+	const cfg = await loadConfig(opts.projectRoot);
+	const db = await getDb(cfg.projectRoot);
+	cfgTimer.end();
+
+	const agentTimer = time('runner:resolveAgentConfig');
+	const agentCfg = await resolveAgentConfig(cfg.projectRoot, opts.agent);
+	agentTimer.end({ agent: opts.agent });
+
+	const agentPrompt = agentCfg.prompt || '';
+
+	const historyTimer = time('runner:buildHistory');
+	let history: Awaited<ReturnType<typeof buildHistoryMessages>>;
+	if (opts.isCompactCommand && opts.compactionContext) {
+		debugLog('[RUNNER] Using minimal history for /compact command');
+		history = [];
+	} else {
+		history = await buildHistoryMessages(db, opts.sessionId);
+	}
+	historyTimer.end({ messages: history.length });
+
+	const sessionRows = await db
+		.select()
+		.from(sessions)
+		.where(eq(sessions.id, opts.sessionId))
+		.limit(1);
+	const contextSummary = sessionRows[0]?.contextSummary ?? undefined;
+	if (contextSummary) {
+		debugLog(
+			`[RUNNER] Using context summary from compaction (${contextSummary.length} chars)`,
+		);
+	}
+
+	const isFirstMessage = !history.some((m) => m.role === 'assistant');
+
+	debugLog(`[RUNNER] isFirstMessage: ${isFirstMessage}`);
+	debugLog(`[RUNNER] userContext provided: ${opts.userContext ? 'YES' : 'NO'}`);
+	if (opts.userContext) {
+		debugLog(
+			`[RUNNER] userContext value: ${opts.userContext.substring(0, 100)}${opts.userContext.length > 100 ? '...' : ''}`,
+		);
+	}
+
+	const systemTimer = time('runner:composeSystemPrompt');
+	const { getAuth } = await import('@agi-cli/sdk');
+	const auth = await getAuth(opts.provider, cfg.projectRoot);
+	const needsSpoof = auth?.type === 'oauth';
+	const spoofPrompt = needsSpoof
+		? getProviderSpoofPrompt(opts.provider)
+		: undefined;
+
+	debugLog(`[RUNNER] needsSpoof (OAuth): ${needsSpoof}`);
+	debugLog(
+		`[RUNNER] spoofPrompt: ${spoofPrompt ? `present (${opts.provider})` : 'none'}`,
+	);
+
+	let system: string;
+	let systemComponents: string[] = [];
+	let oauthFullPromptComponents: string[] | undefined;
+	let additionalSystemMessages: Array<{
+		role: 'system' | 'user';
+		content: string;
+	}> = [];
+
+	if (spoofPrompt) {
+		system = spoofPrompt;
+		systemComponents = [`spoof:${opts.provider || 'unknown'}`];
+		const fullPrompt = await composeSystemPrompt({
+			provider: opts.provider,
+			model: opts.model,
+			projectRoot: cfg.projectRoot,
+			agentPrompt,
+			oneShot: opts.oneShot,
+			spoofPrompt: undefined,
+			includeProjectTree: isFirstMessage,
+			userContext: opts.userContext,
+			contextSummary,
+		});
+		oauthFullPromptComponents = fullPrompt.components;
+
+		additionalSystemMessages = [{ role: 'system', content: fullPrompt.prompt }];
+
+		debugLog('[RUNNER] OAuth mode: additionalSystemMessages created');
+		const includesUserContext =
+			!!opts.userContext && fullPrompt.prompt.includes(opts.userContext);
+		debugLog(
+			`[system] oauth-full summary: ${JSON.stringify({
+				components: oauthFullPromptComponents ?? [],
+				length: fullPrompt.prompt.length,
+				includesUserContext,
+			})}`,
+		);
+	} else {
+		const composed = await composeSystemPrompt({
+			provider: opts.provider,
+			model: opts.model,
+			projectRoot: cfg.projectRoot,
+			agentPrompt,
+			oneShot: opts.oneShot,
+			spoofPrompt: undefined,
+			includeProjectTree: isFirstMessage,
+			userContext: opts.userContext,
+			contextSummary,
+		});
+		system = composed.prompt;
+		systemComponents = composed.components;
+	}
+	systemTimer.end();
+	debugLog(
+		`[system] summary: ${JSON.stringify({
+			components: systemComponents,
+			length: system.length,
+		})}`,
+	);
+
+	if (opts.isCompactCommand && opts.compactionContext) {
+		debugLog('[RUNNER] Injecting compaction context for /compact command');
+		const compactPrompt = getCompactionSystemPrompt();
+		additionalSystemMessages.push({
+			role: 'system',
+			content: compactPrompt,
+		});
+		additionalSystemMessages.push({
+			role: 'user',
+			content: `Please summarize this conversation:\n\n<conversation-to-summarize>\n${opts.compactionContext}\n</conversation-to-summarize>`,
+		});
+	}
+
+	const toolsTimer = time('runner:discoverTools');
+	const allTools = await discoverProjectTools(cfg.projectRoot);
+	toolsTimer.end({ count: allTools.length });
+	const allowedNames = new Set([...(agentCfg.tools || []), 'finish']);
+	const gated = allTools.filter((tool) => allowedNames.has(tool.name));
+	debugLog(`[tools] ${gated.length} allowed tools`);
+
+	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
+	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);
+
+	const oauthSystemPrompt =
+		needsSpoof && opts.provider === 'openai' && additionalSystemMessages[0]
+			? additionalSystemMessages[0].content
+			: undefined;
+	const model = await resolveModel(opts.provider, opts.model, cfg, {
+		systemPrompt: oauthSystemPrompt,
+	});
+	debugLog(
+		`[RUNNER] Model created: ${JSON.stringify({ id: model.modelId, provider: model.provider })}`,
+	);
+
+	const maxOutputTokens = getMaxOutputTokens(opts.provider, opts.model);
+	debugLog(`[RUNNER] maxOutputTokens for ${opts.model}: ${maxOutputTokens}`);
+
+	const { sharedCtx, firstToolTimer, firstToolSeen } = await setupToolContext(
+		opts,
+		db,
+	);
+
+	const providerAuth = await getAuth(opts.provider, opts.projectRoot);
+	const authType = providerAuth?.type;
+	const toolset = adaptTools(gated, sharedCtx, opts.provider, authType);
+
+	const providerOptions: Record<string, unknown> = {};
+	let effectiveMaxOutputTokens = maxOutputTokens;
+
+	if (opts.reasoning) {
+		if (opts.provider === 'anthropic') {
+			providerOptions.anthropic = {
+				thinking: { type: 'enabled', budgetTokens: THINKING_BUDGET },
+			};
+			if (maxOutputTokens && maxOutputTokens > THINKING_BUDGET) {
+				effectiveMaxOutputTokens = maxOutputTokens - THINKING_BUDGET;
+			}
+		} else if (opts.provider === 'openai') {
+			providerOptions.openai = {
+				reasoningSummary: 'auto',
+			};
+		} else if (opts.provider === 'google') {
+			providerOptions.google = {
+				thinkingConfig: { thinkingBudget: THINKING_BUDGET },
+			};
+		}
+	}
+
+	return {
+		cfg,
+		db,
+		agentCfg,
+		history,
+		system,
+		systemComponents,
+		additionalSystemMessages,
+		model,
+		maxOutputTokens,
+		effectiveMaxOutputTokens,
+		toolset,
+		sharedCtx,
+		firstToolTimer,
+		firstToolSeen,
+		providerOptions,
+		needsSpoof,
+	};
+}
+
+export function buildMessages(
+	additionalSystemMessages: Array<{ role: string; content: string }>,
+	history: Array<{ role: string; content: string | Array<unknown> }>,
+	isFirstMessage: boolean,
+): Array<{ role: string; content: string | Array<unknown> }> {
+	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.',
+		});
+	}
+
+	return messagesWithSystemInstructions;
+}