nine-hundred 0.0.1

package/dist/agent/tools/run_js_tool/run_js_tool.test.js

@@ -0,0 +1,67 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { runJsTool } from './index.js';
+let originalCwd;
+let tempRoot;
+let currentDir;
+let outsideDir;
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-run-js-'));
+    currentDir = path.join(tempRoot, 'current');
+    outsideDir = path.join(tempRoot, 'outside');
+    await mkdir(currentDir);
+    await mkdir(outsideDir);
+    process.chdir(currentDir);
+});
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('runJsTool', () => {
+    it('executes JavaScript and returns stdout', async () => {
+        const result = await runJsTool('console.log(1 + 2)');
+        expect(result).toContain('Exit code: 0');
+        expect(result).toContain('stdout:');
+        expect(result).toContain('3');
+    });
+    it('executes multiline JavaScript', async () => {
+        const result = await runJsTool(`
+      const values = [1, 2, 3];
+      console.log(values.map((value) => value * value).join(','));
+    `);
+        expect(result).toContain('1,4,9');
+    });
+    it('returns stdout and stderr', async () => {
+        const result = await runJsTool("console.error('warn'); console.log('ok');");
+        expect(result).toContain('ok');
+        expect(result).toContain('warn');
+    });
+    it('returns JavaScript errors to the caller', async () => {
+        const result = await runJsTool("throw new Error('boom');");
+        expect(result).toContain('JavaScript execution failed with exit code');
+        expect(result).toContain('Error: boom');
+    });
+    it('executes JavaScript in a nested working directory', async () => {
+        await mkdir('src');
+        await writeFile(path.join('src', 'data.txt'), 'nested data');
+        const result = await runJsTool("const fs = require('node:fs'); console.log(fs.readFileSync('data.txt', 'utf8'));", 'src');
+        expect(result).toContain('nested data');
+    });
+    it('rejects path traversal outside the current working directory', async () => {
+        await expect(runJsTool('console.log(1)', '..')).rejects.toThrow('Can only execute JavaScript inside the current working directory.');
+    });
+    it('rejects absolute working directories outside the current working directory', async () => {
+        await expect(runJsTool('console.log(1)', outsideDir)).rejects.toThrow('Can only execute JavaScript inside the current working directory.');
+    });
+    it('rejects symlink working directories that point outside the current working directory', async () => {
+        await symlink(outsideDir, 'outside-link');
+        await expect(runJsTool('console.log(1)', 'outside-link')).rejects.toThrow('Can only execute JavaScript inside the current working directory.');
+    });
+    it('rejects empty JavaScript code', async () => {
+        await expect(runJsTool('')).rejects.toThrow('JavaScript code is required.');
+        await expect(runJsTool('   ')).rejects.toThrow('JavaScript code is required.');
+    });
+});

package/dist/agent/tools/run_py_tool/index.js

@@ -0,0 +1,48 @@
+import { execFile } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const OUTSIDE_CWD_ERROR = 'Can only execute Python inside the current working directory.';
+const PYTHON_NOT_FOUND_MESSAGE = 'Python 3 is required to run Python code, but the "python3" executable was not found. Please install Python 3 and try again.';
+async function resolveWorkingDirectory(cwd) {
+    const root = await realpath(process.cwd());
+    const requestedCwd = path.resolve(root, cwd);
+    const targetCwd = await realpath(requestedCwd);
+    const relativePath = path.relative(root, targetCwd);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        throw new Error(OUTSIDE_CWD_ERROR);
+    }
+    const stats = await stat(targetCwd);
+    if (!stats.isDirectory()) {
+        throw new Error('Working directory must be a directory.');
+    }
+    return targetCwd;
+}
+function formatSuccess(stdout, stderr) {
+    return `Exit code: 0\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`;
+}
+function formatFailure(code, stdout, stderr) {
+    return `Python execution failed with exit code ${code}.\n\nstdout:\n${stdout}\n\nstderr:\n${stderr}`;
+}
+export async function runPyTool(code, cwd = '.') {
+    if (!code.trim()) {
+        throw new Error('Python code is required.');
+    }
+    const targetCwd = await resolveWorkingDirectory(cwd);
+    try {
+        const { stdout, stderr } = await execFileAsync('python3', ['-c', code], {
+            cwd: targetCwd,
+            timeout: 10_000,
+            maxBuffer: 1024 * 1024,
+        });
+        return formatSuccess(stdout, stderr);
+    }
+    catch (error) {
+        const execError = error;
+        if (execError.code === 'ENOENT') {
+            return PYTHON_NOT_FOUND_MESSAGE;
+        }
+        return formatFailure(execError.code ?? 'unknown', execError.stdout ?? '', execError.stderr ?? '');
+    }
+}

