@oh-my-pi/pi-coding-agent 15.5.13 → 15.6.0

package/src/tools/memory-retain.ts

@@ -0,0 +1,91 @@
+import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
+import type { ToolSession } from ".";
+
+const memoryRetainSchema = z.object({
+	items: z
+		.array(
+			z.object({
+				content: z.string().describe("information to remember"),
+				context: z.string().describe("source context").optional(),
+			}),
+		)
+		.min(1)
+		.describe("memories to retain"),
+});
+
+export type MemoryRetainParams = z.infer<typeof memoryRetainSchema>;
+export class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
+	readonly name = "retain";
+	readonly approval = "read" as const;
+	readonly label = "Retain";
+	readonly description = retainDescription;
+	readonly parameters = memoryRetainSchema;
+	readonly strict = true;
+	readonly loadMode = "discoverable";
+	readonly summary = "Store important facts in long-term memory";
+
+	constructor(private readonly session: ToolSession) {}
+
+	static createIf(session: ToolSession): MemoryRetainTool | null {
+		const backend = session.settings.get("memory.backend");
+		if (backend !== "hindsight" && backend !== "mnemosyne") return null;
+		return new MemoryRetainTool(session);
+	}
+
+	async execute(_id: string, params: MemoryRetainParams): Promise<AgentToolResult> {
+		const backend = this.session.settings.get("memory.backend");
+		if (backend === "mnemosyne") {
+			const state = this.session.getMnemosyneSessionState?.();
+			if (!state) {
+				throw new Error("Mnemosyne backend is not initialised for this session.");
+			}
+
+			for (const item of params.items) {
+				state.rememberScoped(item.content, {
+					source: "coding-agent-retain",
+					importance: 0.75,
+					metadata: {
+						session_id: state.sessionId,
+						cwd: state.session.sessionManager.getCwd(),
+						context: item.context ?? null,
+						tool: "retain",
+					},
+					scope: "bank",
+					extract: true,
+					extractEntities: true,
+					veracity: "tool",
+					memoryType: "fact",
+				});
+			}
+
+			const count = params.items.length;
+			const noun = count === 1 ? "memory" : "memories";
+			return {
+				content: [{ type: "text", text: `${count} ${noun} stored.` }],
+				details: { count },
+			};
+		}
+
+		const state = this.session.getHindsightSessionState?.();
+		if (!state) {
+			throw new Error("Hindsight backend is not initialised for this session.");
+		}
+
+		// Push every item onto the session-owned queue and return immediately.
+		// The queue flushes either when it reaches its batch threshold or when
+		// its debounce timer fires. If the eventual batch fails, the queue
+		// surfaces a UI-only warning notice — the LLM is not informed.
+		for (const item of params.items) {
+			state.enqueueRetain(item.content, item.context);
+		}
+
+		const count = params.items.length;
+		const noun = count === 1 ? "memory" : "memories";
+		return {
+			content: [{ type: "text", text: `${count} ${noun} queued.` }],
+			details: { count },
+		};
+	}
+}

package/src/tools/renderers.ts

@@ -16,13 +16,13 @@ import { astEditToolRenderer } from "./ast-edit";
 import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
 import { browserToolRenderer } from "./browser/render";
-import { calculatorToolRenderer } from "./calculator";
 import { debugToolRenderer } from "./debug";
 import { evalToolRenderer } from "./eval";
 import { findToolRenderer } from "./find";
 import { githubToolRenderer } from "./gh-renderer";
 import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { jobToolRenderer } from "./job";
+import { recallToolRenderer, reflectToolRenderer, retainToolRenderer } from "./memory-render";
 import { readToolRenderer } from "./read";
 import { recipeToolRenderer } from "./recipe/render";
 import { resolveToolRenderer } from "./resolve";
@@ -54,7 +54,6 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	recipe: recipeToolRenderer as ToolRenderer,
 	debug: debugToolRenderer as ToolRenderer,
 	eval: evalToolRenderer as ToolRenderer,
-	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
 	apply_patch: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
@@ -64,6 +63,9 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	read: readToolRenderer as ToolRenderer,
 	job: jobToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,
+	retain: retainToolRenderer as ToolRenderer,
+	recall: recallToolRenderer as ToolRenderer,
+	reflect: reflectToolRenderer as ToolRenderer,
 	search_tool_bm25: searchToolBm25Renderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,

