@makefinks/daemon 0.1.4 → 0.3.0

package/src/app/components/AppOverlays.tsx

@@ -7,11 +7,26 @@ import { OnboardingOverlay } from "../../components/OnboardingOverlay";
 import { ProviderMenu } from "../../components/ProviderMenu";
 import { SessionMenu } from "../../components/SessionMenu";
 import { SettingsMenu } from "../../components/SettingsMenu";
+import { ToolsMenu } from "../../components/ToolsMenu";
+import { UrlMenu } from "../../components/UrlMenu";
+import { useUrlMenuItems } from "../../hooks/use-url-menu-items";
 import { useAppContext } from "../../state/app-context";
+import type { ContentBlock, ConversationMessage } from "../../types";
 
-function AppOverlaysImpl() {
+interface AppOverlaysProps {
+	conversationHistory: ConversationMessage[];
+	currentContentBlocks: ContentBlock[];
+}
+
+function AppOverlaysImpl({ conversationHistory, currentContentBlocks }: AppOverlaysProps) {
 	const ctx = useAppContext();
 	const { menus, device, settings, model, session, grounding, onboarding } = ctx;
+
+	const urlMenuItems = useUrlMenuItems({
+		conversationHistory,
+		currentContentBlocks,
+		latestGroundingMap: grounding.latestGroundingMap,
+	});
 	const {
 		deviceCallbacks,
 		settingsCallbacks,
@@ -104,6 +119,15 @@ function AppOverlaysImpl() {
 				/>
 			)}
 
+			{menus.showUrlMenu && <UrlMenu items={urlMenuItems} onClose={() => menus.setShowUrlMenu(false)} />}
+
+			{menus.showToolsMenu && (
+				<ToolsMenu
+					onClose={() => menus.setShowToolsMenu(false)}
+					persistPreferences={(updates) => settings.persistPreferences(updates)}
+				/>
+			)}
+
 			{onboarding.onboardingActive && (
 				<OnboardingOverlay
 					step={onboarding.onboardingStep}

package/src/app/components/ConversationPane.tsx

@@ -428,9 +428,11 @@ function ConversationPaneImpl(props: ConversationPaneProps) {
 							</box>
 						)}
 
-						{hasGrounding && groundingCount && daemonState === DaemonState.IDLE && (
-							<GroundingBadge count={groundingCount} />
-						)}
+						{hasGrounding &&
+							groundingCount &&
+							(daemonState === DaemonState.IDLE || daemonState === DaemonState.SPEAKING) && (
+								<GroundingBadge count={groundingCount} />
+							)}
 
 						{showWorkingSpinner && (
 							<InlineStatusIndicator

package/src/components/HotkeysPane.tsx

@@ -36,10 +36,11 @@ export function HotkeysPane({ onClose }: HotkeysPaneProps) {
 		{
 			title: "SESSION",
 			items: [
-				{ key: "T", label: "Toggle full reasoning previews" },
+				{ key: "R", label: "Toggle full reasoning previews" },
 				{ key: "O", label: "Toggle tool output previews" },
 				{ key: "N", label: "New session" },
 				{ key: "G", label: "Open Grounding Menu" },
+				{ key: "U", label: "Open URL Menu" },
 				{ key: "CTRL+X", label: "Undo last message" },
 			],
 		},
@@ -50,6 +51,7 @@ export function HotkeysPane({ onClose }: HotkeysPaneProps) {
 				{ key: "M", label: "Models" },
 				{ key: "P", label: "Providers" },
 				{ key: "L", label: "Sessions" },
+				{ key: "T", label: "Tools" },
 				{ key: "S", label: "Settings" },
 			],
 		},

package/src/components/TokenUsageDisplay.tsx

@@ -2,10 +2,10 @@
  * Component for displaying token usage statistics.
  */
 
+import type { TokenUsage } from "../types";
 import { COLORS } from "../ui/constants";
 import { formatTokenCount } from "../utils/formatters";
-import { calculateCost, formatCost, formatContextUsage, type ModelMetadata } from "../utils/model-metadata";
-import type { TokenUsage } from "../types";
+import { type ModelMetadata, calculateCost, formatContextUsage, formatCost } from "../utils/model-metadata";
 
 interface TokenUsageDisplayProps {
 	usage: TokenUsage;
@@ -15,7 +15,6 @@ interface TokenUsageDisplayProps {
 export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayProps) {
 	const mainPromptTokens = usage.promptTokens;
 	const mainCompletionTokens = usage.completionTokens;
-	const mainTotalTokens = mainPromptTokens + mainCompletionTokens;
 
 	// Calculate cost if we have pricing info
 	const cost =
@@ -30,11 +29,12 @@ export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayPro
 					)
 				: null;
 
-	// Calculate context usage percentage
-	const contextTotalTokens = mainTotalTokens;
-	const contextUsage = modelMetadata?.contextLength
-		? formatContextUsage(contextTotalTokens, modelMetadata.contextLength)
-		: null;
+	// Context % uses latest turn only (prompt already includes full history, completion is that turn's output)
+	const latestTurnTotal = (usage.latestTurnPromptTokens ?? 0) + (usage.latestTurnCompletionTokens ?? 0);
+	const contextUsage =
+		modelMetadata?.contextLength && latestTurnTotal > 0
+			? formatContextUsage(latestTurnTotal, modelMetadata.contextLength)
+			: null;
 
 	return (
 		<box
@@ -47,12 +47,12 @@ export function TokenUsageDisplay({ usage, modelMetadata }: TokenUsageDisplayPro
 		>
 			<text>
 				{/* Context usage: X/Y (Z%) */}
-				{modelMetadata?.contextLength && (
+				{contextUsage && (
 					<>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}>Tokens: </span>
-						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(contextTotalTokens)}</span>
+						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(latestTurnTotal)}</span>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}>/</span>
-						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(modelMetadata.contextLength)}</span>
+						<span fg={COLORS.TOKEN_USAGE}>{formatTokenCount(modelMetadata!.contextLength)}</span>
 						<span fg={COLORS.REASONING_DIM}> ({contextUsage})</span>
 						<span fg={COLORS.TOKEN_USAGE_LABEL}> · </span>
 					</>

package/src/components/ToolsMenu.tsx

@@ -0,0 +1,235 @@
+import { useEffect, useMemo, useState } from "react";
+
+import { invalidateDaemonToolsCache } from "../ai/tools/index";
+import { invalidateSubagentToolsCache } from "../ai/tools/subagents";
+import {
+	buildMenuItems,
+	getDefaultToolOrder,
+	getToolLabels,
+	resolveToolAvailability,
+} from "../ai/tools/tool-registry";
+import { useMenuKeyboard } from "../hooks/use-menu-keyboard";
+import { getDaemonManager } from "../state/daemon-state";
+import type { ToolToggleId, ToolToggles } from "../types";
+import { DEFAULT_TOOL_TOGGLES } from "../types";
+import { COLORS } from "../ui/constants";
+
+interface ToolsMenuProps {
+	persistPreferences: (updates: Partial<{ toolToggles: ToolToggles }>) => void;
+	onClose: () => void;
+}
+
+type MenuToolItem = {
+	id: ToolToggleId;
+	label: string;
+	envAvailable: boolean;
+	disabledReason?: string;
+};
+
+function getToolLabel(id: ToolToggleId): string {
+	switch (id) {
+		case "readFile":
+			return "readFile";
+		case "runBash":
+			return "runBash";
+		case "webSearch":
+			return "webSearch";
+		case "fetchUrls":
+			return "fetchUrls";
+		case "renderUrl":
+			return "renderUrl";
+		case "todoManager":
+			return "todoManager";
+		case "groundingManager":
+			return "groundingManager";
+		case "subagent":
+			return "subagent";
+		default:
+			return id;
+	}
+}
+
+export function ToolsMenu({ persistPreferences, onClose }: ToolsMenuProps) {
+	const manager = getDaemonManager();
+	const [toggles, setToggles] = useState<ToolToggles>(manager.toolToggles ?? { ...DEFAULT_TOOL_TOGGLES });
+
+	const [toolAvailability, setToolAvailability] = useState<Record<ToolToggleId, MenuToolItem> | null>(null);
+
+	useEffect(() => {
+		let cancelled = false;
+		const loadAvailability = async () => {
+			const toggles = manager.toolToggles ?? { ...DEFAULT_TOOL_TOGGLES };
+			const availability = await resolveToolAvailability(toggles);
+			const map = buildMenuItems(availability) as Record<ToolToggleId, MenuToolItem>;
+
+			if (cancelled) return;
+			setToolAvailability(map);
+		};
+
+		void loadAvailability();
+		return () => {
+			cancelled = true;
+		};
+	}, [manager, toggles]);
+
+	const items = useMemo((): MenuToolItem[] => {
+		const labels = getToolLabels();
+		const order = getDefaultToolOrder();
+		if (!toolAvailability) {
+			return order.map((id) => ({
+				id,
+				label: labels[id],
+				envAvailable: true,
+			}));
+		}
+
+		return order.map((id) => toolAvailability[id]).filter((item): item is MenuToolItem => Boolean(item));
+	}, [toolAvailability]);
+
+	const { selectedIndex } = useMenuKeyboard({
+		itemCount: items.length,
+		onClose,
+		closeOnSelect: false,
+		onSelect: (idx) => {
+			const item = items[idx];
+			if (!item) return;
+
+			const current = manager.toolToggles ?? { ...DEFAULT_TOOL_TOGGLES };
+
+			// If env-unavailable, block enabling, but allow disabling.
+			if (!item.envAvailable && current[item.id]) {
+				return;
+			}
+
+			const next: ToolToggles = {
+				...DEFAULT_TOOL_TOGGLES,
+				...current,
+				[item.id]: !current[item.id],
+			};
+			manager.toolToggles = next;
+			setToggles(next);
+			persistPreferences({ toolToggles: next });
+
+			invalidateDaemonToolsCache();
+			invalidateSubagentToolsCache();
+			resolveToolAvailability(next)
+				.then((availability) => {
+					const map = buildMenuItems(availability) as Record<ToolToggleId, MenuToolItem>;
+					setToolAvailability(map);
+				})
+				.catch(() => {
+					setToolAvailability(null);
+				});
+		},
+	});
+
+	const showReasonColumn = useMemo(() => {
+		return items.some((item) => !item.envAvailable);
+	}, [items]);
+
+	const labelWidth = useMemo(() => {
+		const raw = items.reduce((max, item) => Math.max(max, item.label.length), 0);
+		// When no env-disabled tools exist, keep the menu compact.
+		return showReasonColumn ? raw : Math.min(raw, 16);
+	}, [items, showReasonColumn]);
+
+	const statusWidth = 8;
+
+	function truncateText(text: string, maxLen: number): string {
+		if (text.length <= maxLen) return text;
+		return text.slice(0, Math.max(0, maxLen - 1)) + "…";
+	}
+
+	return (
+		<box
+			position="absolute"
+			left={0}
+			top={0}
+			width="100%"
+			height="100%"
+			flexDirection="column"
+			alignItems="center"
+			justifyContent="center"
+			zIndex={100}
+		>
+			<box
+				flexDirection="column"
+				backgroundColor={COLORS.MENU_BG}
+				borderStyle="single"
+				borderColor={COLORS.MENU_BORDER}
+				paddingLeft={2}
+				paddingRight={2}
+				paddingTop={1}
+				paddingBottom={1}
+				width={showReasonColumn ? "70%" : "52%"}
+				minWidth={showReasonColumn ? 70 : 48}
+				maxWidth={showReasonColumn ? 150 : 90}
+			>
+				<box marginBottom={1}>
+					<text>
+						<span fg={COLORS.DAEMON_LABEL}>[ TOOLS ]</span>
+					</text>
+				</box>
+				<box marginBottom={1}>
+					<text>
+						<span fg={COLORS.USER_LABEL}>↑/↓ or j/k to navigate, ENTER to toggle, ESC to close</span>
+					</text>
+				</box>
+
+				{showReasonColumn && (
+					<box marginBottom={1}>
+						<text>
+							<span fg={COLORS.REASONING_DIM}>
+								{"TOOL".padEnd(labelWidth)} {"STATUS".padEnd(statusWidth)} REASON
+							</span>
+						</text>
+					</box>
+				)}
+
+				<box flexDirection="column">
+					{items.map((item, idx) => {
+						const isSelected = idx === selectedIndex;
+						const isEnabled = Boolean(toggles[item.id]);
+						const canEnable = item.envAvailable;
+						const statusLabel = !canEnable ? "DISABLED" : isEnabled ? "ON" : "OFF";
+						const reason = !canEnable && item.disabledReason ? item.disabledReason : "";
+
+						const labelColor = isSelected ? COLORS.DAEMON_LABEL : COLORS.MENU_TEXT;
+						const statusColor = !canEnable
+							? COLORS.REASONING_DIM
+							: isEnabled
+								? COLORS.DAEMON_TEXT
+								: COLORS.REASONING_DIM;
+						const reasonColor = COLORS.REASONING_DIM;
+
+						const labelText = truncateText(item.label, labelWidth).padEnd(labelWidth);
+						const statusText = statusLabel.padEnd(statusWidth);
+						const reasonText = reason ? truncateText(reason, 60) : "";
+
+						return (
+							<box
+								key={item.id}
+								backgroundColor={isSelected ? COLORS.MENU_SELECTED_BG : COLORS.MENU_BG}
+								paddingLeft={1}
+								paddingRight={1}
+							>
+								<text>
+									<span fg={labelColor}>{isSelected ? "▶ " : "  "}</span>
+									<span fg={labelColor}>{labelText}</span>
+									<span fg={COLORS.REASONING_DIM}> </span>
+									<span fg={statusColor}>{statusText}</span>
+									{showReasonColumn && reasonText ? (
+										<>
+											<span fg={COLORS.REASONING_DIM}> </span>
+											<span fg={reasonColor}>{reasonText}</span>
+										</>
+									) : null}
+								</text>
+							</box>
+						);
+					})}
+				</box>
+			</box>
+		</box>
+	);
+}

package/src/components/UrlMenu.tsx

@@ -0,0 +1,182 @@
+import type { KeyEvent, ScrollBoxRenderable } from "@opentui/core";
+import { useKeyboard, useRenderer } from "@opentui/react";
+import { useCallback, useMemo, useRef } from "react";
+import { COLORS } from "../ui/constants";
+
+import type { UrlMenuItem } from "../types";
+
+interface UrlMenuProps {
+	items: UrlMenuItem[];
+	onClose: () => void;
+}
+
+const SCROLL_AMOUNT = 1;
+
+function splitUrl(url: string): { origin: string; path: string } {
+	try {
+		const parsed = new URL(url);
+		return { origin: parsed.origin, path: parsed.pathname + parsed.search + parsed.hash };
+	} catch {
+		const match = url.match(/^(https?:\/\/[^/]+)(\/.*)?$/);
+		if (match) {
+			return { origin: match[1] ?? url, path: match[2] ?? "" };
+		}
+		return { origin: url, path: "" };
+	}
+}
+
+export function UrlMenu({ items, onClose }: UrlMenuProps) {
+	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+	const renderer = useRenderer();
+
+	const sortedItems = useMemo(() => {
+		const next = [...items];
+		next.sort((a, b) => {
+			const groundedDelta = b.groundedCount - a.groundedCount;
+			if (groundedDelta !== 0) return groundedDelta;
+
+			const aPercent = a.readPercent ?? -1;
+			const bPercent = b.readPercent ?? -1;
+			if (aPercent !== bPercent) return bPercent - aPercent;
+
+			return b.lastSeenIndex - a.lastSeenIndex;
+		});
+		return next;
+	}, [items]);
+
+	const menuWidth = useMemo(() => {
+		return Math.max(80, Math.min(220, Math.floor(renderer.terminalWidth * 0.8)));
+	}, [renderer.terminalWidth]);
+
+	const menuHeight = useMemo(() => {
+		const headerHeight = 4;
+		const rowCount = sortedItems.length;
+		const contentHeight = rowCount > 0 ? rowCount : 1;
+		const minHeight = Math.floor(renderer.terminalHeight * 0.5);
+		const maxHeight = Math.floor(renderer.terminalHeight * 0.8);
+		return Math.max(minHeight, Math.min(headerHeight + contentHeight + 2, maxHeight));
+	}, [sortedItems.length, renderer.terminalHeight]);
+
+	const scrollBy = useCallback((delta: number) => {
+		const scrollbox = scrollRef.current;
+		if (!scrollbox) return;
+		const viewportHeight = scrollbox.viewport?.height ?? 0;
+		const maxScrollTop = Math.max(0, scrollbox.scrollHeight - viewportHeight);
+		const nextScrollTop = Math.max(0, Math.min(scrollbox.scrollTop + delta, maxScrollTop));
+		scrollbox.scrollTop = nextScrollTop;
+	}, []);
+
+	const handleKeyPress = useCallback(
+		(key: KeyEvent) => {
+			if (key.eventType !== "press") return;
+
+			if (key.name === "escape" || key.sequence === "u" || key.sequence === "U") {
+				onClose();
+				key.preventDefault();
+				return;
+			}
+
+			if (key.sequence === "j" || key.sequence === "J" || key.name === "down") {
+				scrollBy(SCROLL_AMOUNT);
+				key.preventDefault();
+				return;
+			}
+
+			if (key.sequence === "k" || key.sequence === "K" || key.name === "up") {
+				scrollBy(-SCROLL_AMOUNT);
+				key.preventDefault();
+				return;
+			}
+		},
+		[onClose, scrollBy]
+	);
+
+	useKeyboard(handleKeyPress);
+
+	return (
+		<box
+			position="absolute"
+			left={0}
+			top={0}
+			width="100%"
+			height="100%"
+			flexDirection="column"
+			alignItems="center"
+			justifyContent="center"
+			zIndex={100}
+		>
+			<box
+				flexDirection="column"
+				backgroundColor={COLORS.MENU_BG}
+				borderStyle="single"
+				borderColor={COLORS.MENU_BORDER}
+				paddingLeft={2}
+				paddingRight={2}
+				paddingTop={1}
+				paddingBottom={1}
+				width={menuWidth}
+				height={menuHeight}
+			>
+				<box marginBottom={1} flexDirection="row" width="100%">
+					<text>
+						<span fg={COLORS.DAEMON_LABEL}>[ URLS ]</span>
+						<span fg={COLORS.REASONING_DIM}> — {sortedItems.length} fetched</span>
+					</text>
+					<box flexGrow={1} />
+					<text>
+						<span fg={COLORS.USER_LABEL}>
+							<span fg={COLORS.DAEMON_LABEL}>j/k</span> scroll · <span fg={COLORS.DAEMON_LABEL}>ESC</span>{" "}
+							close
+						</span>
+					</text>
+				</box>
+
+				<box marginBottom={1} flexDirection="row" width="100%" justifyContent="space-between">
+					<text>
+						<span fg={COLORS.REASONING_DIM}>
+							{"G".padEnd(2)}
+							{"READ".padEnd(6)}URL
+						</span>
+					</text>
+					<text>
+						<span fg={COLORS.REASONING_DIM}>(G=grounded, READ=% or HL=highlights)</span>
+					</text>
+				</box>
+
+				<scrollbox ref={scrollRef} flexGrow={1} width="100%" overflow="scroll">
+					{sortedItems.length === 0 ? (
+						<text>
+							<span fg={COLORS.REASONING_DIM}>No URLs fetched yet</span>
+						</text>
+					) : (
+						sortedItems.map((item, idx) => {
+							const { origin, path } = splitUrl(item.url);
+							const grounded = item.groundedCount > 0;
+							const readLabel =
+								item.readPercent !== undefined
+									? `${item.readPercent}%`
+									: item.highlightsCount !== undefined
+										? `HL:${item.highlightsCount}`
+										: "—";
+
+							return (
+								<box key={idx} flexDirection="row" marginBottom={0}>
+									<text>
+										<span fg={grounded ? COLORS.DAEMON_TEXT : COLORS.REASONING_DIM}>
+											{grounded ? "G" : "·"}
+										</span>
+										<span fg={COLORS.REASONING_DIM}> </span>
+										<span fg={COLORS.REASONING_DIM}>{readLabel.padStart(4, " ")}</span>
+										<span fg={COLORS.REASONING_DIM}> </span>
+										<span fg={item.status === "error" ? COLORS.ERROR : COLORS.DAEMON_LABEL}>{origin}</span>
+										<span fg={COLORS.REASONING_DIM}>{path}</span>
+									</text>
+								</box>
+							);
+						})
+					)}
+				</scrollbox>
+			</box>
+		</box>
+	);
+}

package/src/hooks/daemon-event-handlers/interrupted-turn.ts

@@ -0,0 +1,148 @@
+import type { ContentBlock, ModelMessage, ToolResultOutput } from "../../types";
+
+export const INTERRUPTED_TOOL_RESULT = "Tool execution interrupted by user";
+
+export function normalizeInterruptedToolBlockResult(result: unknown): unknown {
+	if (result !== undefined) return result;
+	return { success: false, error: INTERRUPTED_TOOL_RESULT };
+}
+
+export function normalizeInterruptedToolResultOutput(result: unknown): ToolResultOutput {
+	if (result === undefined) {
+		return { type: "error-text", value: INTERRUPTED_TOOL_RESULT };
+	}
+
+	if (typeof result === "string") {
+		return { type: "text", value: result };
+	}
+
+	try {
+		JSON.stringify(result);
+		return { type: "json", value: result as ToolResultOutput["value"] };
+	} catch {
+		return { type: "text", value: String(result) };
+	}
+}
+
+export function buildInterruptedContentBlocks(contentBlocks: ContentBlock[]): ContentBlock[] {
+	return contentBlocks.map((block) => {
+		if (block.type !== "tool") return { ...block };
+
+		const call = { ...block.call };
+		if (call.status === "running") {
+			call.status = "failed";
+			call.error = INTERRUPTED_TOOL_RESULT;
+		}
+		if (call.subagentSteps) {
+			call.subagentSteps = call.subagentSteps.map((step) =>
+				step.status === "running" ? { ...step, status: "failed" } : step
+			);
+		}
+
+		return {
+			...block,
+			call,
+			result: normalizeInterruptedToolBlockResult(block.result),
+		};
+	});
+}
+
+export function buildInterruptedModelMessages(contentBlocks: ContentBlock[]): ModelMessage[] {
+	const messages: ModelMessage[] = [];
+
+	type AssistantPart =
+		| { type: "text"; text: string }
+		| { type: "reasoning"; text: string }
+		| { type: "tool-call"; toolCallId: string; toolName: string; input: unknown };
+
+	type ToolResultPart = {
+		type: "tool-result";
+		toolCallId: string;
+		toolName: string;
+		output: ToolResultOutput;
+	};
+
+	let assistantParts: AssistantPart[] = [];
+	let toolResults: ToolResultPart[] = [];
+
+	for (const block of contentBlocks) {
+		if (block.type === "reasoning" && block.content) {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			assistantParts.push({ type: "reasoning", text: block.content });
+			continue;
+		}
+
+		if (block.type === "text" && block.content) {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			assistantParts.push({ type: "text", text: block.content });
+			continue;
+		}
+
+		if (block.type === "tool") {
+			if (toolResults.length > 0) {
+				messages.push({
+					role: "tool",
+					content: [...toolResults],
+				} as unknown as ModelMessage);
+				toolResults = [];
+			}
+
+			const toolCallId = block.call.toolCallId;
+			if (!toolCallId) {
+				continue;
+			}
+
+			assistantParts.push({
+				type: "tool-call",
+				toolCallId,
+				toolName: block.call.name,
+				input: block.call.input ?? {},
+			});
+
+			if (assistantParts.length > 0) {
+				messages.push({
+					role: "assistant",
+					content: [...assistantParts],
+				} as unknown as ModelMessage);
+				assistantParts = [];
+			}
+
+			toolResults.push({
+				type: "tool-result",
+				toolCallId,
+				toolName: block.call.name,
+				output: normalizeInterruptedToolResultOutput(block.result),
+			});
+		}
+	}
+
+	if (assistantParts.length > 0) {
+		messages.push({
+			role: "assistant",
+			content: [...assistantParts],
+		} as unknown as ModelMessage);
+	}
+
+	if (toolResults.length > 0) {
+		messages.push({
+			role: "tool",
+			content: [...toolResults],
+		} as unknown as ModelMessage);
+	}
+
+	return messages;
+}