package/dist/agent/tools/run_py_tool/run_py_tool.test.js

@@ -0,0 +1,67 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { runPyTool } from './index.js';
+let originalCwd;
+let tempRoot;
+let currentDir;
+let outsideDir;
+beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-run-py-'));
+    currentDir = path.join(tempRoot, 'current');
+    outsideDir = path.join(tempRoot, 'outside');
+    await mkdir(currentDir);
+    await mkdir(outsideDir);
+    process.chdir(currentDir);
+});
+afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('runPyTool', () => {
+    it('executes Python and returns stdout', async () => {
+        const result = await runPyTool('print(1 + 2)');
+        expect(result).toContain('Exit code: 0');
+        expect(result).toContain('stdout:');
+        expect(result).toContain('3');
+    });
+    it('executes multiline Python', async () => {
+        const result = await runPyTool(`
+values = [1, 2, 3]
+print(','.join(str(value * value) for value in values))
+    `);
+        expect(result).toContain('1,4,9');
+    });
+    it('returns stdout and stderr', async () => {
+        const result = await runPyTool("import sys; print('warn', file=sys.stderr); print('ok')");
+        expect(result).toContain('ok');
+        expect(result).toContain('warn');
+    });
+    it('returns Python errors to the caller', async () => {
+        const result = await runPyTool("raise Exception('boom')");
+        expect(result).toContain('Python execution failed with exit code');
+        expect(result).toContain('Exception: boom');
+    });
+    it('executes Python in a nested working directory', async () => {
+        await mkdir('src');
+        await writeFile(path.join('src', 'data.txt'), 'nested data');
+        const result = await runPyTool("from pathlib import Path\nprint(Path('data.txt').read_text())", 'src');
+        expect(result).toContain('nested data');
+    });
+    it('rejects path traversal outside the current working directory', async () => {
+        await expect(runPyTool('print(1)', '..')).rejects.toThrow('Can only execute Python inside the current working directory.');
+    });
+    it('rejects absolute working directories outside the current working directory', async () => {
+        await expect(runPyTool('print(1)', outsideDir)).rejects.toThrow('Can only execute Python inside the current working directory.');
+    });
+    it('rejects symlink working directories that point outside the current working directory', async () => {
+        await symlink(outsideDir, 'outside-link');
+        await expect(runPyTool('print(1)', 'outside-link')).rejects.toThrow('Can only execute Python inside the current working directory.');
+    });
+    it('rejects empty Python code', async () => {
+        await expect(runPyTool('')).rejects.toThrow('Python code is required.');
+        await expect(runPyTool('   ')).rejects.toThrow('Python code is required.');
+    });
+});