package/src/tools/todo-write.ts

@@ -35,9 +35,15 @@ export interface TodoPhase {
 	tasks: TodoItem[];
 }
 
+export interface TodoCompletionTransition {
+	phase: string;
+	content: string;
+}
+
 export interface TodoWriteToolDetails {
 	phases: TodoPhase[];
 	storage: "session" | "memory";
+	completedTasks?: TodoCompletionTransition[];
 }
 
 // =============================================================================
@@ -97,6 +103,31 @@ function clonePhases(phases: TodoPhase[]): TodoPhase[] {
 	return phases.map(phase => ({ name: phase.name, tasks: phase.tasks.map(cloneTask) }));
 }
 
+function todoTransitionKey(phase: string, content: string): string {
+	return `${phase}\u0000${content}`;
+}
+
+function getCompletionTransitions(previous: TodoPhase[], updated: TodoPhase[]): TodoCompletionTransition[] {
+	const previousStatuses = new Map<string, TodoStatus>();
+	for (const phase of previous) {
+		for (const task of phase.tasks) {
+			previousStatuses.set(todoTransitionKey(phase.name, task.content), task.status);
+		}
+	}
+
+	const transitions: TodoCompletionTransition[] = [];
+	for (const phase of updated) {
+		for (const task of phase.tasks) {
+			if (task.status !== "completed") continue;
+			const previousStatus = previousStatuses.get(todoTransitionKey(phase.name, task.content));
+			if (previousStatus && previousStatus !== "completed") {
+				transitions.push({ phase: phase.name, content: task.content });
+			}
+		}
+	}
+	return transitions;
+}
+
 function normalizeInProgressTask(phases: TodoPhase[]): void {
 	const orderedTasks = phases.flatMap(phase => phase.tasks);
 	if (orderedTasks.length === 0) return;
@@ -577,13 +608,16 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoWriteToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
-		const { phases: updated, errors } = applyParams(previousPhases, params);
+		const { phases: updated, errors } = applyParams(clonePhases(previousPhases), params);
+		const completedTasks = getCompletionTransitions(previousPhases, updated);
 		this.session.setTodoPhases?.(updated);
 		const storage = this.session.getSessionFile() ? "session" : "memory";
+		const details: TodoWriteToolDetails = { phases: updated, storage };
+		if (completedTasks.length > 0) details.completedTasks = completedTasks;
 
 		return {
 			content: [{ type: "text", text: formatSummary(updated, errors) }],
-			details: { phases: updated, storage },
+			details,
 			isError: errors.length > 0 ? true : undefined,
 		};
 	}
@@ -667,16 +701,55 @@ function noteMarker(count: number, uiTheme: Theme): string {
 	return uiTheme.fg("dim", chalk.italic(` \u207a${toSuperscript(count)}`));
 }
 
