code-ollama 0.20.0 → 0.21.1

package/README.md

@@ -21,6 +21,9 @@
 npx code-ollama
 ```
 
+> [!IMPORTANT]
+> If you see an error that says server/model is unavailable, then follow these [steps](https://github.com/ai-action/code-ollama/wiki/Ollama).
+
 ## Install
 
 Install the [CLI](https://www.npmjs.com/package/code-ollama) globally:

package/dist/assets/{tui-DDbMjcMS.js → tui-BHkHnKUC.js}

@@ -1,4 +1,4 @@
-import { A as WARNING, B as LABEL, C as loadConfig, D as resetSystemMessage, E as saveClipboardImage, F as USER, G as VERSION, H as SAFE, I as PLAN_GENERATION_INSTRUCTION, K as LIST, L as BACK, M as getTheme, N as ASSISTANT, O as withSystemMessage, P as SYSTEM, R as CATALOG, S as streamChat, T as removeClipboardImage, U as APPROVE, V as PLAN, W as REJECT, _ as setClearHandler, a as tick, b as listModels, c as appendMessage, d as deleteSessionIfEmpty, f as listSessions, g as reset, h as clear, i as WRITE_TOOLS, j as LIST$1, k as HEADER_PREFIX, l as createSession, m as updateSessionModel, n as READ_TOOLS, o as color, p as loadSession, r as TOOLS, s as write, t as executeTool, u as deleteSession, v as checkHealth, w as saveConfig, x as pullModel, y as deleteModel, z as AUTO } from "../cli.js";
+import { A as saveClipboardImage, B as PLAN_GENERATION_INSTRUCTION, C as deleteModel, D as loadConfig, E as streamChat, F as LIST$1, G as PLAN, H as CATALOG, I as getTheme, J as REJECT, K as SAFE, L as ASSISTANT, M as withSystemMessage, N as HEADER_PREFIX, O as saveConfig, P as WARNING, R as SYSTEM, S as checkHealth, T as pullModel, U as AUTO, V as BACK, W as LABEL, X as VERSION, Y as NAME, Z as LIST, _ as loadSession, a as normalizeToolCall, b as reset, c as WRITE_TOOLS, d as write, f as appendMessage, g as listSessions, h as deleteSessionIfEmpty, i as formatToolResultContent, j as resetSystemMessage, k as removeClipboardImage, l as tick, m as deleteSession, n as executeTool, o as READ_TOOLS, p as createSession, q as APPROVE, r as executeToolCall, s as TOOLS, t as checkForUpdate, u as color, v as updateSessionModel, w as listModels, x as setClearHandler, y as clear, z as USER } from "../cli.js";
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
@@ -1362,6 +1362,7 @@ function hasExecutablePlan(content) {
 }
 //#endregion
 //#region src/components/Chat/Chat.tsx
+var MAX_TOOL_TURNS = 25;
 function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onModeChange, sessionId, theme = getTheme() }) {
 	const sessionMessages = initialMessages ?? [];
 	const history = useMemo(() => sessionMessages.flatMap(({ role, content }) => role === "user" && !content.startsWith("/") ? [content] : []), [sessionMessages]);
@@ -1400,7 +1401,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		};
 		return {
 			role: SYSTEM,
-			content: `Tool ${toolName} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+			content: formatToolResultContent(toolName, result)
 		};
 	}, []);
 	const buildPlanModeCorrectionMessage = useCallback((toolName) => ({
@@ -1425,72 +1426,112 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 		}]);
 	}, []);
 	const processStream = useCallback(async (currentMessages, executionMode = mode) => {
+		const modelName = model;
 		// v8 ignore next
-		if (!model) throw new Error("Model is required");
+		if (!modelName) throw new Error("Model is required");
 		const controller = new AbortController();
 		abortControllerRef.current = controller;
-		const assistantMessage = {
-			role: ASSISTANT,
-			content: ""
-		};
-		let committedMessages = currentMessages;
-		let assistantCommitted = false;
-		const commitAssistantMessage = () => {
-			if (assistantCommitted) {
-				// v8 ignore next
-				if (committedMessages.at(-1)?.role === "assistant") {
-					committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
-					setMessages(committedMessages);
-				}
-				return committedMessages;
-			}
-			assistantCommitted = true;
-			setStreamingMessage(null);
-			if (!assistantMessage.content) {
-				setMessages(committedMessages);
-				return committedMessages;
-			}
-			committedMessages = [...committedMessages, { ...assistantMessage }];
-			setMessages(committedMessages);
-			return committedMessages;
-		};
-		setStreamingMessage(assistantMessage);
+		let activeMessages = currentMessages;
+		let toolTurns = 0;
 		try {
-			for await (const chunk of streamChat(withSystemMessage(currentMessages), model, TOOLS, controller.signal)) {
-				// v8 ignore next 3
-				if (controller.signal.aborted) return;
-				if (chunk.type === "content") {
-					assistantMessage.content += chunk.content;
-					setStreamingMessage({ ...assistantMessage });
-				} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
-					const requiresApproval = WRITE_TOOLS.has(toolCall.function.name);
+			while (!controller.signal.aborted) {
+				const assistantMessage = {
+					role: ASSISTANT,
+					content: ""
+				};
+				let committedMessages = activeMessages;
+				let assistantCommitted = false;
+				const commitAssistantMessage = () => {
 					// v8 ignore start
-					const allowedTools = executionMode === "plan" ? READ_TOOLS : void 0;
+					if (assistantCommitted) {
+						if (committedMessages.at(-1)?.role === "assistant") {
+							committedMessages = [...committedMessages.slice(0, -1), { ...assistantMessage }];
+							setMessages(committedMessages);
+						}
+						return committedMessages;
+					}
 					// v8 ignore stop
+					assistantCommitted = true;
+					setStreamingMessage(null);
+					if (!assistantMessage.content) {
+						setMessages(committedMessages);
+						return committedMessages;
+					}
+					committedMessages = [...committedMessages, { ...assistantMessage }];
+					setMessages(committedMessages);
+					return committedMessages;
+				};
+				setStreamingMessage(assistantMessage);
+				let nextMessages = null;
+				for await (const chunk of streamChat(withSystemMessage(activeMessages), modelName, TOOLS, controller.signal)) {
+					if (chunk.type === "content") {
+						assistantMessage.content += chunk.content;
+						setStreamingMessage({ ...assistantMessage });
+						continue;
+					}
+					if (chunk.tool_calls.length === 0) continue;
 					const updatedMessages = commitAssistantMessage();
-					if (executionMode === "safe" && requiresApproval) {
-						setPendingToolCall(toolCall);
-						setIsLoading(false);
-						return;
+					const toolResultMessages = [];
+					for (const toolCall of chunk.tool_calls) try {
+						const normalized = normalizeToolCall(toolCall);
+						if (executionMode === "safe" && normalized.requiresApproval) {
+							setPendingToolCall({
+								toolCall,
+								messages: [...updatedMessages, ...toolResultMessages],
+								executionMode
+							});
+							setIsLoading(false);
+							return;
+						}
+						// v8 ignore next
+						const allowedTools = executionMode === "plan" ? READ_TOOLS : void 0;
+						const result = await executeTool(normalized.name, normalized.arguments, { allowedTools });
+						toolResultMessages.push(buildToolResultMessage(normalized.name, result));
+					} catch (error) {
+						toolResultMessages.push(buildToolResultMessage(toolCall.function.name, {
+							content: "",
+							// v8 ignore next
+							error: error instanceof Error ? error.message : String(error)
+						}));
 					}
-					const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools });
-					const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
-					const newMessages = [...updatedMessages, toolResultMessage];
-					setMessages(newMessages);
-					await processStream(newMessages, executionMode);
+					nextMessages = [...updatedMessages, ...toolResultMessages];
+					setMessages(nextMessages);
+					break;
+				}
+				if (!nextMessages) {
+					await prewarmCodeBlocks(assistantMessage.content, theme);
+					commitAssistantMessage();
 					return;
 				}
+				toolTurns += 1;
+				/* v8 ignore start */
+				if (toolTurns >= MAX_TOOL_TURNS) {
+					setMessages([...nextMessages, {
+						role: SYSTEM,
+						content: [
+							"Tool execution stopped because the maximum tool turn limit was reached",
+							ACTION_NOT_PERFORMED,
+							"Summarize completed work and explain what remains without calling more tools."
+						].join("\n")
+					}]);
+					return;
+				}
+				/* v8 ignore stop */
+				activeMessages = nextMessages;
 			}
-			await prewarmCodeBlocks(assistantMessage.content, theme);
-			commitAssistantMessage();
 		} catch (error) {
 			// v8 ignore next
 			if (!controller.signal.aborted) {
-				assistantMessage.content = `Error: ${error instanceof Error ? error.message : String(error)}`;
-				await prewarmCodeBlocks(assistantMessage.content, theme);
-				commitAssistantMessage();
+				const errorMessage = {
+					role: ASSISTANT,
+					content: `Error: ${error instanceof Error ? error.message : String(error)}`
+				};
+				await prewarmCodeBlocks(errorMessage.content, theme);
+				setStreamingMessage(null);
+				setMessages([...activeMessages, errorMessage]);
 			}
 		} finally {
+			// v8 ignore next
 			if (abortControllerRef.current === controller) abortControllerRef.current = null;
 			setIsLoading(false);
 		}
@@ -1542,15 +1583,29 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 					setStreamingMessage({ ...assistantMessage });
 				} else if (chunk.type === "tool_calls") for (const toolCall of chunk.tool_calls) {
 					const updatedMessages = commitAssistantMessage();
-					if (!READ_TOOLS.has(toolCall.function.name)) {
-						const correctionMessage = buildPlanModeCorrectionMessage(toolCall.function.name);
+					let normalized;
+					try {
+						normalized = normalizeToolCall(toolCall);
+					} catch (error) {
+						/* v8 ignore start */
+						const toolResultMessage = buildToolResultMessage(toolCall.function.name, {
+							content: "",
+							error: error instanceof Error ? error.message : String(error)
+						});
+						const newMessages = [...updatedMessages, toolResultMessage];
+						setMessages(newMessages);
+						await processStreamReadOnly(newMessages);
+						return;
+					}
+					if (!READ_TOOLS.has(normalized.name)) {
+						const correctionMessage = buildPlanModeCorrectionMessage(normalized.name);
 						const newMessages = [...updatedMessages, correctionMessage];
 						setMessages(newMessages);
 						await processStreamReadOnly(newMessages);
 						return;
 					}
-					const result = await executeTool(toolCall.function.name, toolCall.function.arguments, { allowedTools: READ_TOOLS });
-					const toolResultMessage = buildToolResultMessage(toolCall.function.name, result);
+					const result = await executeTool(normalized.name, normalized.arguments, { allowedTools: READ_TOOLS });
+					const toolResultMessage = buildToolResultMessage(normalized.name, result);
 					const newMessages = [...updatedMessages, toolResultMessage];
 					setMessages(newMessages);
 					await processStreamReadOnly(newMessages);
@@ -1641,35 +1696,36 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 	const handleToolApproval = useCallback(async (decision) => {
 		// v8 ignore next
 		if (!pendingToolCall) return;
-		const toolCall = pendingToolCall;
+		const { executionMode, messages: approvedMessages, toolCall } = pendingToolCall;
 		setPendingToolCall(null);
 		setIsLoading(true);
 		switch (decision) {
 			case APPROVE: {
-				const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
+				const result = await executeToolCall(toolCall);
 				const toolResultMessage = {
 					role: SYSTEM,
-					content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
+					content: formatToolResultContent(toolCall.function.name, result)
 				};
-				const newMessages = [...messages, toolResultMessage];
-				setMessages((previousMessages) => [...previousMessages, toolResultMessage]);
-				await processStream(newMessages);
+				const newMessages = [...approvedMessages, toolResultMessage];
+				setMessages(newMessages);
+				await processStream(newMessages, executionMode);
 				break;
 			}
-			case REJECT:
-				setMessages((previousMessages) => [...previousMessages, {
-					role: USER,
-					content: TURN_ABORTED_MESSAGE
-				}]);
+			case REJECT: {
+				const toolResultMessage = {
+					role: SYSTEM,
+					content: formatToolResultContent(toolCall.function.name, {
+						content: "",
+						error: "Tool call rejected by user"
+					})
+				};
+				setMessages([...approvedMessages, toolResultMessage]);
 				setIsLoading(false);
 				setInterruptReason(InterruptReason.Rejected);
 				break;
+			}
 		}
-	}, [
-		pendingToolCall,
-		messages,
-		processStream
-	]);
+	}, [pendingToolCall, processStream]);
 	const handleSubmit = useCallback(async ({ content, images }) => {
 		setInterruptReason(null);
 		const userContent = content.trim();
@@ -1711,7 +1767,7 @@ function Chat({ initialMessages, model, onCommand, onMessagesChange, mode, onMod
 				theme
 			}),
 			!pendingPlan && pendingToolCall && /* @__PURE__ */ jsx(ToolApproval, {
-				toolCall: pendingToolCall,
+				toolCall: pendingToolCall.toolCall,
 				onDecision: handleToolApproval,
 				theme
 			}),
@@ -1783,12 +1839,9 @@ function abbreviatePath(dir) {
 	const home = homedir();
 	return dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
 }
-function Header({ model, onLoad, theme = getTheme() }) {
+function Header({ model, theme = getTheme() }) {
 	const directory = abbreviatePath(process.cwd());
 	const modelLabel = model || "not configured";
-	useEffect(() => {
-		onLoad();
-	}, []);
 	return /* @__PURE__ */ jsx(Static, {
 		items: [0],
 		children: (key) => /* @__PURE__ */ jsxs(Box, {
@@ -2781,6 +2834,63 @@ function ThemeSettings({ currentTheme, onClose, onPreview, onSave }) {
 	});
 }
 //#endregion
+//#region src/components/UpdateBanner/UpdateBanner.tsx
+var RELEASES_URL = `https://github.com/ai-action/${NAME}/releases`;
+function UpdateBanner({ onLoad, theme }) {
+	const [latestVersion, setLatestVersion] = useState();
+	useEffect(() => {
+		checkForUpdate().then(setLatestVersion).finally(async () => {
+			await tick();
+			onLoad();
+		});
+	}, []);
+	if (!latestVersion) return null;
+	return /* @__PURE__ */ jsx(Static, {
+		items: [0],
+		children: (key) => /* @__PURE__ */ jsxs(Box, {
+			borderStyle: "bold",
+			flexDirection: "column",
+			paddingX: 1,
+			children: [
+				/* @__PURE__ */ jsxs(Text, { children: [
+					/* @__PURE__ */ jsx(Text, {
+						italic: true,
+						children: "🚀 Update available! "
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: theme.colors.secondary,
+						children: VERSION
+					}),
+					" →",
+					" ",
+					/* @__PURE__ */ jsx(Text, {
+						color: theme.colors.secondary,
+						children: latestVersion
+					})
+				] }),
+				/* @__PURE__ */ jsx(Box, {
+					marginBottom: 1,
+					children: /* @__PURE__ */ jsxs(Text, { children: [
+						"Run to update:",
+						" ",
+						/* @__PURE__ */ jsxs(Text, {
+							color: theme.colors.command,
+							children: ["npm i -g ", NAME]
+						})
+					] })
+				}),
+				/* @__PURE__ */ jsx(Text, { children: "See release notes:" }),
+				/* @__PURE__ */ jsx(Text, {
+					color: theme.colors.accent,
+					dimColor: true,
+					underline: true,
+					children: RELEASES_URL
+				})
+			]
+		}, key)
+	});
+}
+//#endregion
 //#region src/components/App/constants.ts
 var Screen = /* @__PURE__ */ function(Screen) {
 	Screen["Chat"] = "chat";
@@ -3002,7 +3112,7 @@ function ReadinessCheck({ errorMessage, onCommand, setupState, theme = getTheme(
 function App({ sessionId }) {
 	const [appConfig, setConfig] = useState(() => loadConfig());
 	const [mode, setMode] = useState(SAFE);
-	const [isHeaderLoaded, setIsHeaderLoaded] = useState(false);
+	const [isLoaded, setIsLoaded] = useState(false);
 	const [setupState, setSetupState] = useState(() => appConfig.model ? ReadinessState.Ready : ReadinessState.MissingModelConfig);
 	const [setupErrorMessage, setSetupErrorMessage] = useState(null);
 	const { currentScreen, setScreen, handleClose, handleCommand } = useScreenRouter();
@@ -3066,19 +3176,6 @@ function App({ sessionId }) {
 		onUpdateConfig: handleUpdateConfig,
 		setScreen
 	});
-	const handleHeaderLoad = useCallback(() => {
-		setIsHeaderLoaded(true);
-	}, []);
-	const handleToggleMode = useCallback(() => {
-		setMode((mode) => {
-			switch (mode) {
-				case SAFE: return AUTO;
-				case AUTO: return PLAN;
-				case PLAN:
-				default: return SAFE;
-			}
-		});
-	}, []);
 	const handleChatCommand = useCallback((command) => {
 		handleCommand(command, {
 			model: appConfig.model ?? "",
@@ -3093,18 +3190,6 @@ function App({ sessionId }) {
 		handleCreateSession,
 		setPreviewThemeId
 	]);
-	const handleDeleteSessionAndStay = useCallback((sid) => {
-		handleDeleteSession(sid);
-		setScreen(Screen.SessionManager);
-	}, [handleDeleteSession, setScreen]);
-	const handleOpenSessionAndNavigate = useCallback((sid) => {
-		handleOpenSession(sid);
-		setScreen(Screen.Chat);
-	}, [handleOpenSession, setScreen]);
-	const handleCreateSessionAndNavigate = useCallback(() => {
-		handleCreateSession();
-		setScreen(Screen.Chat);
-	}, [handleCreateSession, setScreen]);
 	let screenContent;
 	switch (currentScreen) {
 		case Screen.ModelManager:
@@ -3127,9 +3212,18 @@ function App({ sessionId }) {
 			screenContent = /* @__PURE__ */ jsx(SessionManager, {
 				currentSessionId: activeSession.metadata.id,
 				onClose: handleClose,
-				onDelete: handleDeleteSessionAndStay,
-				onNew: handleCreateSessionAndNavigate,
-				onOpen: handleOpenSessionAndNavigate,
+				onDelete: (sessionId) => {
+					handleDeleteSession(sessionId);
+					setScreen(Screen.SessionManager);
+				},
+				onNew: () => {
+					handleCreateSession();
+					setScreen(Screen.Chat);
+				},
+				onOpen: (sessionId) => {
+					handleOpenSession(sessionId);
+					setScreen(Screen.Chat);
+				},
 				theme: activeTheme
 			});
 			break;
@@ -3164,14 +3258,27 @@ function App({ sessionId }) {
 		children: [
 			/* @__PURE__ */ jsx(Header, {
 				model: appConfig.model ?? "",
-				onLoad: handleHeaderLoad,
 				theme: activeTheme
 			}),
-			isHeaderLoaded && screenContent,
+			/* @__PURE__ */ jsx(UpdateBanner, {
+				onLoad: () => {
+					setIsLoaded(true);
+				},
+				theme: activeTheme
+			}),
+			isLoaded && screenContent,
 			/* @__PURE__ */ jsx(Footer, {
 				mode,
 				model: appConfig.model ?? "",
-				onToggleMode: handleToggleMode,
+				onToggleMode: () => {
+					setMode((mode) => {
+						switch (mode) {
+							case SAFE: return AUTO;
+							case AUTO: return PLAN;
+							case PLAN: return SAFE;
+						}
+					});
+				},
 				theme: activeTheme
 			})
 		]

package/dist/cli.js

@@ -8,6 +8,18 @@ import { randomUUID } from "node:crypto";
 import { Ollama } from "ollama";
 import { v7 } from "uuid";
 import { promisify } from "node:util";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/constants/command.ts
 var LIST$1 = [
 	{
@@ -38,7 +50,7 @@ var LIST$1 = [
 //#endregion
 //#region package.json
 var name = "code-ollama";
-var version = "0.20.0";
+var version = "0.21.1";
 //#endregion
 //#region src/constants/package.ts
 var NAME = name;
@@ -280,6 +292,17 @@ function getTheme(themeId = DEFAULT_THEME_ID) {
 }
 //#endregion
 //#region src/constants/tool.ts
+var tool_exports = /* @__PURE__ */ __exportAll({
+	EDIT_FILE: () => EDIT_FILE,
+	GREP_SEARCH: () => GREP_SEARCH,
+	LIST_DIR: () => LIST_DIR,
+	READ_FILE: () => READ_FILE,
+	RUN_SHELL: () => RUN_SHELL,
+	VIEW_RANGE: () => VIEW_RANGE,
+	WEB_FETCH: () => WEB_FETCH,
+	WEB_SEARCH: () => WEB_SEARCH,
+	WRITE_FILE: () => WRITE_FILE
+});
 var READ_FILE = "read_file";
 var WRITE_FILE = "write_file";
 var EDIT_FILE = "edit_file";
@@ -1170,18 +1193,85 @@ var REQUIRED_STRING_ARGS = {
 	[WEB_SEARCH]: ["query"],
 	[WEB_FETCH]: ["url"]
 };
+var TOOL_NAMES = new Set(Object.values(tool_exports));
+function isToolName(name) {
+	return TOOL_NAMES.has(name);
+}
 function validateArgs(name, args) {
-	const required = REQUIRED_STRING_ARGS[name] ?? [];
+	const required = REQUIRED_STRING_ARGS[name];
 	const received = Object.keys(args).join(", ") || "none";
-	for (const key of required) if (typeof args[key] !== "string") return {
+	for (const key of required) if (typeof args[key] !== "string" || !args[key]) return {
 		content: "",
 		error: `Missing required argument: ${key} (received keys: ${received})`
 	};
+	if (name === "view_range") {
+		if (!Number.isInteger(args.start) || !Number.isInteger(args.end)) return {
+			content: "",
+			error: `Missing required numeric arguments: start, end (received keys: ${received})`
+		};
+		if (args.start < 1 || args.end < args.start) return {
+			content: "",
+			error: "Invalid line range: start must be >= 1 and end must be >= start"
+		};
+	}
+	if (name === "web_fetch") try {
+		const url = new URL(args.url);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return {
+			content: "",
+			error: "URL must use http or https"
+		};
+	} catch {
+		return {
+			content: "",
+			error: "Invalid URL"
+		};
+	}
+}
+function normalizeToolCall(toolCall) {
+	const name = toolCall.function.name;
+	const rawArguments = toolCall.function.arguments;
+	if (!isToolName(name)) throw new Error(`Unknown tool: ${name}`);
+	if (typeof rawArguments !== "object" || rawArguments === null || Array.isArray(rawArguments)) throw new Error(`Invalid arguments for tool: ${name}`);
+	const normalizedArguments = rawArguments;
+	const invalid = validateArgs(name, normalizedArguments);
+	if (invalid?.error) throw new Error(invalid.error);
+	return {
+		name,
+		arguments: normalizedArguments,
+		requiresApproval: WRITE_TOOLS.has(name)
+	};
+}
+function formatToolResultContent(toolName, result) {
+	const status = result.error ? "The requested action was NOT performed" : "";
+	const content = result.content ? `\n${result.content}` : "";
+	const error = result.error ? `\nError: ${result.error}` : "";
+	return [
+		`Tool ${toolName} result:`,
+		status,
+		content.trim(),
+		error.trim()
+	].filter(Boolean).join("\n");
+}
+async function executeToolCall(toolCall, options) {
+	try {
+		const normalized = normalizeToolCall(toolCall);
+		return await executeTool(normalized.name, normalized.arguments, options);
+	} catch (error) {
+		return {
+			content: "",
+			// v8 ignore next
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
 }
 /**
 * Execute a tool by name with arguments
 */
 async function executeTool(name, args, options) {
+	if (!isToolName(name)) return {
+		content: "",
+		error: `Unknown tool: ${name}`
+	};
 	if (options?.allowedTools && !options.allowedTools.has(name)) return {
 		content: "",
 		error: `Tool not allowed: ${name}`
@@ -1199,6 +1289,7 @@ async function executeTool(name, args, options) {
 		case VIEW_RANGE: return viewRange(stringArgs.path, args.start, args.end);
 		case WEB_SEARCH: return await webSearch(stringArgs.query);
 		case WEB_FETCH: return await webFetch(stringArgs.url);
+		// v8 ignore next 2
 		default: return {
 			content: "",
 			error: `Unknown tool: ${name}`
@@ -1206,8 +1297,41 @@ async function executeTool(name, args, options) {
 	}
 }
 //#endregion
+//#region src/utils/update.ts
+var REGISTRY_URL = `https://registry.npmjs.org/${NAME}/latest`;
+function getSemver(version) {
+	return version.split(".").map(Number);
+}
+/**
+* Check if the latest version is newer than the current version
+* @param current The current version
+* @param latest The latest version
+* @returns true if the latest version is newer, false otherwise
+*/
+function isVersionNewer(current, latest) {
+	const [currentMajor, currentMinor, currentPatch] = getSemver(current);
+	const [latestMajor, latestMinor, latestPatch] = getSemver(latest);
+	if (latestMajor !== currentMajor) return latestMajor > currentMajor;
+	if (latestMinor !== currentMinor) return latestMinor > currentMinor;
+	return latestPatch > currentPatch;
+}
+/**
+* Check if a newer version is available on npm
+* @returns The latest version if available, undefined otherwise
+*/
+async function checkForUpdate() {
+	try {
+		const response = await fetch(REGISTRY_URL);
+		if (!response.ok) return;
+		const { version: latestVersion } = await response.json();
+		if (!latestVersion) return;
+		if (isVersionNewer(VERSION, latestVersion)) return latestVersion;
+	} catch {}
+}
+//#endregion
 //#region src/cli.ts
 var cli = cac("code-ollama");
+var MAX_TOOL_TURNS = 25;
 cli.version(VERSION);
 cli.help();
 cli.command("run <model> <prompt>", "Run a one-off prompt").action(async (model, prompt) => {
@@ -1240,30 +1364,40 @@ async function runPrompt(model, prompt) {
 	write("\n");
 }
 async function processRunStream(messages, model) {
-	const assistantMessage = {
-		role: ASSISTANT,
-		content: ""
-	};
-	for await (const chunk of streamChat(messages, model, TOOLS)) {
-		if (chunk.type === "content") {
-			assistantMessage.content += chunk.content;
-			write(chunk.content);
-			continue;
-		}
-		for (const toolCall of chunk.tool_calls) {
-			const result = await executeTool(toolCall.function.name, toolCall.function.arguments);
-			const toolResultMessage = {
-				role: SYSTEM,
-				content: `Tool ${toolCall.function.name} result:\n${result.content}${result.error ? `\nError: ${result.error}` : ""}`
-			};
-			await processRunStream([
-				...messages,
-				assistantMessage,
-				toolResultMessage
-			], model);
-			return;
+	let activeMessages = messages;
+	let toolTurns = 0;
+	while (toolTurns < MAX_TOOL_TURNS) {
+		const assistantMessage = {
+			role: ASSISTANT,
+			content: ""
+		};
+		let nextMessages = null;
+		for await (const chunk of streamChat(activeMessages, model, TOOLS)) {
+			if (chunk.type === "content") {
+				assistantMessage.content += chunk.content;
+				write(chunk.content);
+				continue;
+			}
+			// v8 ignore next 3
+			if (chunk.tool_calls.length === 0) continue;
+			const committedMessages = [...activeMessages, assistantMessage];
+			const toolResultMessages = [];
+			for (const toolCall of chunk.tool_calls) {
+				const result = await executeToolCall(toolCall);
+				toolResultMessages.push({
+					role: SYSTEM,
+					content: formatToolResultContent(toolCall.function.name, result)
+				});
+			}
+			nextMessages = [...committedMessages, ...toolResultMessages];
+			break;
 		}
+		if (!nextMessages) return;
+		activeMessages = nextMessages;
+		toolTurns += 1;
 	}
+	// v8 ignore next 3
+	writeError("Tool execution stopped because the maximum tool turn limit was reached\n");
 }
 async function main(args = process.argv.slice(2)) {
 	if (args.length) cli.parse([
@@ -1274,7 +1408,7 @@ async function main(args = process.argv.slice(2)) {
 	else await launchTui();
 }
 async function launchTui(sessionId) {
-	const { renderApp } = await import("./assets/tui-DDbMjcMS.js");
+	const { renderApp } = await import("./assets/tui-BHkHnKUC.js");
 	reset();
 	renderApp(sessionId);
 }
@@ -1290,4 +1424,4 @@ function isEntrypoint(argv1 = process.argv[1]) {
 if (isEntrypoint()) main();
 // v8 ignore stop
 //#endregion
-export { WARNING as A, LABEL as B, loadConfig as C, resetSystemMessage as D, saveClipboardImage as E, USER as F, VERSION as G, SAFE as H, PLAN_GENERATION_INSTRUCTION as I, LIST$1 as K, BACK as L, getTheme as M, ASSISTANT as N, withSystemMessage as O, SYSTEM as P, CATALOG as R, streamChat as S, removeClipboardImage as T, APPROVE as U, PLAN as V, REJECT as W, setClearHandler as _, tick as a, listModels as b, appendMessage as c, deleteSessionIfEmpty as d, listSessions as f, reset as g, clear as h, WRITE_TOOLS as i, LIST as j, HEADER_PREFIX as k, createSession as l, updateSessionModel as m, main, READ_TOOLS as n, color as o, loadSession as p, TOOLS as r, write as s, executeTool as t, deleteSession as u, checkHealth as v, saveConfig as w, pullModel as x, deleteModel as y, AUTO as z };
+export { saveClipboardImage as A, PLAN_GENERATION_INSTRUCTION as B, deleteModel as C, loadConfig as D, streamChat as E, LIST as F, PLAN as G, CATALOG as H, getTheme as I, REJECT as J, SAFE as K, ASSISTANT as L, withSystemMessage as M, HEADER_PREFIX as N, saveConfig as O, WARNING as P, SYSTEM as R, checkHealth as S, pullModel as T, AUTO as U, BACK as V, LABEL as W, VERSION as X, NAME as Y, LIST$1 as Z, loadSession as _, normalizeToolCall as a, reset as b, WRITE_TOOLS as c, write as d, appendMessage as f, listSessions as g, deleteSessionIfEmpty as h, formatToolResultContent as i, resetSystemMessage as j, removeClipboardImage as k, tick as l, deleteSession as m, main, executeTool as n, READ_TOOLS as o, createSession as p, APPROVE as q, executeToolCall as r, TOOLS as s, checkForUpdate as t, color as u, updateSessionModel as v, listModels as w, setClearHandler as x, clear as y, USER as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-ollama",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "Ollama coding agent that runs in your terminal",
   "author": "Mark <mark@remarkablemark.org> (https://remarkablemark.org)",
   "type": "module",
@@ -42,34 +42,34 @@
     "@inkjs/ui": "2.0.0",
     "@shikijs/cli": "4.1.0",
     "cac": "7.0.0",
-    "ink": "7.0.3",
+    "ink": "7.0.5",
     "marked": "15.0.12",
     "marked-terminal": "7.3.0",
     "ollama": "0.6.3",
-    "react": "19.2.6",
+    "react": "19.2.7",
     "uuid": "14.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "21.0.1",
-    "@commitlint/config-conventional": "21.0.1",
+    "@commitlint/cli": "21.0.2",
+    "@commitlint/config-conventional": "21.0.2",
     "@eslint/js": "10.0.1",
     "@types/node": "25.9.1",
-    "@types/react": "19.2.15",
-    "@vitest/coverage-v8": "4.1.7",
-    "eslint": "10.4.0",
-    "eslint-plugin-prettier": "5.5.5",
+    "@types/react": "19.2.16",
+    "@vitest/coverage-v8": "4.1.8",
+    "eslint": "10.4.1",
+    "eslint-plugin-prettier": "5.5.6",
     "eslint-plugin-simple-import-sort": "13.0.0",
     "globals": "17.6.0",
     "husky": "9.1.7",
     "ink-testing-library": "4.0.0",
-    "lint-staged": "17.0.5",
+    "lint-staged": "17.0.7",
     "prettier": "3.8.3",
     "publint": "0.3.21",
-    "tsx": "4.22.3",
+    "tsx": "4.22.4",
     "typescript": "6.0.3",
-    "typescript-eslint": "8.59.4",
-    "vite": "8.0.14",
-    "vitest": "4.1.7"
+    "typescript-eslint": "8.60.1",
+    "vite": "8.0.16",
+    "vitest": "4.1.8"
   },
   "files": [
     "dist/"