package/dist/agent/tools/tool_logger.js

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+const MAX_SUMMARY_LENGTH = 120;
+export function logToolCall(toolName, summary) {
+    const safeSummary = summary ? ` ${chalk.yellow(truncateSummary(summary))}` : '';
+    console.log(`\n${chalk.dim.cyan('[Tool]')} ${chalk.cyan(toolName)} ${chalk.dim('called:')}${safeSummary}`);
+}
+export function formatToolArg(name, value) {
+    if (!value)
+        return undefined;
+    return `${name}=${JSON.stringify(truncateSummary(value))}`;
+}
+function truncateSummary(summary) {
+    if (summary.length <= MAX_SUMMARY_LENGTH)
+        return summary;
+    return `${summary.slice(0, MAX_SUMMARY_LENGTH - 1)}…`;
+}

package/dist/agent/tools/tool_logger.test.js

@@ -0,0 +1,22 @@
+import { stripVTControlCharacters } from 'node:util';
+import { describe, expect, it, vi } from 'vitest';
+import { formatToolArg, logToolCall } from './tool_logger.js';
+describe('tool logger', () => {
+    it('prints a colored tool call log with a plain text equivalent', () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        logToolCall('exec_tool', 'command="ls"');
+        expect(stripVTControlCharacters(logSpy.mock.calls[0]?.[0] ?? '').trim()).toBe('[Tool] exec_tool called: command="ls"');
+    });
+    it('formats string arguments as JSON values', () => {
+        expect(formatToolArg('filePath', 'src/index.ts')).toBe('filePath="src/index.ts"');
+    });
+    it('omits empty optional arguments', () => {
+        expect(formatToolArg('cwd', undefined)).toBeUndefined();
+        expect(formatToolArg('cwd', '')).toBeUndefined();
+    });
+    it('truncates long argument values', () => {
+        const value = 'a'.repeat(200);
+        expect(formatToolArg('command', value)).toHaveLength(130);
+        expect(formatToolArg('command', value)).toContain('…"');
+    });
+});

package/dist/agent/tools/web_fetch_url/index.js