-function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
+export const TODO_WRITE_STRIKE_HOLD_FRAMES = 2;
+export const TODO_WRITE_STRIKE_REVEAL_FRAMES = 12;
+export const TODO_WRITE_STRIKE_TOTAL_FRAMES = TODO_WRITE_STRIKE_HOLD_FRAMES + TODO_WRITE_STRIKE_REVEAL_FRAMES;
+const EMPTY_COMPLETION_KEYS = new Set<string>();
+const STRIKE_START = "\x1b[9m";
+const STRIKE_END = "\x1b[29m";
+
+function strikethroughText(text: string): string {
+	return `${STRIKE_START}${text}${STRIKE_END}`;
+}
+
+function partialStrikethrough(text: string, visibleChars: number): string {
+	if (visibleChars <= 0) return text;
+	const chars = [...text];
+	if (visibleChars >= chars.length) return strikethroughText(text);
+	return `${strikethroughText(chars.slice(0, visibleChars).join(""))}${chars.slice(visibleChars).join("")}`;
+}
+
+function strikeRevealCount(text: string, frame: number | undefined): number | undefined {
+	if (frame === undefined) return undefined;
+	if (frame <= TODO_WRITE_STRIKE_HOLD_FRAMES) return 0;
+	const chars = [...text];
+	if (chars.length === 0) return undefined;
+	const revealFrame = Math.min(frame - TODO_WRITE_STRIKE_HOLD_FRAMES, TODO_WRITE_STRIKE_REVEAL_FRAMES);
+	return Math.ceil((chars.length * revealFrame) / TODO_WRITE_STRIKE_REVEAL_FRAMES);
+}
+
+function formatTodoLine(
+	item: TodoItem,
+	uiTheme: Theme,
+	prefix: string,
+	completionKeys: Set<string>,
+	frame: number | undefined,
+): string {
 	const checkbox = uiTheme.checkbox;
 	const marker = noteMarker(item.notes?.length ?? 0, uiTheme);
 	switch (item.status) {
-		case "completed":
-			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`) + marker;
+		case "completed": {
+			const revealCount = completionKeys.has(item.content) ? strikeRevealCount(item.content, frame) : undefined;
+			const content =
+				revealCount === undefined
+					? strikethroughText(item.content)
+					: partialStrikethrough(item.content, revealCount);
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`) + marker;
+		}
 		case "in_progress":
 			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`) + marker;
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(item.content)}`) + marker;
 		default:
 			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`) + marker;
 	}
@@ -722,6 +795,16 @@ export const todoWriteToolRenderer = {
 		_args?: TodoWriteRenderArgs,
 	): Component {
 		const phases = (result.details?.phases ?? []).filter(phase => phase.tasks.length > 0);
+		const completedTasks = result.details?.completedTasks ?? [];
+		const completionKeysByPhase = new Map<string, Set<string>>();
+		for (const task of completedTasks) {
+			let keys = completionKeysByPhase.get(task.phase);
+			if (!keys) {
+				keys = new Set<string>();
+				completionKeysByPhase.set(task.phase, keys);
+			}
+			keys.add(task.content);
+		}
 		const allTasks = phases.flatMap(phase => phase.tasks);
 		const header = renderStatusLine(
 			{ icon: "success", title: "Todo Write", meta: [`${allTasks.length} tasks`] },
@@ -732,29 +815,45 @@ export const todoWriteToolRenderer = {
 			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
-		const { expanded } = options;
-		const lines: string[] = [header];
-		for (let p = 0; p < phases.length; p++) {
-			const phase = phases[p];
-			if (phases.length > 1) {
-				lines.push(uiTheme.fg("accent", chalk.bold(`  ${formatPhaseDisplayName(phase.name, p + 1)}`)));
-			}
-			const treeLines = renderTreeList(
-				{
-					items: phase.tasks,
-					expanded,
-					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-					itemType: "todo",
-					renderItem: todo => formatTodoLine(todo, uiTheme, ""),
-				},
-				uiTheme,
-			);
-			for (const line of treeLines) {
-				lines.push(`  ${line}`);
-			}
-		}
-		lines.push(...renderNoteAttachments(phases, uiTheme));
-		return new Text(lines.join("\n"), 0, 0);
+		let cachedKey: string | undefined;
+		let cachedLines: string[] | undefined;
+		return {
+			invalidate(): void {
+				cachedKey = undefined;
+				cachedLines = undefined;
+			},
+			render(width: number): string[] {
+				const { expanded, spinnerFrame } = options;
+				const key = `${expanded ? 1 : 0}:${spinnerFrame ?? -1}:${width}`;
+				if (cachedKey === key && cachedLines) return cachedLines;
+
+				const lines: string[] = [header];
+				for (let p = 0; p < phases.length; p++) {
+					const phase = phases[p];
+					if (phases.length > 1) {
+						lines.push(uiTheme.fg("accent", chalk.bold(`  ${formatPhaseDisplayName(phase.name, p + 1)}`)));
+					}
+					const completionKeys = completionKeysByPhase.get(phase.name) ?? EMPTY_COMPLETION_KEYS;
+					const treeLines = renderTreeList(
+						{
+							items: phase.tasks,
+							expanded,
+							maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+							itemType: "todo",
+							renderItem: todo => formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame),
+						},
+						uiTheme,
+					);
+					for (const line of treeLines) {
+						lines.push(`  ${line}`);
+					}
+				}
+				lines.push(...renderNoteAttachments(phases, uiTheme));
+				cachedKey = key;
+				cachedLines = lines;
+				return lines;
+			},
+		};
 	},
 	mergeCallAndResult: true,
 };

package/src/tools/tool-result.ts

@@ -12,6 +12,7 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 	#details: TDetails;
 	#meta = outputMeta();
 	#content: ToolContent = [];
+	#isError = false;
 
 	constructor(details?: TDetails) {
 		this.#details = details ?? ({} as TDetails);
@@ -67,6 +68,12 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return this;
 	}
 
+	/** Flag the result as a non-throwing failure (agent-loop surfaces it as a tool error). */
+	error(value = true): this {
+		this.#isError = value;
+		return this;
+	}
+
 	done(): AgentToolResult<TDetails> {
 		const meta = this.#meta.get();
 		if (meta) {
@@ -77,6 +84,7 @@ export class ToolResultBuilder<TDetails extends DetailsWithMeta> {
 		return {
 			content: this.#content,
 			details: hasDetails ? this.#details : undefined,
+			...(this.#isError ? { isError: true } : {}),
 		};
 	}
 }

package/src/utils/title-generator.ts

@@ -9,13 +9,16 @@ import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import { ONLINE_TINY_TITLE_MODEL_KEY } from "../tiny/models";
+import { formatTitleUserMessage, normalizeGeneratedTitle } from "../tiny/text";
+import { tinyTitleClient } from "../tiny/title-client";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
 
 const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
-const MAX_INPUT_CHARS = 2000;
+export const TITLE_LOCAL_FALLBACK_DELAY_MS = 10_000;
 const TITLE_MAX_TOKENS = 30;
 const REASONING_SAFE_MAX_TOKENS = 1024;
 const SET_TITLE_TOOL_NAME = "set_title";
@@ -48,6 +51,78 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	return undefined;
 }
 
+export async function raceFirstNonNull<T>(
+	primary: Promise<T | null>,
+	startFallback: () => Promise<T | null>,
+	delayMs: number = TITLE_LOCAL_FALLBACK_DELAY_MS,
+	onPrimaryWinAfterFallback?: () => void,
+): Promise<T | null> {
+	const { promise, resolve } = Promise.withResolvers<T | null>();
+	let resolved = false;
+	let primarySettled = false;
+	let fallbackStarted = false;
+	let fallbackSettled = false;
+
+	const resolveOnce = (value: T | null): void => {
+		if (resolved) return;
+		resolved = true;
+		resolve(value);
+	};
+	const maybeResolveNull = (): void => {
+		if (primarySettled && fallbackStarted && fallbackSettled) resolveOnce(null);
+	};
+	const startFallbackOnce = (): void => {
+		if (fallbackStarted || resolved) return;
+		fallbackStarted = true;
+		let fallback: Promise<T | null>;
+		try {
+			fallback = startFallback();
+		} catch {
+			fallbackSettled = true;
+			maybeResolveNull();
+			return;
+		}
+		void fallback.then(
+			value => {
+				fallbackSettled = true;
+				if (value !== null) resolveOnce(value);
+				else maybeResolveNull();
+			},
+			() => {
+				fallbackSettled = true;
+				maybeResolveNull();
+			},
+		);
+	};
+
+	const timer = setTimeout(startFallbackOnce, delayMs);
+	void primary.then(
+		value => {
+			primarySettled = true;
+			clearTimeout(timer);
+			if (value !== null) {
+				if (fallbackStarted) onPrimaryWinAfterFallback?.();
+				resolveOnce(value);
+				return;
+			}
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+		() => {
+			primarySettled = true;
+			clearTimeout(timer);
+			startFallbackOnce();
+			maybeResolveNull();
+		},
+	);
+
+	try {
+		return await promise;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /**
  * Generate a title for a session based on the first user message.
  *
@@ -68,6 +143,41 @@ export async function generateSessionTitle(
 	sessionId?: string,
 	currentModel?: Model<Api>,
 	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const tinyModel = settings.get("providers.tinyModel");
+	if (tinyModel === ONLINE_TINY_TITLE_MODEL_KEY) {
+		return generateTitleOnline(firstMessage, registry, settings, sessionId, currentModel, metadataResolver);
+	}
+
+	const onlineAbortController = new AbortController();
+	const localTitle = tinyTitleClient.generate(tinyModel, firstMessage).then(
+		title => title || null,
+		() => null,
+	);
+	const startOnline = (): Promise<string | null> =>
+		generateTitleOnline(
+			firstMessage,
+			registry,
+			settings,
+			sessionId,
+			currentModel,
+			metadataResolver,
+			onlineAbortController.signal,
+		);
+
+	return raceFirstNonNull(localTitle, startOnline, TITLE_LOCAL_FALLBACK_DELAY_MS, () => {
+		onlineAbortController.abort();
+	});
+}
+
+export async function generateTitleOnline(
+	firstMessage: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+	signal?: AbortSignal,
 ): Promise<string | null> {
 	const model = getTitleModel(registry, settings, currentModel);
 	if (!model) {
@@ -75,12 +185,7 @@ export async function generateSessionTitle(
 		return null;
 	}
 
-	// Truncate message if too long
-	const truncatedMessage =
-		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
-	const userMessage = `<user-message>
-${truncatedMessage}
-</user-message>`;
+	const userMessage = formatTitleUserMessage(firstMessage);
 
 	const apiKey = await registry.getApiKey(model, sessionId);
 	if (!apiKey) {
@@ -122,6 +227,7 @@ ${truncatedMessage}
 				disableReasoning: true,
 				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
 				metadata,
+				signal,
 			},
 		);
 
@@ -134,7 +240,7 @@ ${truncatedMessage}
 			return null;
 		}
 
-		const title = extractGeneratedTitle(response.content);
+		const title = normalizeGeneratedTitle(extractGeneratedTitle(response.content));
 
 		logger.debug("title-generator: response", {
 			model: request.model,
@@ -143,11 +249,7 @@ ${truncatedMessage}
 			stopReason: response.stopReason,
 		});
 
-		if (!title) {
-			return null;
-		}
-
-		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+		return title;
 	} catch (err) {
 		logger.debug("title-generator: error", {
 			model: request.model,

package/dist/types/tools/calculator.d.ts

@@ -1,77 +0,0 @@
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import * as z from "zod/v4";
-import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme } from "../modes/theme/theme";
-import type { ToolSession } from ".";
-declare const calculatorSchema: z.ZodObject<{
-    calculations: z.ZodArray<z.ZodObject<{
-        expression: z.ZodString;
-        prefix: z.ZodString;
-        suffix: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export interface CalculatorToolDetails {
-    results: Array<{
-        expression: string;
-        value: number;
-        output: string;
-    }>;
-}
-type CalculatorParams = z.infer<typeof calculatorSchema>;
-/**
- * Calculator tool for evaluating mathematical expressions.
- *
- * Supports decimal, hex (0x), binary (0b), octal (0o) literals,
- * standard arithmetic operators, and parentheses.
- */
-export declare class CalculatorTool implements AgentTool<typeof calculatorSchema, CalculatorToolDetails> {
-    readonly name = "calc";
-    readonly approval: "read";
-    readonly label = "Calc";
-    readonly summary = "Evaluate a mathematical expression";
-    readonly loadMode = "discoverable";
-    readonly description: string;
-    readonly parameters: z.ZodObject<{
-        calculations: z.ZodArray<z.ZodObject<{
-            expression: z.ZodString;
-            prefix: z.ZodString;
-            suffix: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    readonly strict = true;
-    constructor(_session: ToolSession);
-    execute(_toolCallId: string, { calculations }: CalculatorParams, signal?: AbortSignal): Promise<AgentToolResult<CalculatorToolDetails>>;
-}
-interface CalculatorRenderArgs {
-    calculations?: Array<{
-        expression: string;
-        prefix?: string;
-        suffix?: string;
-    }>;
-}
-/**
- * TUI renderer for calculator tool calls and results.
- * Handles both collapsed (preview) and expanded (full) display modes.
- */
-export declare const calculatorToolRenderer: {
-    /**
-     * Render the tool call header showing the first expression and count.
-     * Format: "Calc <expression> (N calcs)"
-     */
-    renderCall(args: CalculatorRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
-    /**
-     * Render calculation results as a tree list.
-     * Collapsed mode shows first N items with expand hint; expanded shows all.
-     */
-    renderResult(result: {
-        content: Array<{
-            type: string;
-            text?: string;
-        }>;
-        details?: CalculatorToolDetails;
-        isError?: boolean;
-    }, options: RenderResultOptions, uiTheme: Theme, args?: CalculatorRenderArgs): Component;
-    mergeCallAndResult: boolean;
-};
-export {};

package/src/prompts/tools/calculator.md

@@ -1,10 +0,0 @@
-Performs basic calculations.
-
-<instruction>
-- Supports +, -, *, /, %, ** and parentheses
-- Supports decimal, hex (0x), binary (0b), and octal (0o) literals
-</instruction>
-
-<output>
-Returns each calculation result with its prefix and suffix applied.
-</output>