lcagent-cli 0.1.4 → 0.1.6

package/README.md

@@ -139,6 +139,14 @@ npm run start -- model
 npm run start -- doctor
 ```
 
+当模型触发工具时，CLI 会打印：
+
+- `[tool-call] 工具名`：后面跟模型传入的原始 JSON 参数
+- `[tool-result] 工具名`：显示工具执行结果
+- `[tool-result] 工具名 (error)`：显示工具失败原因
+
+这样可以直接看出是模型参数字段名不对、路径不对，还是工具执行本身报错。
+
 ## 设计目标
 
 - 保留 Claude Code 式的核心代理循环
@@ -165,4 +173,4 @@ npm run start -- doctor
 npm run start -- doctor
 ```
 
-`doctor` 会额外探测多个端点（如 `/v1`、`/v1/models`、`/v1/chat/completions`），并尽量打印底层网络错误，方便区分 DNS、TCP 超时、HTTP 返回和认证问题。
+`doctor` 会额外探测多个端点（如 `/v1`、`/v1/models`、`/v1/chat/completions`），并尽量打印底层网络错误；对于 OpenAI-compatible 服务，还会额外检查 tool calling 是否真的返回 `tool_calls`。

package/dist/bin/cli.js

@@ -7,6 +7,7 @@ import { fetch } from '../core/http.js';
 import { agentConfigSchema } from '../config/schema.js';
 import { getConfigPath, loadConfig, updateConfig } from '../config/store.js';
 import { getDefaultTools } from '../tools/registry.js';
+import { toOpenAICompatibleTool } from '../tools/types.js';
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, '');
 }
@@ -45,6 +46,32 @@ function questionAsync(rl, prompt) {
         });
     });
 }