@@ -0,0 +1,76 @@
+const MAX_RESPONSE_CHARS = 20_000;
+const FETCH_TIMEOUT_MS = 10_000;
+const SUPPORTED_PROTOCOLS = new Set(['http:', 'https:']);
+function parseHttpUrl(url) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        throw new Error('Invalid URL.');
+    }
+    if (!SUPPORTED_PROTOCOLS.has(parsedUrl.protocol)) {
+        throw new Error('Only HTTP and HTTPS URLs are supported.');
+    }
+    return parsedUrl;
+}
+function isTextContent(contentType) {
+    const normalizedContentType = contentType.toLowerCase();
+    return (!normalizedContentType ||
+        normalizedContentType.startsWith('text/') ||
+        normalizedContentType.includes('application/json') ||
+        normalizedContentType.includes('application/xml') ||
+        normalizedContentType.includes('application/xhtml+xml') ||
+        normalizedContentType.includes('application/javascript'));
+}
+function truncateContent(content) {
+    if (content.length <= MAX_RESPONSE_CHARS) {
+        return content;
+    }
+    return `${content.slice(0, MAX_RESPONSE_CHARS)}\n\n[Content truncated to ${MAX_RESPONSE_CHARS} characters.]`;
+}
+function formatFetchError(error) {
+    if (error instanceof Error && error.message) {
+        return `Web fetch failed: ${error.message}`;
+    }
+    return 'Web fetch failed.';
+}
+function formatStatus(response) {
+    return response.statusText ? `${response.status} ${response.statusText}` : String(response.status);
+}
+function formatResponse(url, response, contentType, content) {
+    return `URL: ${url.toString()}\nStatus: ${formatStatus(response)}\nContent-Type: ${contentType || 'unknown'}\n\n${content}`;
+}
+export async function webFetchUrl(url) {
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) {
+        throw new Error('URL is required.');
+    }
+    const parsedUrl = parseHttpUrl(trimmedUrl);
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const response = await fetch(parsedUrl.toString(), {
+            headers: {
+                Accept: 'text/html, application/json, text/plain, application/xml, */*',
+            },
+            signal: abortController.signal,
+        });
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!isTextContent(contentType)) {
+            const contentLength = response.headers.get('content-length') ?? 'unknown';
+            return `URL: ${parsedUrl.toString()}\nStatus: ${formatStatus(response)}\nContent-Type: ${contentType}\n\nFetched non-text resource (${contentLength} bytes).`;
+        }
+        const content = truncateContent(await response.text());
+        if (!response.ok) {
+            return `Web fetch failed: HTTP ${formatStatus(response)}\n\n${formatResponse(parsedUrl, response, contentType, content)}`;
+        }
+        return formatResponse(parsedUrl, response, contentType, content);
+    }
+    catch (error) {
+        return formatFetchError(error);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/agent/tools/web_fetch_url/web_fetch_url.test.js

@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { webFetchUrl } from './index.js';
+const fetchMock = vi.fn();
+function createHeaders(headers) {
+    return new Headers(headers);
+}
+function createResponse({ body, headers = { 'content-type': 'text/html; charset=utf-8' }, ok = true, status = 200, statusText = 'OK', }) {
+    return {
+        headers: createHeaders(headers),
+        ok,
+        status,
+        statusText,
+        text: vi.fn().mockResolvedValue(body),
+    };
+}
+beforeEach(() => {
+    fetchMock.mockReset();
+    vi.stubGlobal('fetch', fetchMock);
+});
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+describe('webFetchUrl', () => {
+    it('fetches text content from a URL', async () => {
+        fetchMock.mockResolvedValue(createResponse({ body: '<html>Hello</html>' }));
+        const result = await webFetchUrl('https://example.com/');
+        expect(fetchMock).toHaveBeenCalledWith('https://example.com/', expect.objectContaining({
+            headers: expect.objectContaining({
+                Accept: 'text/html, application/json, text/plain, application/xml, */*',
+            }),
+        }));
+        expect(result).toContain('URL: https://example.com/');
+        expect(result).toContain('Status: 200 OK');
+        expect(result).toContain('Content-Type: text/html; charset=utf-8');
+        expect(result).toContain('<html>Hello</html>');
+    });
+    it('fetches JSON content from a URL', async () => {
+        fetchMock.mockResolvedValue(createResponse({
+            body: '{"ok":true}',
+            headers: { 'content-type': 'application/json' },
+        }));
+        const result = await webFetchUrl('https://api.example.com/data');
+        expect(result).toContain('Content-Type: application/json');
+        expect(result).toContain('{"ok":true}');
+    });
+    it('trims the URL before fetching', async () => {
+        fetchMock.mockResolvedValue(createResponse({ body: 'ok' }));
+        await webFetchUrl('  https://example.com/path  ');
+        expect(fetchMock).toHaveBeenCalledWith('https://example.com/path', expect.any(Object));
+    });
+    it('rejects empty URLs', async () => {
+        await expect(webFetchUrl('')).rejects.toThrow('URL is required.');
+        await expect(webFetchUrl('   ')).rejects.toThrow('URL is required.');
+    });
+    it('rejects invalid URLs', async () => {
+        await expect(webFetchUrl('not-a-url')).rejects.toThrow('Invalid URL.');
+    });
+    it('rejects non-HTTP URLs', async () => {
+        await expect(webFetchUrl('file:///etc/passwd')).rejects.toThrow('Only HTTP and HTTPS URLs are supported.');
+        await expect(webFetchUrl('ftp://example.com/file')).rejects.toThrow('Only HTTP and HTTPS URLs are supported.');
+    });
+    it('returns a readable failure for non-OK HTTP responses', async () => {
+        fetchMock.mockResolvedValue(createResponse({
+            body: 'missing',
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+        }));
+        const result = await webFetchUrl('https://example.com/missing');
+        expect(result).toContain('Web fetch failed: HTTP 404 Not Found');
+        expect(result).toContain('missing');
+    });
+    it('returns a readable failure when fetch throws an Error', async () => {
+        fetchMock.mockRejectedValue(new Error('getaddrinfo ENOTFOUND example.test'));
+        await expect(webFetchUrl('https://example.test/')).resolves.toBe('Web fetch failed: getaddrinfo ENOTFOUND example.test');
+    });
+    it('returns a generic failure when fetch throws a non-error value', async () => {
+        fetchMock.mockRejectedValue('boom');
+        await expect(webFetchUrl('https://example.com/')).resolves.toBe('Web fetch failed.');
+    });
+    it('truncates long text responses', async () => {
+        fetchMock.mockResolvedValue(createResponse({ body: 'a'.repeat(20_001) }));
+        const result = await webFetchUrl('https://example.com/long');
+        expect(result).toContain('a'.repeat(20_000));
+        expect(result).toContain('[Content truncated to 20000 characters.]');
+    });
+    it('returns metadata for non-text resources', async () => {
+        const response = createResponse({
+            body: 'binary',
+            headers: {
+                'content-length': '1024',
+                'content-type': 'image/png',
+            },
+        });
+        const textMock = vi.mocked(response.text);
+        fetchMock.mockResolvedValue(response);
+        const result = await webFetchUrl('https://example.com/image.png');
+        expect(textMock).not.toHaveBeenCalled();
+        expect(result).toContain('Content-Type: image/png');
+        expect(result).toContain('Fetched non-text resource (1024 bytes).');
+    });
+});

package/dist/agent/tools/web_search_tool/index.js

@@ -0,0 +1,26 @@
+import { TavilySearch } from '@langchain/tavily';
+import { getEnvValue } from '../../config/index.js';
+function formatSearchError(error) {
+    if (error instanceof Error && error.message) {
+        return `Web search failed: ${error.message}`;
+    }
+    return 'Web search failed.';
+}
+export async function webSearchTool(query) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        throw new Error('Search query is required.');
+    }
+    try {
+        const tavilySearch = new TavilySearch({
+            maxResults: 3,
+            topic: 'general',
+            tavilyApiKey: getEnvValue('TAVILY_API_KEY'),
+        });
+        const result = await tavilySearch.invoke({ query: trimmedQuery });
+        return typeof result === 'string' ? result : JSON.stringify(result);
+    }
+    catch (error) {
+        return formatSearchError(error);
+    }
+}

