@zihanw/pi-forge 0.2.0 → 0.3.1

package/src/compiler.ts

@@ -1,5 +1,6 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type {
+	CompileMessageSource,
 	CompileMessagesResult,
 	CompileSystemPromptResult,
 	PromptRuntime,
@@ -8,11 +9,12 @@ import type {
 	PromptStackItem,
 	PromptStackRole,
 	PromptStackSlotItem,
-	PromptStateScope,
-	PromptStateValue,
+	PromptVariableValue,
 	PromptVariableStore,
 } from "./types.ts";
-import { SUPPORTED_SLOTS } from "./types.ts";
+import { applyRegexRulesToMessages, applyRegexRulesToString } from "./regex.ts";
+import { expandMacros } from "./macro-engine.ts";
+import { renderSlotText } from "./slot-renderers.ts";
 
 const ZERO_USAGE = {
 	input: 0,
@@ -23,7 +25,9 @@ const ZERO_USAGE = {
 	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
 
-export function createPromptVariableStore(sessionVariables: Record<string, PromptStateValue> = {}): PromptVariableStore {
+const SUMMARY_ROLES = new Set(["branchSummary", "compactionSummary"]);
+
+export function createPromptVariableStore(sessionVariables: Record<string, PromptVariableValue> = {}): PromptVariableStore {
 	return { turn: {}, session: { ...sessionVariables }, sessionDirty: false };
 }
 
@@ -65,20 +69,20 @@ export function compileSystemPrompt(
 	const compiled = parts.join("\n\n");
 	const mode = stack.mode ?? "replace";
 
+	let systemPrompt: string;
 	if (!compiled) {
 		diagnostics.push({ level: "warning", message: "Compiled system prompt is empty; preserving base system prompt." });
-		return { systemPrompt: baseSystemPrompt, diagnostics };
-	}
-
-	if (mode === "append") {
-		return { systemPrompt: compiled ? `${baseSystemPrompt}\n\n${compiled}` : baseSystemPrompt, diagnostics };
-	}
-
-	if (mode === "prepend") {
-		return { systemPrompt: compiled ? `${compiled}\n\n${baseSystemPrompt}` : baseSystemPrompt, diagnostics };
+		systemPrompt = baseSystemPrompt;
+	} else if (mode === "append") {
+		systemPrompt = compiled ? `${baseSystemPrompt}\n\n${compiled}` : baseSystemPrompt;
+	} else if (mode === "prepend") {
+		systemPrompt = compiled ? `${compiled}\n\n${baseSystemPrompt}` : baseSystemPrompt;
+	} else {
+		systemPrompt = compiled;
 	}
 
-	return { systemPrompt: compiled, diagnostics };
+	systemPrompt = applyRegexRulesToString(stack, systemPrompt, "compiled", "system", diagnostics);
+	return { systemPrompt, diagnostics };
 }
 
 export function compileMessages(
@@ -87,7 +91,8 @@ export function compileMessages(
 	originalMessages: AgentMessage[],
 ): CompileMessagesResult {
 	const diagnostics: PromptStackDiagnostic[] = [];
-	const messages: AgentMessage[] = [];
+	let messages: AgentMessage[] = [];
+	let messageSources: CompileMessageSource[] = [];
 	let insertedHistory = false;
 
 	for (const item of enabledItems(stack)) {
@@ -100,7 +105,10 @@ export function compileMessages(
 				});
 				continue;
 			}
-			messages.push(...getChatHistoryMessages(originalMessages, item));
+			const historyMessages = getChatHistoryMessages(originalMessages, item, diagnostics);
+			const transformedHistory = applyRegexRulesToMessages(stack, historyMessages, "history", diagnostics);
+			messages.push(...transformedHistory);
+			messageSources.push(...chatHistoryMessageSources(transformedHistory, item));
 			insertedHistory = true;
 			continue;
 		}
@@ -112,14 +120,18 @@ export function compileMessages(
 			: renderSlotText(item, stack, runtime, diagnostics);
 
 		if (!content.trim()) continue;
-		messages.push(createSyntheticMessage(item.role, content, stack, runtime));
+		const message = createSyntheticMessage(item.role, content, stack, runtime);
+		messages.push(message);
+		messageSources.push(stackItemMessageSource(message, item));
 	}
 
 	if (!insertedHistory) {
 		messages.push(...originalMessages);
+		messageSources.push(...implicitHistoryMessageSources(originalMessages));
 	}
 
-	return { messages, diagnostics };
+	messages = applyRegexRulesToMessages(stack, messages, "compiled", diagnostics);
+	return { messages, messageSources, diagnostics };
 }
 
 export function getLatestUserMessage(messages: AgentMessage[]): string | undefined {
@@ -133,470 +145,382 @@ export function getLatestUserMessage(messages: AgentMessage[]): string | undefin
 	return undefined;
 }
 
-export function renderPreviewMessages(messages: AgentMessage[], maxChars = 8000): string {
-	let text = "";
-	for (const message of messages) {
-		const role = message.role;
-		text += `\n--- ${role} ---\n`;
-		text += contentToText((message as { content?: unknown; summary?: string; command?: string; output?: string }).content);
-		if (role === "bashExecution") {
-			const bash = message as { command?: string; output?: string };
-			text += `Ran ${bash.command ?? ""}\n${bash.output ?? ""}`;
-		}
-		if (role === "branchSummary" || role === "compactionSummary") {
-			text += (message as { summary?: string }).summary ?? "";
-		}
-		text += "\n";
-		if (text.length > maxChars) return `${text.slice(0, maxChars)}\n\n[preview truncated]`;
+export function agentMessageToPreviewText(message: AgentMessage): string {
+	let text = contentToText((message as { content?: unknown; summary?: string; command?: string; output?: string }).content);
+	const role = message.role;
+	if (role === "bashExecution") {
+		const bash = message as { command?: string; output?: string };
+		text += `Ran ${bash.command ?? ""}\n${bash.output ?? ""}`;
 	}
-	return text.trimStart();
-}
-
-function getChatHistoryMessages(messages: AgentMessage[], item: PromptStackSlotItem): AgentMessage[] {
-	if (item.options?.includeLastUserMessage !== false) return messages;
-
-	const lastUserIndex = findLastUserMessageIndex(messages);
-	if (lastUserIndex === -1) return messages;
-
-	return messages.filter((_message, index) => index !== lastUserIndex);
-}
-
-function findLastUserMessageIndex(messages: AgentMessage[]): number {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		if (messages[i].role === "user") return i;
+	if (role === "branchSummary" || role === "compactionSummary") {
+		text += (message as { summary?: string }).summary ?? "";
 	}
-	return -1;
-}
-
-function enabledItems(stack: PromptStack): PromptStackItem[] {
-	return stack.items.filter((item) => item.enabled !== false);
+	return text;
 }
 
-function renderSlotText(
+function getChatHistoryMessages(
+	messages: AgentMessage[],
 	item: PromptStackSlotItem,
-	stack: PromptStack,
-	runtime: PromptRuntime,
 	diagnostics: PromptStackDiagnostic[],
-): string {
-	const slot = item.slot;
+): AgentMessage[] {
+	let result = messages;
+	const options = item.options ?? {};
+	let shouldRepairToolPairs = false;
 
-	if (!SUPPORTED_SLOTS.has(slot as any)) {
-		diagnostics.push({ level: "warning", message: `Unsupported slot: ${slot}`, itemId: item.id });
-		return "";
+	if (options.includeLastUserMessage === false) {
+		const lastUserIndex = findLastUserMessageIndex(result);
+		if (lastUserIndex !== -1) result = result.filter((_message, index) => index !== lastUserIndex);
 	}
 
-	switch (slot) {
-		case "tools":
-			return renderTools(runtime);
-		case "tool-guidelines":
-			return renderToolGuidelines(runtime);
-		case "skills":
-			return renderSkills(runtime);
-		case "project-context":
-			return renderProjectContext(runtime);
-		case "append-system-prompt":
-			return runtime.options.appendSystemPrompt ?? "";
-		case "date":
-			return `Current date: ${formatDate(runtime.now)}`;
-		case "cwd":
-			return `Current working directory: ${runtime.options.cwd.replace(/\\/g, "/")}`;
-		case "date-cwd":
-			return [`Current date: ${formatDate(runtime.now)}`, `Current working directory: ${runtime.options.cwd.replace(/\\/g, "/")}`].join("\n");
-		case "active-model": {
-			const model = runtime.ctx?.model;
-			return model ? `Current model: ${model.provider}/${model.id}` : "Current model: (none)";
-		}
-		case "pi-docs":
-			return renderPiDocsGuidance();
-		case "variables":
-			return renderVariables(item, stack, runtime);
-		case "chat-history":
-			return "";
-		default:
-			return "";
+	if (options.includeSummaries === false) {
+		const next = result.filter((message) => !isSummaryMessage(message));
+		addHistoryFilterDiagnostic(diagnostics, item.id, "summary", result.length, next.length);
+		result = next;
 	}
-}
 
-function renderTools(runtime: PromptRuntime): string {
-	const tools = runtime.options.selectedTools ?? [];
-	const snippets = runtime.options.toolSnippets ?? {};
-	const lines = ["<available_tools>"];
+	if (isStringArray(options.roles) && options.roles.length > 0) {
+		const allowedRoles = new Set(options.roles);
+		const next = result.filter((message) => allowedRoles.has(messageRole(message)));
+		addHistoryFilterDiagnostic(diagnostics, item.id, "role", result.length, next.length);
+		result = next;
+		shouldRepairToolPairs = true;
+	}
 
-	if (tools.length === 0) {
-		lines.push("  (none)");
-	} else {
-		for (const name of tools) {
-			const snippet = snippets[name] ?? "No prompt snippet provided.";
-			lines.push(`  <tool name=\"${escapeXml(name)}\">${escapeXml(snippet)}</tool>`);
-		}
+	if (options.toolMode === "drop") {
+		result = dropToolHistory(result, diagnostics, item.id);
+	} else if (options.toolMode !== undefined && options.toolMode !== "keep") {
+		diagnostics.push({ level: "warning", message: `Unsupported chat-history toolMode: ${String(options.toolMode)}.`, itemId: item.id });
 	}
 
-	lines.push("</available_tools>");
-	return lines.join("\n");
-}
+	if (options.stripAssistantThinking === true) {
+		result = stripAssistantThinkingFromHistory(result, diagnostics, item.id);
+	}
 
-function renderToolGuidelines(runtime: PromptRuntime): string {
-	const tools = runtime.options.selectedTools ?? [];
-	const guidelines: string[] = [];
-	const seen = new Set<string>();
-	const add = (line: string) => {
-		const normalized = line.trim();
-		if (!normalized || seen.has(normalized)) return;
-		seen.add(normalized);
-		guidelines.push(normalized);
-	};
+	const limited = limitChatHistory(result, options, diagnostics, item.id);
+	if (limited !== result) {
+		result = limited;
+		shouldRepairToolPairs = true;
+	}
 
-	if (tools.includes("bash") && !tools.includes("grep") && !tools.includes("find") && !tools.includes("ls")) {
-		add("Use bash for file operations like ls, rg, find.");
+	if (shouldRepairToolPairs && options.toolMode !== "drop") {
+		result = repairToolHistory(result, diagnostics, item.id);
 	}
 
-	for (const guideline of runtime.options.promptGuidelines ?? []) add(guideline);
+	return result;
+}
 
-	if (guidelines.length === 0) return "";
-	return ["<tool_guidelines>", ...guidelines.map((line) => `- ${line}`), "</tool_guidelines>"].join("\n");
+function findLastUserMessageIndex(messages: AgentMessage[]): number {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (messages[i].role === "user") return i;
+	}
+	return -1;
 }
 
-function renderSkills(runtime: PromptRuntime): string {
-	const skills = (runtime.options.skills ?? []).filter((skill) => !skill.disableModelInvocation);
-	if (skills.length === 0) return "";
+function limitChatHistory(
+	messages: AgentMessage[],
+	options: NonNullable<PromptStackSlotItem["options"]>,
+	diagnostics: PromptStackDiagnostic[],
+	itemId: string,
+): AgentMessage[] {
+	let result = messages;
+	const maxMessages = positiveIntegerOption(options.maxMessages);
+	const maxChars = positiveIntegerOption(options.maxChars);
 
-	const lines = [
-		"The following skills provide specialized instructions for specific tasks.",
-		"Use the read tool to load a skill's file when the task matches its description.",
-		"When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
-		"",
-		"<available_skills>",
-	];
+	if (maxMessages !== undefined && result.length > maxMessages) {
+		const next = result.slice(-maxMessages);
+		diagnostics.push({
+			level: "info",
+			message: `Trimmed chat history from ${result.length} to ${next.length} message(s) by maxMessages.`,
+			itemId,
+		});
+		result = next;
+	}
 
-	for (const skill of skills) {
-		lines.push("  <skill>");
-		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-		lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
-		lines.push("  </skill>");
+	if (maxChars !== undefined) {
+		const next = takeRecentMessagesWithinChars(result, maxChars);
+		if (next.length < result.length) {
+			diagnostics.push({
+				level: "info",
+				message: `Trimmed chat history from ${result.length} to ${next.length} message(s) by maxChars.`,
+				itemId,
+			});
+			result = next;
+		}
 	}
 
-	lines.push("</available_skills>");
-	return lines.join("\n");
+	return result;
 }
 
-function renderProjectContext(runtime: PromptRuntime): string {
-	const contextFiles = runtime.options.contextFiles ?? [];
-	if (contextFiles.length === 0) return "";
-
-	const lines = ["<project_context>", "", "Project-specific instructions and guidelines:", ""];
-	for (const file of contextFiles) {
-		lines.push(`<project_instructions path=\"${escapeXml(file.path)}\">`);
-		lines.push(file.content);
-		lines.push("</project_instructions>", "");
+function takeRecentMessagesWithinChars(messages: AgentMessage[], maxChars: number): AgentMessage[] {
+	const selected: AgentMessage[] = [];
+	let chars = 0;
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		const messageChars = agentMessageToPreviewText(message).length;
+		if (selected.length > 0 && chars + messageChars > maxChars) break;
+		selected.push(message);
+		chars += messageChars;
 	}
-	lines.push("</project_context>");
-	return lines.join("\n");
+	return selected.reverse();
 }
 
-function renderPiDocsGuidance(): string {
-	return [
-		"Pi documentation guidance:",
-		"- Read Pi documentation only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI.",
-		"- Resolve docs/... against Pi's installed documentation directory and examples/... against Pi's installed examples directory.",
-	].join("\n");
+function addHistoryFilterDiagnostic(
+	diagnostics: PromptStackDiagnostic[],
+	itemId: string,
+	filter: string,
+	before: number,
+	after: number,
+): void {
+	if (before === after) return;
+	diagnostics.push({
+		level: "info",
+		message: `Filtered ${before - after} chat-history message(s) by ${filter}.`,
+		itemId,
+	});
 }
 
-function renderVariables(
-	item: PromptStackSlotItem,
-	stack: PromptStack,
-	runtime: PromptRuntime,
-): string {
-	const options = item.options ?? {};
-	const scopes = selectedVariableScopes(options);
-	const includeMetadata = options.includeMetadata === true;
-	const format = options.format === "json" ? "json" : "xml";
-	const includeNamespaces = normalizeStringArray(options.includeNamespaces);
-	const excludeNamespaces = normalizeStringArray(options.excludeNamespaces);
-	const maxValueChars = typeof options.maxValueChars === "number" && Number.isFinite(options.maxValueChars) && options.maxValueChars > 0
-		? Math.floor(options.maxValueChars)
-		: undefined;
-	const store = runtime.variables;
-	const grouped: Record<PromptStateScope, Record<string, PromptStateValue>> = {
-		static: {},
-		session: {},
-		turn: {},
-	};
+function dropToolHistory(
+	messages: AgentMessage[],
+	diagnostics: PromptStackDiagnostic[],
+	itemId: string,
+): AgentMessage[] {
+	let removedToolCalls = 0;
+	let droppedToolResults = 0;
+	let droppedEmptyMessages = 0;
+	let changed = false;
+	const result: AgentMessage[] = [];
 
-	if (scopes.has("static")) {
-		grouped.static = collectStaticVariables(stack);
-	}
-	if (scopes.has("session")) {
-		grouped.session = { ...collectDefaultVariables(stack, "session"), ...(store?.session ?? {}) };
-	}
-	if (scopes.has("turn")) {
-		grouped.turn = { ...collectDefaultVariables(stack, "turn"), ...(store?.turn ?? {}) };
+	for (const message of messages) {
+		if (isToolResultMessage(message)) {
+			droppedToolResults++;
+			changed = true;
+			continue;
+		}
+		const stripped = stripToolCallParts(message, () => false);
+		removedToolCalls += stripped.removedCalls;
+		if (stripped.message !== message) changed = true;
+		if (!stripped.message) {
+			droppedEmptyMessages++;
+			continue;
+		}
+		result.push(stripped.message);
 	}
 
-	for (const scope of ["static", "session", "turn"] as const) {
-		grouped[scope] = Object.fromEntries(
-			Object.entries(grouped[scope]).filter(([name]) => shouldRenderVariable(name, includeNamespaces, excludeNamespaces)),
-		);
+	if (!changed) return messages;
+	diagnostics.push({
+		level: "info",
+		message: `Dropped tool history from chat-history: removed ${removedToolCalls} tool call(s), dropped ${droppedToolResults} tool result message(s)` +
+			(droppedEmptyMessages > 0 ? `, and dropped ${droppedEmptyMessages} empty message(s).` : "."),
+		itemId,
+	});
+	return result;
+}
+
+function repairToolHistory(
+	messages: AgentMessage[],
+	diagnostics: PromptStackDiagnostic[],
+	itemId: string,
+): AgentMessage[] {
+	const includedCallIds = new Set<string>();
+	const includedResultIds = new Set<string>();
+	for (const message of messages) {
+		for (const id of toolCallIdsForMessage(message)) includedCallIds.add(id);
+		const resultId = toolResultMessageId(message);
+		if (resultId) includedResultIds.add(resultId);
 	}
 
-	if (!Object.values(grouped).some((values) => Object.keys(values).length > 0)) return "";
-
-	if (format === "json") {
-		const payload: Record<string, unknown> = {};
-		for (const scope of ["static", "session", "turn"] as const) {
-			if (Object.keys(grouped[scope]).length === 0) continue;
-			payload[scope] = includeMetadata
-				? Object.fromEntries(Object.entries(grouped[scope]).sort(([a], [b]) => a.localeCompare(b)).map(([name, value]) => [
-					name,
-					{
-						value,
-						...metadataForVariable(stack, name),
-					},
-				]))
-				: Object.fromEntries(Object.entries(grouped[scope]).sort(([a], [b]) => a.localeCompare(b)));
+	let removedToolCalls = 0;
+	let droppedToolResults = 0;
+	let droppedEmptyMessages = 0;
+	let changed = false;
+	const result: AgentMessage[] = [];
+
+	for (const message of messages) {
+		if (isToolResultMessage(message)) {
+			const resultId = toolResultMessageId(message);
+			if (!resultId || !includedCallIds.has(resultId)) {
+				droppedToolResults++;
+				changed = true;
+				continue;
+			}
+			result.push(message);
+			continue;
 		}
-		return `<prompt_state format=\"json\">\n${escapeXml(JSON.stringify(payload, null, 2))}\n</prompt_state>`;
-	}
 
-	const parts: string[] = ["<prompt_state>"];
-
-	for (const scope of ["static", "session", "turn"] as const) {
-		const entries = Object.entries(grouped[scope]).sort(([a], [b]) => a.localeCompare(b));
-		if (entries.length === 0) continue;
-		parts.push(`  <${scope}>`);
-		for (const [name, value] of entries) {
-			const metadata = includeMetadata ? metadataForVariable(stack, name) : {};
-			const attrs = [
-				`name=\"${escapeXml(name)}\"`,
-				`type=\"${escapeXml(metadata.type ?? inferStateValueType(value))}\"`,
-			];
-			if (metadata.description) attrs.push(`description=\"${escapeXml(metadata.description)}\"`);
-			if (metadata.agentWritable !== undefined) attrs.push(`agentWritable=\"${metadata.agentWritable ? "true" : "false"}\"`);
-			if (metadata.userWritable !== undefined) attrs.push(`userWritable=\"${metadata.userWritable ? "true" : "false"}\"`);
-			parts.push(`    <var ${attrs.join(" ")}>${escapeXml(truncateValue(stateValueToPromptText(value), maxValueChars))}</var>`);
+		const stripped = stripToolCallParts(message, (id) => !!id && includedResultIds.has(id));
+		removedToolCalls += stripped.removedCalls;
+		if (stripped.message !== message) changed = true;
+		if (!stripped.message) {
+			droppedEmptyMessages++;
+			continue;
 		}
-		parts.push(`  </${scope}>`);
+		result.push(stripped.message);
 	}
 
-	parts.push("</prompt_state>");
-	return parts.join("\n");
+	if (!changed) return messages;
+	diagnostics.push({
+		level: "info",
+		message: `Repaired tool history after chat-history filtering: removed ${removedToolCalls} dangling tool call(s), dropped ${droppedToolResults} dangling tool result message(s)` +
+			(droppedEmptyMessages > 0 ? `, and dropped ${droppedEmptyMessages} empty message(s).` : "."),
+		itemId,
+	});
+	return result;
+}
+
+function stripToolCallParts(
+	message: AgentMessage,
+	keep: (id: string | undefined) => boolean,
+): { message?: AgentMessage; removedCalls: number } {
+	const content = (message as { content?: unknown }).content;
+	if (!Array.isArray(content)) return { message, removedCalls: 0 };
+
+	const nextContent = content.filter((part) => !isToolCallContent(part) || keep(toolCallPartId(part)));
+	const removedCalls = content.length - nextContent.length;
+	if (removedCalls === 0) return { message, removedCalls: 0 };
+	if (nextContent.length === 0) return { removedCalls };
+	return { message: { ...message, content: nextContent } as AgentMessage, removedCalls };
 }
 
-function selectedVariableScopes(options: Record<string, unknown>): Set<PromptStateScope> {
-	const explicit = normalizeStringArray(options.includeScopes).filter(isStateScope);
-	if (explicit.length > 0) return new Set(explicit);
+function toolCallIdsForMessage(message: AgentMessage): string[] {
+	const content = (message as { content?: unknown }).content;
+	if (!Array.isArray(content)) return [];
+	return content
+		.map((part) => toolCallPartId(part))
+		.filter((id): id is string => !!id);
+}
 
-	const scopes = new Set<PromptStateScope>();
-	if (options.includeStatic !== false) scopes.add("static");
-	if (options.includeSession !== false) scopes.add("session");
-	if (options.includeTurn !== false) scopes.add("turn");
-	return scopes;
+function isToolCallContent(value: unknown): boolean {
+	return isPlainObject(value) && value.type === "toolCall";
 }
 
-function collectStaticVariables(stack: PromptStack): Record<string, PromptStateValue> {
-	return {
-		...collectDefaultVariables(stack, "static"),
-		...(stack.variables ?? {}),
-	};
+function toolCallPartId(value: unknown): string | undefined {
+	if (!isPlainObject(value)) return undefined;
+	return firstString(value.id, value.toolCallId, value.callId);
 }
 
-function collectDefaultVariables(stack: PromptStack, scope: PromptStateScope): Record<string, PromptStateValue> {
-	const values: Record<string, PromptStateValue> = {};
-	for (const [name, definition] of Object.entries(stack.state?.definitions ?? {})) {
-		if ((definition.scope ?? "session") !== scope) continue;
-		if (definition.default !== undefined) values[name] = definition.default;
-	}
-	return values;
+function isToolResultMessage(message: AgentMessage): boolean {
+	return messageRole(message) === "toolResult";
 }
 
-function shouldRenderVariable(name: string, includePatterns: string[], excludePatterns: string[]): boolean {
-	if (includePatterns.length > 0 && !includePatterns.some((pattern) => matchesNamespace(name, pattern))) return false;
-	if (excludePatterns.some((pattern) => matchesNamespace(name, pattern))) return false;
-	return true;
+function toolResultMessageId(message: AgentMessage): string | undefined {
+	if (!isToolResultMessage(message)) return undefined;
+	const raw = message as unknown as Record<string, unknown>;
+	return firstString(raw.toolCallId, raw.id, raw.callId);
 }
 
-function matchesNamespace(name: string, pattern: string): boolean {
-	if (!pattern) return false;
-	if (pattern.endsWith("*")) return name.startsWith(pattern.slice(0, -1));
-	return name === pattern;
+function isSummaryMessage(message: AgentMessage): boolean {
+	return SUMMARY_ROLES.has(messageRole(message));
 }
 
-function metadataForVariable(stack: PromptStack, name: string): {
-	type?: string;
-	description?: string;
-	agentWritable?: boolean;
-	userWritable?: boolean;
-} {
-	const definition = stack.state?.definitions?.[name];
-	if (!definition) return {};
-	return {
-		type: definition.type,
-		description: definition.description,
-		agentWritable: definition.agentWritable,
-		userWritable: definition.userWritable,
-	};
+function messageRole(message: AgentMessage): string {
+	return String((message as { role?: unknown }).role ?? "");
 }
 
-function normalizeStringArray(value: unknown): string[] {
-	return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
+function positiveIntegerOption(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
 }
 
-function isStateScope(value: string): value is PromptStateScope {
-	return value === "static" || value === "session" || value === "turn";
+function firstString(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value === "string" && value) return value;
+	}
+	return undefined;
 }
 
-function inferStateValueType(value: PromptStateValue): string {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "array";
-	return typeof value;
+function isStringArray(value: unknown): value is string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
 
-function truncateValue(value: string, maxChars: number | undefined): string {
-	if (!maxChars || value.length <= maxChars) return value;
-	return `${value.slice(0, maxChars)}\n[truncated]`;
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
-function stateValueToPromptText(value: PromptStateValue): string {
-	if (typeof value === "string") return value;
-	return JSON.stringify(value, null, 2);
+function chatHistoryMessageSources(messages: AgentMessage[], item: PromptStackSlotItem): CompileMessageSource[] {
+	return messages.map((message, index) => ({
+		kind: "chat-history",
+		itemId: item.id,
+		itemName: item.name,
+		slot: item.slot,
+		historyIndex: index + 1,
+		historyCount: messages.length,
+		role: String((message as { role?: unknown }).role ?? ""),
+	}));
 }
 
-function stateValueToMacroText(value: PromptStateValue | undefined): string {
-	if (value === undefined) return "";
-	if (typeof value === "string") return value;
-	return JSON.stringify(value);
+function implicitHistoryMessageSources(messages: AgentMessage[]): CompileMessageSource[] {
+	return messages.map((message, index) => ({
+		kind: "implicit-history",
+		itemName: "Conversation history",
+		slot: "chat-history",
+		historyIndex: index + 1,
+		historyCount: messages.length,
+		role: String((message as { role?: unknown }).role ?? ""),
+	}));
 }
 
-function expandMacros(
-	text: string,
-	stack: PromptStack,
-	runtime: PromptRuntime,
+function stackItemMessageSource(message: AgentMessage, item: PromptStackItem): CompileMessageSource {
+	return {
+		kind: "stack-item",
+		itemId: item.id,
+		itemName: item.name,
+		role: String((message as { role?: unknown }).role ?? ""),
+	};
+}
+
+function stripAssistantThinkingFromHistory(
+	messages: AgentMessage[],
 	diagnostics: PromptStackDiagnostic[],
 	itemId: string,
-): string {
-	const policy = stack.defaults?.unresolvedMacroPolicy ?? "warn";
-	const unknown = new Set<string>();
-
-	const result = text.replace(/\{\{([^{}]+)\}\}/g, (full, rawName: string) => {
-		const expression = rawName.trim();
-		const parts = expression.split("::");
-		const command = parts[0]?.trim();
-
-		if (!command) return full;
-
-		// SillyTavern-style mutable variables. By default, setvar is turn-scoped and returns empty text.
-		if (command === "setvar" || command === "setturnvar" || command === "setsessionvar") {
-			const scoped = command === "setvar" && (parts[1] === "turn" || parts[1] === "session");
-			const scope = command === "setsessionvar" || (scoped && parts[1] === "session") ? "session" : "turn";
-			const nameIndex = scoped ? 2 : 1;
-			const valueIndex = nameIndex + 1;
-			const name = parts[nameIndex]?.trim();
-			const value = parts.slice(valueIndex).join("::");
-			if (!name) {
-				unknown.add(expression);
-				return full;
-			}
-			setRuntimeVariable(runtime, scope, name, value);
-			return "";
-		}
+): AgentMessage[] {
+	let strippedBlocks = 0;
+	let changedMessages = 0;
+	let droppedMessages = 0;
+	let changed = false;
+	const result: AgentMessage[] = [];
 
-		if (command === "getvar" || command === "var" || command === "getturnvar" || command === "getsessionvar") {
-			const name = parts[1]?.trim();
-			if (!name) {
-				unknown.add(expression);
-				return full;
-			}
-			if (command === "getturnvar") return stateValueToMacroText(runtime.variables?.turn[name]);
-			if (command === "getsessionvar") return stateValueToMacroText(runtime.variables?.session[name]);
-			return stateValueToMacroText(getRuntimeVariable(runtime, stack, name));
+	for (const message of messages) {
+		const stripped = stripAssistantThinkingFromMessage(message);
+		if (stripped.message !== message) {
+			changed = true;
+			strippedBlocks += stripped.removedBlocks;
+			changedMessages++;
 		}
-
-		if (command === "clearvar" || command === "clearturnvar" || command === "clearsessionvar") {
-			const scoped = command === "clearvar" && (parts[1] === "turn" || parts[1] === "session");
-			const scope = command === "clearsessionvar" || (scoped && parts[1] === "session") ? "session" : "turn";
-			const name = parts[scoped ? 2 : 1]?.trim();
-			if (!name) {
-				unknown.add(expression);
-				return full;
-			}
-			clearRuntimeVariable(runtime, scope, name);
-			return "";
+		if (!stripped.message) {
+			droppedMessages++;
+			continue;
 		}
+		result.push(stripped.message);
+	}
 
-		const dynamicValue = getBuiltinMacro(command, runtime);
-		if (dynamicValue !== undefined) return dynamicValue;
-
-		const variableValue = getRuntimeVariable(runtime, stack, command);
-		if (variableValue !== undefined) return stateValueToMacroText(variableValue);
+	if (!changed) return messages;
 
-		unknown.add(expression);
-		return full;
+	diagnostics.push({
+		level: "info",
+		message: `Stripped ${strippedBlocks} assistant thinking block(s) from ${changedMessages} chat-history message(s)` +
+			(droppedMessages > 0 ? ` and dropped ${droppedMessages} empty assistant message(s).` : "."),
+		itemId,
 	});
-
-	for (const name of unknown) {
-		if (policy === "keep") continue;
-		diagnostics.push({
-			level: policy === "error" ? "error" : "warning",
-			message: `Unresolved macro: {{${name}}}`,
-			itemId,
-		});
-	}
-
 	return result;
 }
 
-function getBuiltinMacro(name: string, runtime: PromptRuntime): string | undefined {
-	switch (name) {
-		case "cwd":
-			return runtime.options.cwd;
-		case "date":
-			return formatDate(runtime.now);
-		case "time":
-			return formatTime(runtime.now);
-		case "lastUserMessage":
-			return runtime.latestUserMessage ?? "";
-		case "selectedTools":
-		case "tools":
-			return (runtime.options.selectedTools ?? []).join(", ");
-		case "activeModel": {
-			const model = runtime.ctx?.model;
-			return model ? `${model.provider}/${model.id}` : "";
-		}
-		default:
-			return undefined;
-	}
-}
+function stripAssistantThinkingFromMessage(message: AgentMessage): { message?: AgentMessage; removedBlocks: number } {
+	if (message.role !== "assistant") return { message, removedBlocks: 0 };
+	const content = (message as { content?: unknown }).content;
+	if (!Array.isArray(content)) return { message, removedBlocks: 0 };
 
-function getRuntimeVariable(runtime: PromptRuntime, stack: PromptStack, name: string): PromptStateValue | undefined {
-	if (runtime.variables && Object.prototype.hasOwnProperty.call(runtime.variables.turn, name)) return runtime.variables.turn[name];
-	if (runtime.variables && Object.prototype.hasOwnProperty.call(runtime.variables.session, name)) return runtime.variables.session[name];
-	const staticVariables = collectStaticVariables(stack);
-	if (Object.prototype.hasOwnProperty.call(staticVariables, name)) return staticVariables[name];
-	return undefined;
+	const nextContent = content.filter((part) => !isThinkingContent(part));
+	const removedBlocks = content.length - nextContent.length;
+	if (removedBlocks === 0) return { message, removedBlocks: 0 };
+	if (nextContent.length === 0) return { removedBlocks };
+	return { message: { ...message, content: nextContent } as AgentMessage, removedBlocks };
 }
 
-function setRuntimeVariable(runtime: PromptRuntime, scope: "turn" | "session", name: string, value: string): void {
-	if (!runtime.variables) return;
-	if (scope === "session") {
-		if (runtime.variables.session[name] !== value) {
-			runtime.variables.session[name] = value;
-			runtime.variables.sessionDirty = true;
-		}
-		return;
-	}
-	runtime.variables.turn[name] = value;
+function isThinkingContent(value: unknown): boolean {
+	return !!value && typeof value === "object" && !Array.isArray(value) && (value as { type?: unknown }).type === "thinking";
 }
 
-function clearRuntimeVariable(runtime: PromptRuntime, scope: "turn" | "session", name: string): void {
-	if (!runtime.variables) return;
-	if (scope === "session") {
-		if (Object.prototype.hasOwnProperty.call(runtime.variables.session, name)) {
-			delete runtime.variables.session[name];
-			runtime.variables.sessionDirty = true;
-		}
-		return;
-	}
-	delete runtime.variables.turn[name];
+function enabledItems(stack: PromptStack): PromptStackItem[] {
+	return stack.items.filter((item) => item.enabled !== false);
 }
 
 function createSyntheticMessage(role: Exclude<PromptStackRole, "system">, content: string, stack: PromptStack, runtime: PromptRuntime): AgentMessage {
@@ -652,26 +576,3 @@ function contentToText(content: unknown): string {
 		.filter(Boolean)
 		.join("\n");
 }
-
-function formatDate(now: Date): string {
-	const year = now.getFullYear();
-	const month = String(now.getMonth() + 1).padStart(2, "0");
-	const day = String(now.getDate()).padStart(2, "0");
-	return `${year}-${month}-${day}`;
-}
-
-function formatTime(now: Date): string {
-	const hours = String(now.getHours()).padStart(2, "0");
-	const minutes = String(now.getMinutes()).padStart(2, "0");
-	const seconds = String(now.getSeconds()).padStart(2, "0");
-	return `${hours}:${minutes}:${seconds}`;
-}
-
-function escapeXml(value: string): string {
-	return value
-		.replace(/&/g, "&amp;")
-		.replace(/</g, "&lt;")
-		.replace(/>/g, "&gt;")
-		.replace(/\"/g, "&quot;")
-		.replace(/'/g, "&apos;");
-}