agent-termo 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-termo",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Terminal-based AI coding agent that replicates Claude Code experience",
   "type": "module",
   "main": "dist/main.js",

package/src/agents/index.ts

@@ -12,7 +12,7 @@ function parseAgentMeta(content: string): { description: string; tools: string[]
   const toolsStr = toolsMatch?.[1] ?? '';
   const tools = toolsStr
     ? toolsStr.split(',').map((t) => t.trim().replace(/^["']|["']$/g, ''))
-    : ['file:read', 'file:write', 'file:edit', 'file:glob', 'grep', 'bash:execute', 'git:status', 'git:commit', 'git:push', 'git:log'];
+    : ['file:read', 'file:write', 'file:edit', 'file:delete', 'file:glob', 'grep', 'bash:execute', 'git:status', 'git:commit', 'git:push', 'git:log'];
   return { description: descMatch?.[1]?.trim() ?? '', tools };
 }
 
@@ -68,6 +68,7 @@ Available functions:
 - file:read(path) → read a file
 - file:write(path, content) → overwrite a file completely
 - file:edit(path, old_string, new_string) → edit a specific line section
+- file:delete(path) → delete a file after explicit user instruction
 - file:glob(pattern) → list files matching a glob (e.g. "src/**/*.ts")
 - grep(pattern, path, glob?) → search for text in files
 - bash:execute(command) → run a shell command
@@ -91,4 +92,4 @@ export function buildSystemPrompt(memory: string, timeline: string, _agentDir: s
   }
 
   return prompt;
-}
+}

package/src/cli.ts

@@ -96,7 +96,7 @@ async function startAgent(
 program
   .name('agent-termo')
   .description('Terminal AI coding agent with Nvidia NIM APIs')
-  .version('1.0.2')
+  .version('1.0.3')
   .argument('[project]', 'Project directory to operate in', process.cwd())
   .option('-k, --api-key <key>', 'Nvidia NIM API key')
   .option('-m, --model <model>', 'Model name to use')

package/src/llm/client.ts

@@ -8,6 +8,27 @@ import { mergeModels, type ModelInfo } from './models.js';
 
 type NIMTool = OpenAI.Chat.ChatCompletionTool;
 
+const TOOL_NAME_ALIASES: Record<string, string> = {
+	'file:read': 'file_read',
+	'file:write': 'file_write',
+	'file:edit': 'file_edit',
+	'file:delete': 'file_delete',
+	'file:glob': 'file_glob',
+	'bash:execute': 'bash_execute',
+	'git:status': 'git_status',
+	'git:commit': 'git_commit',
+	'git:push': 'git_push',
+	'git:log': 'git_log',
+};
+
+export function toWireToolName(name: string): string {
+	return TOOL_NAME_ALIASES[name] ?? name.replace(/:/g, '_');
+}
+
+export function fromWireToolName(name: string): string {
+	return Object.entries(TOOL_NAME_ALIASES).find(([, wireName]) => wireName === name)?.[0] ?? name;
+}
+
 export class NimClient {
   private client: OpenAI;
   private model: string;
@@ -30,7 +51,7 @@ export class NimClient {
     return toolSchemas.map((t) => ({
       type: 'function' as const,
       function: {
-        name: t.name,
+			name: toWireToolName(t.name),
         description: t.description,
         parameters: t.parameters as unknown as NIMTool['function']['parameters'],
       },
@@ -69,7 +90,7 @@ export class NimClient {
    * Handles Stepfun's quirks: filters "null" reasoning chunks, strips reasoning field.
    * Yields { content, toolCalls } at the end with clean text.
    */
-  async *streamComplete(
+	async *streamComplete(
     messages: ConversationMessage[],
     tools?: NIMTool[],
     onChunk?: (text: string) => void,
@@ -79,15 +100,26 @@ export class NimClient {
 
     const stream = await this.client.chat.completions.create({
       model: this.model,
-      messages: messages.map((m) => {
-        if (m.role === 'tool') {
-          return {
-            role: 'tool' as const,
-            content: m.content,
-            tool_call_id: m.id,
-          };
-        }
-        return {
+		messages: messages.map((m) => {
+			if (m.role === 'tool') {
+				return {
+					role: 'tool' as const,
+					content: m.content,
+					tool_call_id: m.id,
+				};
+			}
+			if (m.role === 'assistant' && m.toolCalls?.length) {
+				return {
+					role: 'assistant' as const,
+					content: m.content || null,
+					tool_calls: m.toolCalls.map((tc) => ({
+						id: tc.id,
+						type: 'function' as const,
+						function: { name: toWireToolName(tc.name), arguments: JSON.stringify(tc.arguments) },
+					})),
+				};
+			}
+			return {
           role: m.role as 'system' | 'user' | 'assistant',
           content: m.content,
         };
@@ -143,7 +175,7 @@ export class NimClient {
       } catch {
         args = { _raw: tc.arguments };
       }
-      return { id: tc.id, name: tc.name, arguments: args };
+			return { id: tc.id, name: fromWireToolName(tc.name), arguments: args };
     });
 
     yield { content: finalContent, toolCalls };
@@ -158,11 +190,22 @@ export class NimClient {
   ): Promise<{ content: string; toolCalls: ToolCall[] }> {
     const response = await this.client.chat.completions.create({
       model: this.model,
-      messages: messages.map((m) => {
-        if (m.role === 'tool') {
-          return { role: 'tool' as const, content: m.content, tool_call_id: m.id };
-        }
-        return { role: m.role as 'system' | 'user' | 'assistant', content: m.content };
+		messages: messages.map((m) => {
+			if (m.role === 'tool') {
+				return { role: 'tool' as const, content: m.content, tool_call_id: m.id };
+			}
+			if (m.role === 'assistant' && m.toolCalls?.length) {
+				return {
+					role: 'assistant' as const,
+					content: m.content || null,
+					tool_calls: m.toolCalls.map((tc) => ({
+						id: tc.id,
+						type: 'function' as const,
+						function: { name: toWireToolName(tc.name), arguments: JSON.stringify(tc.arguments) },
+					})),
+				};
+			}
+			return { role: m.role as 'system' | 'user' | 'assistant', content: m.content };
       }),
       tools: tools,
       temperature: 0.3,
@@ -185,7 +228,7 @@ export class NimClient {
       } catch {
         args = { _raw: tc.function.arguments };
       }
-      return { id: tc.id, name: tc.function.name, arguments: args };
+			return { id: tc.id, name: fromWireToolName(tc.function.name), arguments: args };
     });
 
     // If no tool calls but content looks like a tool call request, parse it
@@ -195,7 +238,7 @@ export class NimClient {
         if (parsed.tool_calls?.length) {
           toolCalls.push(...parsed.tool_calls.map((tc: { id?: string; name?: string; function?: { name?: string; arguments?: unknown } }) => ({
             id: tc.id ?? crypto.randomUUID(),
-            name: tc.function?.name ?? tc.name ?? '',
+				name: fromWireToolName(tc.function?.name ?? tc.name ?? ''),
             arguments: typeof tc.function?.arguments === 'string'
               ? JSON.parse(tc.function.arguments)
               : tc.function?.arguments ?? {},
@@ -213,4 +256,4 @@ export class NimClient {
   }
 }
 
-export { type ToolDef } from '../types/index.js';
+export { type ToolDef } from '../types/index.js';

package/src/llm/tools.ts

@@ -67,12 +67,26 @@ export const TOOL_DEFINITIONS: ToolDef[] = [
           type: 'string',
           description: 'Replacement text',
         },
-      },
-      required: ['path', 'old_string', 'new_string'],
-    },
-  },
-  {
-    name: 'file:glob',
+			},
+			required: ['path', 'old_string', 'new_string'],
+		},
+	},
+	{
+		name: 'file:delete',
+		description: 'Delete a file from the project. Use only when the user explicitly asks to remove it.',
+		parameters: {
+			type: 'object',
+			properties: {
+				path: {
+					type: 'string',
+					description: 'File path to delete (relative to project root)',
+				},
+			},
+			required: ['path'],
+		},
+	},
+	{
+		name: 'file:glob',
     description: 'Find all files matching a glob pattern. Use to discover project structure.',
     parameters: {
       type: 'object',
@@ -203,4 +217,4 @@ export const TOOL_DEFINITIONS: ToolDef[] = [
       },
     },
   },
-];
+];

package/src/main.ts

@@ -2,7 +2,7 @@
 // Agent-Termo — Main REPL entry point
 // =============================================================================
 
-import { NimClient } from './llm/client.js';
+import { NimClient, fromWireToolName } from './llm/client.js';
 import { TOOL_DEFINITIONS } from './llm/tools.js';
 import { executeTool, applyFileChange } from './tools/index.js';
 import { loadMemory, logToTimeline, logAgentTermoTimeline } from './memory/index.js';
@@ -42,16 +42,6 @@ const TOOL_KEYWORDS = [
 	'test', 'compile', 'typescript', 'javascript', 'python', 'node', 'add', 'delete',
 ];
 
-/**
- * Tool-capable models to try when the active model rejects the `tools` parameter.
- * Ordered by preference; first one that accepts tool calls wins.
- */
-const TOOL_MODELS = [
-	'qwen/qwen2.5-coder-32b-instruct',
-	'moonshotai/kimi-k2-instruct',
-	'meta/llama-3.1-405b-instruct',
-];
-
 function mightNeedTools(message: string): boolean {
 	const lower = message.toLowerCase();
 	return TOOL_KEYWORDS.some((w) => lower.includes(w));
@@ -66,31 +56,6 @@ function dedup(arr: ToolCall[]): ToolCall[] {
 	});
 }
 
-/**
- * Try each tool-capable model in TOOL_MODELS order until one accepts the
- * `tools` parameter. Restores the original model in a finally block.
- * Returns the first successful result, or null if all models fail.
- */
-async function tryToolModels(
-	conversation: ConversationMessage[],
-	nimClient: NimClient,
-	originalModel: string,
-): Promise<{ content: string; toolCalls: ToolCall[] } | null> {
-	for (const toolModel of TOOL_MODELS) {
-		if (toolModel === originalModel) continue;
-		try {
-			nimClient.setModel(toolModel);
-			const tools = nimClient.buildToolDefs(TOOL_DEFINITIONS);
-			const result = await nimClient.complete(conversation, tools);
-			return result;
-		} catch {
-			// Try the next model
-		}
-	}
-	nimClient.setModel(originalModel);
-	return null;
-}
-
 /**
  * Get a plain-text assistant response without tool calling: stream first, fall
  * back to a single non-streaming completion. Appends the assistant message to
@@ -136,8 +101,42 @@ async function replyWithText(
 	}
 }
 
+/**
+ * Parse JSON tool calls that a non-tool-calling model may emit as plain text,
+ * e.g. {"tool_calls":[{"id":"call_1","name":"file:write","arguments":{...}}]}.
+ * Returns an empty array when nothing parseable is found.
+ */
+function parseToolCallsFromText(text: string): ToolCall[] {
+	let cleaned = (text ?? '').trim();
+	cleaned = cleaned.replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/i, '').trim();
+
+	let obj: { tool_calls?: unknown };
+	try {
+		obj = JSON.parse(cleaned);
+	} catch {
+		const start = cleaned.indexOf('{');
+		const end = cleaned.lastIndexOf('}');
+		if (start === -1 || end === -1 || end <= start) return [];
+		try {
+			obj = JSON.parse(cleaned.slice(start, end + 1));
+		} catch {
+			return [];
+		}
+	}
+
+	const rawCalls = Array.isArray(obj.tool_calls) ? obj.tool_calls : [];
+	return rawCalls.map((tc: { id?: string; name?: string; function?: { name?: string; arguments?: unknown } }) => ({
+		id: tc.id ?? crypto.randomUUID(),
+		name: fromWireToolName(tc.name ?? (tc.function?.name ?? '')),
+		arguments:
+			typeof tc.function?.arguments === 'string'
+				? (() => { try { return JSON.parse(tc.function.arguments as string); } catch { return { _raw: tc.function.arguments }; } })()
+				: (tc.function?.arguments ?? {}),
+	}));
+}
+
 function extractProposedChange(toolName: string, resultOutput: string): ProposedFileChange | undefined {
-	const isFileTool = toolName === 'file:write' || toolName === 'file:edit';
+	const isFileTool = toolName === 'file:write' || toolName === 'file:edit' || toolName === 'file:delete';
 	if (!isFileTool) return undefined;
 	try {
 		const parsed = JSON.parse(resultOutput);
@@ -258,6 +257,17 @@ async function runToolLoop(
 
 	// Continue looping while the LLM keeps issuing tool calls
 	while (toolCalls.length > 0) {
+		// OpenAI-compatible APIs require the assistant tool-call message directly
+		// before the corresponding tool results. Without this message, the next
+		// request is rejected and file operations appear not to work.
+		conversation.push({
+			id: crypto.randomUUID(),
+			role: 'assistant',
+			content: finalText || '',
+			toolCalls,
+			timestamp: new Date(),
+		});
+
 		// Execute all tool calls from this turn
 		for (const tc of toolCalls) {
 			const execution = await executeToolWithReview(tc.name, tc.arguments, projectRoot, input);
@@ -266,9 +276,9 @@ async function runToolLoop(
 			const statusText = toolResult.success ? 'OK' : ('ERR: ' + (toolResult.error ? toolResult.error.slice(0, 80) : 'unknown error'));
 			const changeNote = execution.change ? (execution.applied ? ' (applied)' : ' (rejected)') : '';
 
-			conversation.push({
-				id: crypto.randomUUID(),
-				role: 'tool',
+				conversation.push({
+					id: tc.id,
+					role: 'tool',
 				content: (toolResult.success ? 'Result: ' : 'Error: ') + (toolResult.success ? (toolResult.output ?? '') : toolResult.error) + changeNote,
 				timestamp: new Date(),
 			});
@@ -280,22 +290,22 @@ async function runToolLoop(
 		// Send conversation (including tool results) back to the LLM
 		// The LLM will either produce text or more tool calls
 		startSpinner('Working');
-		let result: { content: string; toolCalls: ToolCall[] } | null;
+		let result: { content: string; toolCalls: ToolCall[] };
 		try {
 			const tools = nimClient.buildToolDefs(TOOL_DEFINITIONS);
 			result = await nimClient.complete(conversation, tools);
 		} catch {
-			// Model doesn't support native tool calling — try tool-capable
-			// models in order, then restore the original model.
-			const originalModel = nimClient.getModel();
+			// Model doesn't support native tool calling — fall back to plain text
+			// and parse any JSON tool calls emitted in the content.
 			try {
-				result = await tryToolModels(conversation, nimClient, originalModel);
-			} finally {
-				nimClient.setModel(originalModel);
-			}
-			if (!result) {
+				const fallback = await nimClient.complete(conversation, undefined);
+				result = {
+					content: fallback.content,
+					toolCalls: parseToolCallsFromText(fallback.content),
+				};
+			} catch (err2) {
 				stopSpinner();
-				printError('LLM error: no tool-capable model available');
+				printError('LLM error: ' + (err2 instanceof Error ? err2.message : String(err2)));
 				break;
 			}
 		}
@@ -306,12 +316,14 @@ async function runToolLoop(
 
 		// If the LLM produced text alongside tool calls, save it
 		if (finalText && finalText.trim() && finalText.trim() !== 'null') {
-			conversation.push({
-				id: crypto.randomUUID(),
-				role: 'assistant',
-				content: finalText.trim(),
-				timestamp: new Date(),
-			});
+				if (toolCalls.length === 0) {
+					conversation.push({
+						id: crypto.randomUUID(),
+						role: 'assistant',
+						content: finalText.trim(),
+						timestamp: new Date(),
+					});
+				}
 			// Narration that comes with more tool calls is shown now; the
 			// final answer (no tool calls) is printed by the caller.
 			if (toolCalls.length > 0) printAssistantMessage(finalText.trim());
@@ -507,39 +519,33 @@ export async function runRepl(projectRoot?: string): Promise<void> {
 				} catch (err) {
 					stopSpinner();
 					// Tool calling failed (e.g. HTTP 400 because the model does not
-					// support the `tools` parameter). Try tool-capable models in order,
-					// execute the tools, then restore the original model.
-					const originalModel = nimClient.getModel();
-					let toolResult: { content: string; toolCalls: ToolCall[] } | null = null;
+					// support the `tools` parameter). Retry without tools and parse
+					// any JSON tool calls the model may have emitted as plain text.
+					printInfo('Tool calls not supported by this model — retrying without tools.');
 					try {
-						toolResult = await tryToolModels(conversation, nimClient, originalModel);
-					} finally {
-						nimClient.setModel(originalModel);
-					}
-					if (!toolResult) {
+						const fallback = await nimClient.complete(conversation, undefined);
+						const toolCalls = dedup(
+							fallback.toolCalls.length > 0 ? fallback.toolCalls : parseToolCallsFromText(fallback.content),
+						);
+						if (toolCalls.length > 0) {
+							const narration = (fallback.content ?? '').trim().replace(/^null$/, '').trim();
+							if (narration && !narration.includes('"tool_calls"')) printAssistantMessage(narration);
+							const finalText = await runToolLoop(conversation, projectRoot, toolCalls, input, nimClient);
+							if (finalText && finalText.trim() && finalText.trim() !== 'null') {
+								printAssistantMessage(finalText.trim());
+							}
+						} else {
+							const cleanText = (fallback.content ?? '').trim().replace(/^null$/, '').trim();
+							if (cleanText) {
+								conversation.push({ id: crypto.randomUUID(), role: 'assistant', content: cleanText, timestamp: new Date() });
+								printAssistantMessage(cleanText);
+							}
+							}
+					} catch (err2) {
+						printError('LLM error: ' + (err2 instanceof Error ? err2.message : String(err2)));
 						conversation.pop();
 						continue mainLoop;
 					}
-					const fullText = toolResult.content;
-					let toolCalls = dedup(toolResult.toolCalls);
-					if (fullText && fullText.trim() && fullText.trim() !== 'null') {
-						conversation.push({
-							id: crypto.randomUUID(),
-							role: 'assistant',
-							content: fullText.trim(),
-							timestamp: new Date(),
-						});
-					}
-					if (toolCalls.length > 0) {
-						const narration = fullText.trim().replace(/^null$/, '').trim();
-						if (narration) printAssistantMessage(narration);
-						const finalText = await runToolLoop(conversation, projectRoot, toolCalls, input, nimClient);
-						if (finalText && finalText.trim() && finalText.trim() !== 'null') {
-							printAssistantMessage(finalText.trim());
-						}
-					} else if (fullText && fullText.trim()) {
-						printAssistantMessage(fullText.trim());
-					}
 				}
 			} else {
 				await replyWithText(conversation, nimClient);

package/src/memory/index.ts

@@ -72,23 +72,41 @@ export async function loadMemory(projectRoot: string): Promise<string> {
 }
 
 export async function appendToMemory(projectRoot: string, entry: string): Promise<void> {
- const path = resolve(projectRoot, 'docs', 'MEMORY.md');
+ let path: string;
+ try {
+   path = ensureProjectDocs(projectRoot).memoryPath;
+ } catch {
+   return;
+ }
  const timestamp = new Date().toISOString().split('T')[0];
- appendFile(path, '\n\n## ' + timestamp + '\n\n' + entry, 'utf-8');
+ try {
+   appendFile(path, '\n\n## ' + timestamp + '\n\n' + entry, 'utf-8');
+ } catch {
+   // Project memory persistence must not crash the agent.
+ }
 }
 
 // ── Timeline System ──────────────────────────────────────────────────────────
 
 const TIMELINE_TEMPLATE = '# Project Timeline\n\nThis document tracks the complete chronological history of the project.\n\n---\n\n';
+const MEMORY_TEMPLATE = '# Project Memory\n\n## Project Context\n(Add project context here)\n';
+
+function ensureProjectDocs(projectRoot: string): { memoryPath: string; timelinePath: string } {
+ const docsDir = resolve(projectRoot, 'docs');
+ const memoryPath = resolve(docsDir, 'MEMORY.md');
+ const timelinePath = resolve(docsDir, 'TIMELINE.md');
+
+ mkdirSync(docsDir, { recursive: true });
+ if (!existsSync(memoryPath)) writeFile(memoryPath, MEMORY_TEMPLATE, 'utf-8');
+ if (!existsSync(timelinePath)) writeFile(timelinePath, TIMELINE_TEMPLATE, 'utf-8');
+ return { memoryPath, timelinePath };
+}
 
 export async function loadTimeline(projectRoot: string): Promise<string> {
- const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
- if (!existsSync(path)) {
-   try {
-     writeFile(path, TIMELINE_TEMPLATE, 'utf-8');
-   } catch {
-     // ignore
-   }
+ let path: string;
+ try {
+   path = ensureProjectDocs(projectRoot).timelinePath;
+ } catch {
    return '';
  }
  try {
@@ -105,7 +123,12 @@ export async function appendToTimeline(
  actions: string[],
  notes: string[] = [],
 ): Promise<void> {
- const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
+ let path: string;
+ try {
+   path = ensureProjectDocs(projectRoot).timelinePath;
+ } catch {
+   return;
+ }
  const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
 
  const entry =
@@ -120,11 +143,24 @@ export async function appendToTimeline(
    '\n\n### Notes\n' +
    (notes.length > 0 ? notes.map((n) => '- ' + n).join('\n') : '- (none)');
 
- appendFile(path, entry, 'utf-8');
+ try {
+   appendFile(path, entry, 'utf-8');
+ } catch {
+   // Project logging must never prevent the agent from starting.
+ }
 }
 
 export async function logToTimeline(projectRoot: string, message: string): Promise<void> {
- const path = resolve(projectRoot, 'docs', 'TIMELINE.md');
+ let path: string;
+ try {
+   path = ensureProjectDocs(projectRoot).timelinePath;
+ } catch {
+   return;
+ }
  const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 16);
- appendFile(path, '\n- [' + timestamp + '] ' + message, 'utf-8');
+ try {
+   appendFile(path, '\n- [' + timestamp + '] ' + message, 'utf-8');
+ } catch {
+   // Project logging must never prevent the agent from starting.
+ }
 }

package/src/tools/index.ts

@@ -2,7 +2,7 @@
 // Agent-Termo Tool Executor — routes tool calls to implementations
 // =============================================================================
 
-import { readFile as readFileAsync, writeFile as writeFileAsync } from 'node:fs/promises';
+import { readFile as readFileAsync, writeFile as writeFileAsync, unlink as unlinkAsync } from 'node:fs/promises';
 import { resolve, isAbsolute, relative } from 'node:path';
 import { exec as execAsync } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -22,6 +22,7 @@ const TOOL_MAP: Record<string, (...args: any[]) => Promise<ToolResult>> = {
 	'file:read': toolFileRead,
 	'file:write': toolFileWrite,
 	'file:edit': toolFileEdit,
+	'file:delete': toolFileDelete,
 	'file:glob': toolFileGlob,
 	'grep': toolGrep,
 	'bash:execute': toolBash,
@@ -135,7 +136,7 @@ export async function applyFileChange(change: ProposedFileChange, projectRoot: s
 	try {
 		if (change.isDeletion) {
 			if (existsSync(fullPath)) {
-				await writeFileAsync(fullPath, '');
+					await unlinkAsync(fullPath);
 			}
 		} else {
 			const dir = resolve(fullPath, '..');
@@ -227,6 +228,25 @@ async function toolFileEdit(args: Record<string, unknown>, projectRoot: string):
 	}
 }
 
+async function toolFileDelete(args: Record<string, unknown>, projectRoot: string): Promise<ToolResult> {
+	const path = String(args.path ?? '');
+	if (!path) return { id: '', name: 'file:delete', success: false, error: 'path is required', durationMs: 0 };
+	if (!withinProject(path, projectRoot)) {
+		return { id: '', name: 'file:delete', success: false, error: 'Access denied: ' + path, durationMs: 0 };
+	}
+
+	const fullPath = toProjectPath(path, projectRoot);
+	try {
+		if (!existsSync(fullPath)) {
+			return { id: '', name: 'file:delete', success: false, error: 'File not found: ' + path, durationMs: 0 };
+		}
+		const existingContent = await readFileAsync(fullPath, 'utf-8');
+		return proposeFileChange(path, '', projectRoot, 'write', existingContent).result;
+	} catch (err) {
+		return { id: '', name: 'file:delete', success: false, error: 'Cannot delete ' + path + ': ' + (err instanceof Error ? err.message : String(err)), durationMs: 0 };
+	}
+}
+
 async function toolFileGlob(args: Record<string, unknown>, projectRoot: string): Promise<ToolResult> {
 	const globPattern = String(args.pattern ?? '');
 	if (!globPattern) return { id: '', name: 'file:glob', success: false, error: 'pattern is required', durationMs: 0 };

package/src/types/index.ts

@@ -13,6 +13,8 @@ export interface ConversationMessage extends Message {
 	id: string;
 	timestamp: Date;
 	agent?: string; // which agent produced this (for display badge)
+	/** Native tool calls attached to an assistant message. Required before tool results. */
+	toolCalls?: ToolCall[];
 }
 
 export interface ToolCall {