package/dist/agent/tools/web_search_tool/web_search_tool.test.js

@@ -0,0 +1,61 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { webSearchTool } from './index.js';
+const { invokeMock, tavilySearchMock } = vi.hoisted(() => {
+    const invokeMock = vi.fn();
+    const tavilySearchMock = vi.fn(function () {
+        return {
+            invoke: invokeMock,
+        };
+    });
+    return { invokeMock, tavilySearchMock };
+});
+vi.mock('@langchain/tavily', () => ({
+    TavilySearch: tavilySearchMock,
+}));
+vi.mock('../../config/index.js', () => ({
+    getEnvValue: vi.fn(() => undefined),
+}));
+beforeEach(() => {
+    invokeMock.mockReset();
+    tavilySearchMock.mockClear();
+});
+describe('webSearchTool', () => {
+    it('searches the web with Tavily', async () => {
+        invokeMock.mockResolvedValue('mocked result');
+        await expect(webSearchTool('LangChain Tavily')).resolves.toBe('mocked result');
+        expect(tavilySearchMock).toHaveBeenCalledWith({
+            maxResults: 3,
+            topic: 'general',
+        });
+        expect(invokeMock).toHaveBeenCalledWith({ query: 'LangChain Tavily' });
+    });
+    it('trims the search query before invoking Tavily', async () => {
+        invokeMock.mockResolvedValue('trimmed result');
+        await expect(webSearchTool('  latest AI news  ')).resolves.toBe('trimmed result');
+        expect(invokeMock).toHaveBeenCalledWith({ query: 'latest AI news' });
+    });
+    it('rejects empty search queries', async () => {
+        await expect(webSearchTool('')).rejects.toThrow('Search query is required.');
+        await expect(webSearchTool('   ')).rejects.toThrow('Search query is required.');
+    });
+    it('serializes non-string Tavily results', async () => {
+        const result = {
+            results: [
+                {
+                    title: 'Example',
+                    url: 'https://example.com',
+                },
+            ],
+        };
+        invokeMock.mockResolvedValue(result);
+        await expect(webSearchTool('example')).resolves.toBe(JSON.stringify(result));
+    });
+    it('returns a readable error when Tavily search fails', async () => {
+        invokeMock.mockRejectedValue(new Error('Invalid API key'));
+        await expect(webSearchTool('example')).resolves.toBe('Web search failed: Invalid API key');
+    });
+    it('returns a generic error when Tavily throws a non-error value', async () => {
+        invokeMock.mockRejectedValue('boom');
+        await expect(webSearchTool('example')).resolves.toBe('Web search failed.');
+    });
+});