+function formatToolInput(input) {
+    try {
+        return JSON.stringify(input, null, 2);
+    }
+    catch {
+        return String(input);
+    }
+}
+function printEvent(event) {
+    switch (event.type) {
+        case 'status':
+            console.log(`\n[status] ${event.message}`);
+            break;
+        case 'assistant_text':
+            console.log(`\n${event.text}`);
+            break;
+        case 'tool_call':
+            console.log(`\n[tool-call] ${event.toolName}`);
+            console.log(formatToolInput(event.input));
+            break;
+        case 'tool_result':
+            console.log(`\n[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
+            console.log(event.result);
+            break;
+    }
+}
 async function probeUrl(url) {
     try {
         const response = await fetchWithTimeout(url, {
@@ -80,6 +107,55 @@ async function runJsonProbe(params) {
         console.log(`  failed: ${formatError(error)}`);
     }
 }
+async function runOpenAIToolCallingProbe(params) {
+    const tool = toOpenAICompatibleTool(getDefaultTools()[0]);
+    console.log(`- POST /v1/chat/completions (tool calling): ${params.url}`);
+    try {
+        const response = await fetchWithTimeout(params.url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(params.apiKey ? { Authorization: `Bearer ${params.apiKey}` } : {}),
+            },
+            body: JSON.stringify({
+                model: params.model,
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'Call the read_file tool with path set to README.md. Do not answer with plain text only.',
+                    },
+                ],
+                tools: [tool],
+                tool_choice: 'auto',
+                max_tokens: 128,
+            }),
+        }, 8000);
+        const text = await response.text();
+        console.log(`  HTTP ${response.status}`);
+        console.log(`  preview: ${text.slice(0, 300) || '(empty body)'}`);
+        try {
+            const parsed = JSON.parse(text);
+            const toolCalls = parsed.choices?.[0]?.message?.tool_calls;
+            if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+                console.log(`  tool calling: supported (${toolCalls.length} tool call returned)`);
+            }
+            else {
+                const finishReason = parsed.choices?.[0]?.finish_reason ?? 'unknown';
+                const content = parsed.choices?.[0]?.message?.content ?? '';
+                console.log(`  tool calling: no tool_calls returned (finish_reason=${finishReason})`);
+                if (content) {
+                    console.log(`  assistant content: ${String(content).slice(0, 160)}`);
+                }
+            }
+        }
+        catch {
+            console.log('  tool calling: unable to parse JSON response body');
+        }
+    }
+    catch (error) {
+        console.log(`  failed: ${formatError(error)}`);
+    }
+}
 async function runDoctor() {
     const config = await loadConfig();
     const apiKey = config.apiKey ??
@@ -124,6 +200,11 @@ async function runDoctor() {
                 max_tokens: 8,
             }),
         });
+        await runOpenAIToolCallingProbe({
+            url: `${trimmedBaseUrl}/chat/completions`,
+            apiKey,
+            model: config.model,
+        });
         return;
     }
     await runJsonProbe({
@@ -150,21 +231,7 @@ async function runDoctor() {
 async function printAgentRun(prompt) {
     const { engine } = await createApp(process.cwd());
     for await (const event of engine.submit(prompt)) {
-        switch (event.type) {
-            case 'status':
-                console.log(`\n[status] ${event.message}`);
-                break;
-            case 'assistant_text':
-                console.log(`\n${event.text}`);
-                break;
-            case 'tool_call':
-                console.log(`\n[tool] ${event.toolName} ${JSON.stringify(event.input)}`);
-                break;
-            case 'tool_result':
-                console.log(`\n[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
-                console.log(event.result);
-                break;
-        }
+        printEvent(event);
     }
 }
 async function runChat() {
@@ -182,21 +249,7 @@ async function runChat() {
                 break;
             }
             for await (const event of engine.submit(line)) {
-                switch (event.type) {
-                    case 'status':
-                        console.log(`[status] ${event.message}`);
-                        break;
-                    case 'assistant_text':
-                        console.log(event.text);
-                        break;
-                    case 'tool_call':
-                        console.log(`[tool] ${event.toolName} ${JSON.stringify(event.input)}`);
-                        break;
-                    case 'tool_result':
-                        console.log(`[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
-                        console.log(event.result);
-                        break;
-                }
+                printEvent(event);
             }
         }
     }

package/dist/tools/editFile.d.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-    oldText: z.ZodString;
-    newText: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodString>;
+    oldText: z.ZodOptional<z.ZodString>;
+    old_text: z.ZodOptional<z.ZodString>;
+    newText: z.ZodOptional<z.ZodString>;
+    new_text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const editFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/editFile.js

@@ -2,9 +2,13 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    path: z.string().min(1),
-    oldText: z.string(),
-    newText: z.string(),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
+    oldText: z.string().optional(),
+    old_text: z.string().optional(),
+    newText: z.string().optional(),
+    new_text: z.string().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
@@ -31,18 +35,27 @@ export const editFileTool = {
                 content: 'edit_file is blocked in manual approval mode. Switch config approvalMode to auto to enable file edits.',
             };
         }
-        const absolutePath = resolvePath(context.cwd, input.path);
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        const oldText = input.oldText ?? input.old_text;
+        const newText = input.newText ?? input.new_text;
+        if (!normalizedPath || oldText === undefined || newText === undefined) {
+            return {
+                isError: true,
+                content: 'Missing required fields: path, oldText, or newText',
+            };
+        }
+        const absolutePath = resolvePath(context.cwd, normalizedPath);
         const current = await readFile(absolutePath, 'utf8');
-        if (!current.includes(input.oldText)) {
+        if (!current.includes(oldText)) {
             return {
                 isError: true,
                 content: 'oldText was not found in the target file.',
             };
         }
-        const next = current.replace(input.oldText, input.newText);
+        const next = current.replace(oldText, newText);
         await writeFile(absolutePath, next, 'utf8');
         return {
-            content: `Updated ${input.path}`,
+            content: `Updated ${normalizedPath}`,
         };
     },
 };

package/dist/tools/execute.js

@@ -13,5 +13,13 @@ export async function executeToolCall(toolUse, tools, context) {
             content: parsed.error.message,
         };
     }
-    return tool.execute(parsed.data, context);
+    try {
+        return await tool.execute(parsed.data, context);
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: error instanceof Error ? error.message : String(error),
+        };
+    }
 }

package/dist/tools/grep.d.ts

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
+    pattern: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
+    directory: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
+    max_results: z.ZodOptional<z.ZodNumber>;
     isRegex: z.ZodOptional<z.ZodBoolean>;
+    is_regex: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const grepTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/grep.js

@@ -2,10 +2,14 @@ import { readdir, readFile } from 'node:fs/promises';
 import { extname, isAbsolute, join, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    pattern: z.string().min(1),
+    pattern: z.string().min(1).optional(),
+    query: z.string().min(1).optional(),
     path: z.string().optional(),
+    directory: z.string().optional(),
     maxResults: z.number().int().positive().max(200).optional(),
+    max_results: z.number().int().positive().max(200).optional(),
     isRegex: z.boolean().optional(),
+    is_regex: z.boolean().optional(),
 });
 const textExtensions = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', '.yml', '.yaml', '.css', '.html', '.mjs', '.cjs', '.sh', '.py', '.java', '.go', '.rs'
@@ -44,17 +48,26 @@ export const grepTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const root = input.path
-            ? isAbsolute(input.path)
-                ? input.path
-                : resolve(context.cwd, input.path)
+        const pattern = input.pattern ?? input.query;
+        if (!pattern) {
+            return {
+                isError: true,
+                content: 'Missing required field: pattern',
+            };
+        }
+        const searchPath = input.path ?? input.directory;
+        const root = searchPath
+            ? isAbsolute(searchPath)
+                ? searchPath
+                : resolve(context.cwd, searchPath)
             : context.cwd;
-        const matcher = input.isRegex
-            ? new RegExp(input.pattern, 'i')
+        const isRegex = input.isRegex ?? input.is_regex;
+        const matcher = isRegex
+            ? new RegExp(pattern, 'i')
             : null;
         const files = await walk(root);
         const results = [];
-        const maxResults = input.maxResults ?? 50;
+        const maxResults = input.maxResults ?? input.max_results ?? 50;
         for (const filePath of files) {
             if (!textExtensions.has(extname(filePath))) {
                 continue;
@@ -68,7 +81,7 @@ export const grepTool = {
                 const line = lines[index] ?? '';
                 const matched = matcher
                     ? matcher.test(line)
-                    : line.toLowerCase().includes(input.pattern.toLowerCase());
+                    : line.toLowerCase().includes(pattern.toLowerCase());
                 if (!matched) {
                     continue;
                 }

package/dist/tools/readFile.d.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodString>;
     startLine: z.ZodOptional<z.ZodNumber>;
+    start_line: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const readFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/readFile.js

@@ -2,9 +2,13 @@ import { readFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    path: z.string().min(1),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
     startLine: z.number().int().positive().optional(),
+    start_line: z.number().int().positive().optional(),
     endLine: z.number().int().positive().optional(),
+    end_line: z.number().int().positive().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
@@ -25,11 +29,20 @@ export const readFileTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const absolutePath = resolvePath(context.cwd, input.path);
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        if (!normalizedPath) {
+            return {
+                isError: true,
+                content: 'Missing required field: path',
+            };
+        }
+        const startLine = input.startLine ?? input.start_line;
+        const endLine = input.endLine ?? input.end_line;
+        const absolutePath = resolvePath(context.cwd, normalizedPath);
         const contents = await readFile(absolutePath, 'utf8');
         const lines = contents.split(/\r?\n/);
-        const start = Math.max((input.startLine ?? 1) - 1, 0);
-        const end = Math.min(input.endLine ?? lines.length, lines.length);
+        const start = Math.max((startLine ?? 1) - 1, 0);
+        const end = Math.min(endLine ?? lines.length, lines.length);
         const slice = lines.slice(start, end);
         const numbered = slice
             .map((line, index) => `${start + index + 1}: ${line}`)

package/dist/tools/runShell.d.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    command: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const runShellTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/runShell.js

@@ -3,7 +3,8 @@ import { promisify } from 'node:util';
 import { z } from 'zod';
 const execAsync = promisify(exec);
 const inputSchema = z.object({
-    command: z.string().min(1),
+    command: z.string().min(1).optional(),
+    cmd: z.string().min(1).optional(),
 });
 export const runShellTool = {
     name: 'run_shell',
@@ -29,9 +30,16 @@ export const runShellTool = {
             };
         }
         try {
-            const { stdout, stderr } = await execAsync(input.command, {
+            const command = input.command ?? input.cmd;
+            if (!command) {
+                return {
+                    isError: true,
+                    content: 'Missing required field: command',
+                };
+            }
+            const { stdout, stderr } = await execAsync(command, {
                 cwd: context.cwd,
-                shell: '/bin/sh',
+                shell: process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : '/bin/sh',
                 maxBuffer: 1024 * 1024,
             });
             const output = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lcagent-cli",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A minimal coding agent CLI for terminal-based coding workflows.",
   "type": "module",
   "publishConfig": {