package/dist/agent/tools/write_file_tool/index.js

@@ -0,0 +1,22 @@
+import { mkdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export async function writeFileTool(filePath, content) {
+    if (!filePath.trim()) {
+        throw new Error('File path is required.');
+    }
+    const target = path.resolve(filePath);
+    try {
+        const stats = await stat(target);
+        if (!stats.isFile()) {
+            throw new Error('Can only write regular files.');
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    await mkdir(path.dirname(target), { recursive: true });
+    await writeFile(target, content, 'utf8');
+    return `Wrote file: ${target}`;
+}

package/dist/agent/tools/write_file_tool/write_file_tool.test.js

@@ -0,0 +1,46 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { writeFileTool } from './index.js';
+let tempRoot;
+beforeEach(async () => {
+    tempRoot = await mkdtemp(path.join(tmpdir(), 'argos-write-file-'));
+});
+afterEach(async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+});
+describe('writeFileTool', () => {
+    it('writes a file by absolute path', async () => {
+        const filePath = path.join(tempRoot, 'hello.txt');
+        await expect(writeFileTool(filePath, 'hello argos')).resolves.toBe(`Wrote file: ${filePath}`);
+        await expect(readFile(filePath, 'utf8')).resolves.toBe('hello argos');
+    });
+    it('writes a nested file', async () => {
+        const filePath = path.join(tempRoot, 'nested', 'hello.txt');
+        await expect(writeFileTool(filePath, 'nested hello')).resolves.toBe(`Wrote file: ${filePath}`);
+        await expect(readFile(filePath, 'utf8')).resolves.toBe('nested hello');
+    });
+    it('overwrites an existing regular file', async () => {
+        const filePath = path.join(tempRoot, 'hello.txt');
+        await writeFile(filePath, 'old content');
+        await expect(writeFileTool(filePath, 'new content')).resolves.toBe(`Wrote file: ${filePath}`);
+        await expect(readFile(filePath, 'utf8')).resolves.toBe('new content');
+    });
+    it('writes a file by relative path', async () => {
+        const result = await writeFileTool('hello-relative.txt', 'hello relative');
+        expect(result).toMatch(/Wrote file: .*hello-relative\.txt$/);
+        const resolvedPath = path.resolve('hello-relative.txt');
+        await expect(readFile(resolvedPath, 'utf8')).resolves.toBe('hello relative');
+        await rm(resolvedPath);
+    });
+    it('rejects writing to directories', async () => {
+        const dirPath = path.join(tempRoot, 'nested');
+        await mkdir(dirPath);
+        await expect(writeFileTool(dirPath, 'content')).rejects.toThrow('Can only write regular files.');
+    });
+    it('rejects empty paths', async () => {
+        await expect(writeFileTool('', 'content')).rejects.toThrow('File path is required.');
+        await expect(writeFileTool('   ', 'content')).rejects.toThrow('File path is required.');
+    });
+});